Split testb3 into multiple files
[WebKit-https.git] / Source / JavaScriptCore / b3 / testb3.h
1 /*
2  * Copyright (C) 2019 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "AirCode.h"
27 #include "AirInstInlines.h"
28 #include "AirValidate.h"
29 #include "AllowMacroScratchRegisterUsage.h"
30 #include "B3ArgumentRegValue.h"
31 #include "B3AtomicValue.h"
32 #include "B3BasicBlockInlines.h"
33 #include "B3BreakCriticalEdges.h"
34 #include "B3CCallValue.h"
35 #include "B3Compilation.h"
36 #include "B3Compile.h"
37 #include "B3ComputeDivisionMagic.h"
38 #include "B3Const32Value.h"
39 #include "B3Const64Value.h"
40 #include "B3ConstPtrValue.h"
41 #include "B3Effects.h"
42 #include "B3FenceValue.h"
43 #include "B3FixSSA.h"
44 #include "B3Generate.h"
45 #include "B3LowerToAir.h"
46 #include "B3MathExtras.h"
47 #include "B3MemoryValue.h"
48 #include "B3MoveConstants.h"
49 #include "B3NativeTraits.h"
50 #include "B3Procedure.h"
51 #include "B3ReduceStrength.h"
52 #include "B3SlotBaseValue.h"
53 #include "B3StackSlot.h"
54 #include "B3StackmapGenerationParams.h"
55 #include "B3SwitchValue.h"
56 #include "B3UpsilonValue.h"
57 #include "B3UseCounts.h"
58 #include "B3Validate.h"
59 #include "B3ValueInlines.h"
60 #include "B3VariableValue.h"
61 #include "B3WasmAddressValue.h"
62 #include "B3WasmBoundsCheckValue.h"
63 #include "CCallHelpers.h"
64 #include "FPRInfo.h"
65 #include "GPRInfo.h"
66 #include "InitializeThreading.h"
67 #include "JSCInlines.h"
68 #include "LinkBuffer.h"
69 #include "PureNaN.h"
70 #include <cmath>
71 #include <string>
72 #include <wtf/FastTLS.h>
73 #include <wtf/IndexSet.h>
74 #include <wtf/ListDump.h>
75 #include <wtf/Lock.h>
76 #include <wtf/NumberOfCores.h>
77 #include <wtf/StdList.h>
78 #include <wtf/Threading.h>
79 #include <wtf/text/StringCommon.h>
80
81 // We don't have a NO_RETURN_DUE_TO_EXIT, nor should we. That's ridiculous.
82 inline bool hiddenTruthBecauseNoReturnIsStupid() { return true; }
83
84 inline void usage()
85 {
86     dataLog("Usage: testb3 [<filter>]\n");
87     if (hiddenTruthBecauseNoReturnIsStupid())
88         exit(1);
89 }
90
91 #if ENABLE(B3_JIT)
92
93 using namespace JSC;
94 using namespace JSC::B3;
95
96 inline bool shouldBeVerbose()
97 {
98     return shouldDumpIR(B3Mode);
99 }
100
101 extern Lock crashLock;
102
103 // Nothing fancy for now; we just use the existing WTF assertion machinery.
104 #define CHECK(x) do {                                                   \
105     if (!!(x))                                                      \
106         break;                                                      \
107     crashLock.lock();                                               \
108     WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #x); \
109     CRASH();                                                        \
110 } while (false)
111     
112 #define CHECK_EQ(x, y) do { \
113     auto __x = (x); \
114     auto __y = (y); \
115     if (__x == __y) \
116         break; \
117     crashLock.lock(); \
118     WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, toCString(#x " == " #y, " (" #x " == ", __x, ", " #y " == ", __y, ")").data()); \
119     CRASH(); \
120 } while (false)
121
122 #define PREFIX "O", Options::defaultB3OptLevel(), ": "
123
124 #define RUN(test) do {                             \
125     if (!shouldRun(filter, #test))                 \
126         break;                                     \
127     tasks.append(                                  \
128         createSharedTask<void()>(                  \
129             [&] () {                               \
130                 dataLog(PREFIX #test "...\n");     \
131                 test;                              \
132                 dataLog(PREFIX #test ": OK!\n");   \
133             }));                                   \
134     } while (false);
135
136 #define RUN_UNARY(test, values) \
137     for (auto a : values) {                             \
138         CString testStr = toCString(PREFIX #test, "(", a.name, ")"); \
139         if (!shouldRun(filter, testStr.data()))         \
140             continue;                                   \
141         tasks.append(createSharedTask<void()>(          \
142             [=] () {                                    \
143                 dataLog(toCString(testStr, "...\n"));   \
144                 test(a.value);                          \
145                 dataLog(toCString(testStr, ": OK!\n")); \
146             }));                                        \
147     }
148
149 #define RUN_NOW(test) do {                      \
150         if (!shouldRun(filter, #test))          \
151             break;                              \
152         dataLog(PREFIX #test "...\n");          \
153         test;                                   \
154         dataLog(PREFIX #test ": OK!\n");        \
155     } while (false)
156
157 #define RUN_BINARY(test, valuesA, valuesB) \
158     for (auto a : valuesA) {                                \
159         for (auto b : valuesB) {                            \
160             CString testStr = toCString(PREFIX #test, "(", a.name, ", ", b.name, ")"); \
161             if (!shouldRun(filter, testStr.data()))         \
162                 continue;                                   \
163             tasks.append(createSharedTask<void()>(          \
164                 [=] () {                                    \
165                     dataLog(toCString(testStr, "...\n"));   \
166                     test(a.value, b.value);                 \
167                     dataLog(toCString(testStr, ": OK!\n")); \
168                 }));                                        \
169         }                                                   \
170     }
171 #define RUN_TERNARY(test, valuesA, valuesB, valuesC) \
172     for (auto a : valuesA) {                                    \
173         for (auto b : valuesB) {                                \
174             for (auto c : valuesC) {                            \
175                 CString testStr = toCString(#test, "(", a.name, ", ", b.name, ",", c.name, ")"); \
176                 if (!shouldRun(filter, testStr.data()))         \
177                     continue;                                   \
178                 tasks.append(createSharedTask<void()>(          \
179                     [=] () {                                    \
180                         dataLog(toCString(testStr, "...\n"));   \
181                         test(a.value, b.value, c.value);        \
182                         dataLog(toCString(testStr, ": OK!\n")); \
183                     }));                                        \
184             }                                                   \
185         }                                                       \
186     }
187
188
189 inline std::unique_ptr<Compilation> compileProc(Procedure& procedure, unsigned optLevel = Options::defaultB3OptLevel())
190 {
191     procedure.setOptLevel(optLevel);
192     return std::make_unique<Compilation>(B3::compile(procedure));
193 }
194
195 template<typename T, typename... Arguments>
196 T invoke(MacroAssemblerCodePtr<B3CompilationPtrTag> ptr, Arguments... arguments)
197 {
198     void* executableAddress = untagCFunctionPtr<B3CompilationPtrTag>(ptr.executableAddress());
199     T (*function)(Arguments...) = bitwise_cast<T(*)(Arguments...)>(executableAddress);
200     return function(arguments...);
201 }
202
203 template<typename T, typename... Arguments>
204 T invoke(const Compilation& code, Arguments... arguments)
205 {
206     return invoke<T>(code.code(), arguments...);
207 }
208
209 template<typename T, typename... Arguments>
210 T compileAndRun(Procedure& procedure, Arguments... arguments)
211 {
212     return invoke<T>(*compileProc(procedure), arguments...);
213 }
214
215 inline void lowerToAirForTesting(Procedure& proc)
216 {
217     proc.resetReachability();
218     
219     if (shouldBeVerbose())
220         dataLog("B3 before lowering:\n", proc);
221     
222     validate(proc);
223     lowerToAir(proc);
224     
225     if (shouldBeVerbose())
226         dataLog("Air after lowering:\n", proc.code());
227     
228     Air::validate(proc.code());
229 }
230
231 template<typename Func>
232 void checkDisassembly(Compilation& compilation, const Func& func, const CString& failText)
233 {
234     CString disassembly = compilation.disassembly();
235     if (func(disassembly.data()))
236         return;
237     
238     crashLock.lock();
239     dataLog("Bad lowering!  ", failText, "\n");
240     dataLog(disassembly);
241     CRASH();
242 }
243
244 inline void checkUsesInstruction(Compilation& compilation, const char* text)
245 {
246     checkDisassembly(
247         compilation,
248         [&] (const char* disassembly) -> bool {
249             return strstr(disassembly, text);
250         },
251         toCString("Expected to find ", text, " but didnt!"));
252 }
253
254 inline void checkDoesNotUseInstruction(Compilation& compilation, const char* text)
255 {
256     checkDisassembly(
257         compilation,
258         [&] (const char* disassembly) -> bool {
259             return !strstr(disassembly, text);
260         },
261         toCString("Did not expected to find ", text, " but it's there!"));
262 }
263
264 template<typename Type>
265 struct Operand {
266     const char* name;
267     Type value;
268 };
269
270 typedef Operand<int64_t> Int64Operand;
271 typedef Operand<int32_t> Int32Operand;
272
273 template<typename FloatType>
274 void populateWithInterestingValues(Vector<Operand<FloatType>>& operands)
275 {
276     operands.append({ "0.", static_cast<FloatType>(0.) });
277     operands.append({ "-0.", static_cast<FloatType>(-0.) });
278     operands.append({ "0.4", static_cast<FloatType>(0.5) });
279     operands.append({ "-0.4", static_cast<FloatType>(-0.5) });
280     operands.append({ "0.5", static_cast<FloatType>(0.5) });
281     operands.append({ "-0.5", static_cast<FloatType>(-0.5) });
282     operands.append({ "0.6", static_cast<FloatType>(0.5) });
283     operands.append({ "-0.6", static_cast<FloatType>(-0.5) });
284     operands.append({ "1.", static_cast<FloatType>(1.) });
285     operands.append({ "-1.", static_cast<FloatType>(-1.) });
286     operands.append({ "2.", static_cast<FloatType>(2.) });
287     operands.append({ "-2.", static_cast<FloatType>(-2.) });
288     operands.append({ "M_PI", static_cast<FloatType>(M_PI) });
289     operands.append({ "-M_PI", static_cast<FloatType>(-M_PI) });
290     operands.append({ "min", std::numeric_limits<FloatType>::min() });
291     operands.append({ "max", std::numeric_limits<FloatType>::max() });
292     operands.append({ "lowest", std::numeric_limits<FloatType>::lowest() });
293     operands.append({ "epsilon", std::numeric_limits<FloatType>::epsilon() });
294     operands.append({ "infiniti", std::numeric_limits<FloatType>::infinity() });
295     operands.append({ "-infiniti", - std::numeric_limits<FloatType>::infinity() });
296     operands.append({ "PNaN", static_cast<FloatType>(PNaN) });
297 }
298
299 template<typename FloatType>
300 Vector<Operand<FloatType>> floatingPointOperands()
301 {
302     Vector<Operand<FloatType>> operands;
303     populateWithInterestingValues(operands);
304     return operands;
305 };
306
307 inline Vector<Int64Operand> int64Operands()
308 {
309     Vector<Int64Operand> operands;
310     operands.append({ "0", 0 });
311     operands.append({ "1", 1 });
312     operands.append({ "-1", -1 });
313     operands.append({ "42", 42 });
314     operands.append({ "-42", -42 });
315     operands.append({ "int64-max", std::numeric_limits<int64_t>::max() });
316     operands.append({ "int64-min", std::numeric_limits<int64_t>::min() });
317     operands.append({ "int32-max", std::numeric_limits<int32_t>::max() });
318     operands.append({ "int32-min", std::numeric_limits<int32_t>::min() });
319     operands.append({ "uint64-max", static_cast<int64_t>(std::numeric_limits<uint64_t>::max()) });
320     operands.append({ "uint64-min", static_cast<int64_t>(std::numeric_limits<uint64_t>::min()) });
321     operands.append({ "uint32-max", static_cast<int64_t>(std::numeric_limits<uint32_t>::max()) });
322     operands.append({ "uint32-min", static_cast<int64_t>(std::numeric_limits<uint32_t>::min()) });
323     
324     return operands;
325 }
326
327 inline Vector<Int32Operand> int32Operands()
328 {
329     Vector<Int32Operand> operands({
330         { "0", 0 },
331         { "1", 1 },
332         { "-1", -1 },
333         { "42", 42 },
334         { "-42", -42 },
335         { "int32-max", std::numeric_limits<int32_t>::max() },
336         { "int32-min", std::numeric_limits<int32_t>::min() },
337         { "uint32-max", static_cast<int32_t>(std::numeric_limits<uint32_t>::max()) },
338         { "uint32-min", static_cast<int32_t>(std::numeric_limits<uint32_t>::min()) }
339     });
340     return operands;
341 }
342
343 inline void add32(CCallHelpers& jit, GPRReg src1, GPRReg src2, GPRReg dest)
344 {
345     if (src2 == dest)
346         jit.add32(src1, dest);
347     else {
348         jit.move(src1, dest);
349         jit.add32(src2, dest);
350     }
351 }
352
353 template<typename LoadedType, typename EffectiveType>
354 EffectiveType modelLoad(EffectiveType value);
355
356 template<typename LoadedType, typename EffectiveType>
357 EffectiveType modelLoad(EffectiveType value)
358 {
359     union {
360         EffectiveType original;
361         LoadedType loaded;
362     } u;
363     
364     u.original = value;
365     if (std::is_signed<LoadedType>::value)
366         return static_cast<EffectiveType>(u.loaded);
367     return static_cast<EffectiveType>(static_cast<typename std::make_unsigned<EffectiveType>::type>(u.loaded));
368 }
369
370 template<>
371 inline float modelLoad<float, float>(float value) { return value; }
372
373 template<>
374 inline double modelLoad<double, double>(double value) { return value; }
375
376 void run(const char* filter);
377 void testBitAndSExt32(int32_t value, int64_t mask);
378 void testBasicSelect();
379 void testSelectTest();
380 void testSelectCompareDouble();
381 void testSelectCompareFloat(float, float);
382 void testSelectCompareFloatToDouble(float, float);
383 void testSelectDouble();
384 void testSelectDoubleTest();
385 void testSelectDoubleCompareDouble();
386 void testSelectDoubleCompareFloat(float, float);
387 void testSelectFloatCompareFloat(float, float);
388 void testSelectDoubleCompareDoubleWithAliasing();
389 void testSelectFloatCompareFloatWithAliasing();
390 void testSelectFold(intptr_t value);
391 void testSelectInvert();
392 void testCheckSelect();
393 void testCheckSelectCheckSelect();
394 void testCheckSelectAndCSE();
395 void testPowDoubleByIntegerLoop(double xOperand, int32_t yOperand);
396 double b3Pow(double x, int y);
397 void testTruncOrHigh();
398 void testTruncOrLow();
399 void testBitAndOrHigh();
400 void testBitAndOrLow();
401 void testBranch64Equal(int64_t left, int64_t right);
402 void testBranch64EqualImm(int64_t left, int64_t right);
403 void testBranch64EqualMem(int64_t left, int64_t right);
404 void testBranch64EqualMemImm(int64_t left, int64_t right);
405 void testStore8Load8Z(int32_t value);
406 void testStore16Load16Z(int32_t value);
407 void testSShrShl32(int32_t value, int32_t sshrAmount, int32_t shlAmount);
408 void testSShrShl64(int64_t value, int32_t sshrAmount, int32_t shlAmount);
409 void testTrivialInfiniteLoop();
410 void testFoldPathEqual();
411 void testLShiftSelf32();
412 void testRShiftSelf32();
413 void testURShiftSelf32();
414 void testLShiftSelf64();
415 void testRShiftSelf64();
416 void testURShiftSelf64();
417 void testPatchpointDoubleRegs();
418 void testSpillDefSmallerThanUse();
419 void testSpillUseLargerThanDef();
420 void testLateRegister();
421 void interpreterPrint(Vector<intptr_t>* stream, intptr_t value);
422 void testInterpreter();
423 void testReduceStrengthCheckBottomUseInAnotherBlock();
424 void testResetReachabilityDanglingReference();
425 void testEntrySwitchSimple();
426 void testEntrySwitchNoEntrySwitch();
427 void testEntrySwitchWithCommonPaths();
428 void testEntrySwitchWithCommonPathsAndNonTrivialEntrypoint();
429 void testEntrySwitchLoop();
430 void testSomeEarlyRegister();
431 void testBranchBitAndImmFusion(B3::Opcode valueModifier, Type valueType, int64_t constant, Air::Opcode expectedOpcode, Air::Arg::Kind firstKind);
432 void testTerminalPatchpointThatNeedsToBeSpilled();
433 void testTerminalPatchpointThatNeedsToBeSpilled2();
434 void testPatchpointTerminalReturnValue(bool successIsRare);
435 void testMemoryFence();
436 void testStoreFence();
437 void testLoadFence();
438 void testTrappingLoad();
439 void testTrappingStore();
440 void testTrappingLoadAddStore();
441 void testTrappingLoadDCE();
442 void testTrappingStoreElimination();
443 void testMoveConstants();
444 void testPCOriginMapDoesntInsertNops();
445 void testBitOrBitOrArgImmImm32(int, int, int c);
446 void testBitOrImmBitOrArgImm32(int, int, int c);
447 double bitOrDouble(double, double);
448 void testBitOrArgDouble(double);
449 void testBitOrArgsDouble(double, double);
450 void testBitOrArgImmDouble(double, double);
451 void testBitOrImmsDouble(double, double);
452 float bitOrFloat(float, float);
453 void testBitOrArgFloat(float);
454 void testBitOrArgsFloat(float, float);
455 void testBitOrArgImmFloat(float, float);
456 void testBitOrImmsFloat(float, float);
457 void testBitOrArgsFloatWithUselessDoubleConversion(float, float);
458 void testBitXorArgs(int64_t, int64_t);
459 void testBitXorSameArg(int64_t);
460 void testBitXorAndAndArgs(int64_t, int64_t, int64_t c);
461 void testBitXorAndSameArgs(int64_t, int64_t);
462 void testBitXorImms(int64_t, int64_t);
463 void testBitXorArgImm(int64_t, int64_t);
464 void testBitXorImmArg(int64_t, int64_t);
465 void testBitXorBitXorArgImmImm(int64_t, int64_t, int64_t c);
466 void testBitXorImmBitXorArgImm(int64_t, int64_t, int64_t c);
467 void testBitXorArgs32(int, int);
468 void testBitXorSameArg32(int);
469 void testBitXorImms32(int, int);
470 void testBitXorArgImm32(int, int);
471 void testBitXorImmArg32(int, int);
472 void testBitXorBitXorArgImmImm32(int, int, int c);
473 void testBitXorImmBitXorArgImm32(int, int, int c);
474 void testBitNotArg(int64_t);
475 void testBitNotImm(int64_t);
476 void testBitNotMem(int64_t);
477 void testBitNotArg32(int32_t);
478 void testBitNotImm32(int32_t);
479 void testBitNotMem32(int32_t);
480 void testNotOnBooleanAndBranch32(int64_t, int64_t);
481 void testBitNotOnBooleanAndBranch32(int64_t, int64_t);
482 void testShlArgs(int64_t, int64_t);
483 void testShlImms(int64_t, int64_t);
484 void testShlArgImm(int64_t, int64_t);
485 void testShlSShrArgImm(int64_t, int64_t);
486 void testShlArg32(int32_t);
487 void testShlArgs32(int32_t, int32_t);
488 void testShlImms32(int32_t, int32_t);
489 void testShlArgImm32(int32_t, int32_t);
490 void testShlZShrArgImm32(int32_t, int32_t);
491 void testSShrArgs(int64_t, int64_t);
492 void testSShrImms(int64_t, int64_t);
493 void testSShrArgImm(int64_t, int64_t);
494 void testSShrArg32(int32_t);
495 void testSShrArgs32(int32_t, int32_t);
496 void testSShrImms32(int32_t, int32_t);
497 void testSShrArgImm32(int32_t, int32_t);
498 void testZShrArgs(uint64_t, uint64_t);
499 void testZShrImms(uint64_t, uint64_t);
500 void testZShrArgImm(uint64_t, uint64_t);
501 void testZShrArg32(uint32_t);
502 void testZShrArgs32(uint32_t, uint32_t);
503 void testZShrImms32(uint32_t, uint32_t);
504 void testZShrArgImm32(uint32_t, uint32_t);
505 void testClzArg64(int64_t);
506 void testClzMem64(int64_t);
507 void testClzArg32(int32_t);
508 void testClzMem32(int32_t);
509 void testAbsArg(double);
510 void testAbsImm(double);
511 void testAbsMem(double);
512 void testAbsAbsArg(double);
513 void testAbsNegArg(double);
514 void testAbsBitwiseCastArg(double);
515 void testBitwiseCastAbsBitwiseCastArg(double);
516 void testAbsArg(float);
517 void testAbsImm(float);
518 void testAbsMem(float);
519 void testAbsAbsArg(float);
520 void testAbsNegArg(float);
521 void testAbsBitwiseCastArg(float);
522 void testBitwiseCastAbsBitwiseCastArg(float);
523 void testAbsArgWithUselessDoubleConversion(float);
524 void testAbsArgWithEffectfulDoubleConversion(float);
525 void testCeilArg(double);
526 void testCeilImm(double);
527 void testCeilMem(double);
528 void testCeilCeilArg(double);
529 void testFloorCeilArg(double);
530 void testCeilIToD64(int64_t);
531 void testCeilIToD32(int64_t);
532 void testCeilArg(float);
533 void testCeilImm(float);
534 void testCeilMem(float);
535 void testCeilCeilArg(float);
536 void testFloorCeilArg(float);
537 void testCeilArgWithUselessDoubleConversion(float);
538 void testCeilArgWithEffectfulDoubleConversion(float);
539 void testFloorArg(double);
540 void testFloorImm(double);
541 void testFloorMem(double);
542 void testFloorFloorArg(double);
543 void testCeilFloorArg(double);
544 void testFloorIToD64(int64_t);
545 void testFloorIToD32(int64_t);
546 void testFloorArg(float);
547 void testFloorImm(float);
548 void testFloorMem(float);
549 void testFloorFloorArg(float);
550 void testCeilFloorArg(float);
551 void testFloorArgWithUselessDoubleConversion(float);
552 void testFloorArgWithEffectfulDoubleConversion(float);
553 double correctSqrt(double value);
554 void testSqrtArg(double);
555 void testSqrtImm(double);
556 void testSqrtMem(double);
557 void testSqrtArg(float);
558 void testSqrtImm(float);
559 void testSqrtMem(float);
560 void testSqrtArgWithUselessDoubleConversion(float);
561 void testSqrtArgWithEffectfulDoubleConversion(float);
562 void testCompareTwoFloatToDouble(float, float);
563 void testCompareOneFloatToDouble(float, double);
564 void testCompareFloatToDoubleThroughPhi(float, float);
565 void testDoubleToFloatThroughPhi(float value);
566 void testReduceFloatToDoubleValidates();
567 void testDoubleProducerPhiToFloatConversion(float value);
568 void testDoubleProducerPhiToFloatConversionWithDoubleConsumer(float value);
569 void testDoubleProducerPhiWithNonFloatConst(float value, double constValue);
570 void testDoubleArgToInt64BitwiseCast(double value);
571 void testDoubleImmToInt64BitwiseCast(double value);
572 void testTwoBitwiseCastOnDouble(double value);
573 void testBitwiseCastOnDoubleInMemory(double value);
574 void testBitwiseCastOnDoubleInMemoryIndexed(double value);
575 void testInt64BArgToDoubleBitwiseCast(int64_t value);
576 void testInt64BImmToDoubleBitwiseCast(int64_t value);
577 void testTwoBitwiseCastOnInt64(int64_t value);
578 void testBitwiseCastOnInt64InMemory(int64_t value);
579 void testBitwiseCastOnInt64InMemoryIndexed(int64_t value);
580 void testFloatImmToInt32BitwiseCast(float value);
581 void testBitwiseCastOnFloatInMemory(float value);
582 void testInt32BArgToFloatBitwiseCast(int32_t value);
583 void testInt32BImmToFloatBitwiseCast(int32_t value);
584 void testTwoBitwiseCastOnInt32(int32_t value);
585 void testBitwiseCastOnInt32InMemory(int32_t value);
586 void testConvertDoubleToFloatArg(double value);
587 void testConvertDoubleToFloatImm(double value);
588 void testConvertDoubleToFloatMem(double value);
589 void testConvertFloatToDoubleArg(float value);
590 void testConvertFloatToDoubleImm(float value);
591 void testConvertFloatToDoubleMem(float value);
592 void testConvertDoubleToFloatToDoubleToFloat(double value);
593 void testLoadFloatConvertDoubleConvertFloatStoreFloat(float value);
594 void testFroundArg(double value);
595 void testFroundMem(double value);
596 void testIToD64Arg();
597 void testIToF64Arg();
598 void testIToD32Arg();
599 void testIToF32Arg();
600 void testIToD64Mem();
601 void testIToF64Mem();
602 void testIToD32Mem();
603 void testIToF32Mem();
604 void testIToD64Imm(int64_t value);
605 void testIToF64Imm(int64_t value);
606 void testIToD32Imm(int32_t value);
607 void testIToF32Imm(int32_t value);
608 void testIToDReducedToIToF64Arg();
609 void testIToDReducedToIToF32Arg();
610 void testStore32(int value);
611 void testStoreConstant(int value);
612 void testStoreConstantPtr(intptr_t value);
613 void testStore8Arg();
614 void testStore8Imm();
615 void testStorePartial8BitRegisterOnX86();
616 void testStore16Arg();
617 void testStore16Imm();
618 void testTrunc(int64_t value);
619 void testAdd1(int value);
620 void testAdd1Ptr(intptr_t value);
621 void testNeg32(int32_t value);
622 void testNegPtr(intptr_t value);
623 void testStoreAddLoad32(int amount);
624 void testStoreRelAddLoadAcq32(int amount);
625 void testStoreAddLoadImm32(int amount);
626 void testStoreAddLoad8(int amount, B3::Opcode loadOpcode);
627 void testStoreRelAddLoadAcq8(int amount, B3::Opcode loadOpcode);
628 void testStoreRelAddFenceLoadAcq8(int amount, B3::Opcode loadOpcode);
629 void testStoreAddLoadImm8(int amount, B3::Opcode loadOpcode);
630 void testStoreAddLoad16(int amount, B3::Opcode loadOpcode);
631 void testStoreRelAddLoadAcq16(int amount, B3::Opcode loadOpcode);
632 void testStoreAddLoadImm16(int amount, B3::Opcode loadOpcode);
633 void testStoreAddLoad64(int amount);
634 void testStoreRelAddLoadAcq64(int amount);
635 void testStoreAddLoadImm64(int64_t amount);
636 void testStoreAddLoad32Index(int amount);
637 void testStoreAddLoadImm32Index(int amount);
638 void testStoreAddLoad8Index(int amount, B3::Opcode loadOpcode);
639 void testStoreAddLoadImm8Index(int amount, B3::Opcode loadOpcode);
640 void testStoreAddLoad16Index(int amount, B3::Opcode loadOpcode);
641 void testStoreAddLoadImm16Index(int amount, B3::Opcode loadOpcode);
642 void testStoreAddLoad64Index(int amount);
643 void testStoreAddLoadImm64Index(int64_t amount);
644 void testStoreSubLoad(int amount);
645 void testStoreAddLoadInterference(int amount);
646 void testStoreAddAndLoad(int amount, int mask);
647 void testStoreNegLoad32(int32_t value);
648 void testStoreNegLoadPtr(intptr_t value);
649 void testAdd1Uncommuted(int value);
650 void testLoadOffset();
651 void testLoadOffsetNotConstant();
652 void testLoadOffsetUsingAdd();
653 void testLoadOffsetUsingAddInterference();
654 void testLoadOffsetUsingAddNotConstant();
655 void testLoadAddrShift(unsigned shift);
656 void testFramePointer();
657 void testOverrideFramePointer();
658 void testStackSlot();
659 void testLoadFromFramePointer();
660 void testStoreLoadStackSlot(int value);
661 void testStoreFloat(double input);
662 void testStoreDoubleConstantAsFloat(double input);
663 void testSpillGP();
664 void testSpillFP();
665 void testInt32ToDoublePartialRegisterStall();
666 void testInt32ToDoublePartialRegisterWithoutStall();
667 void testBranch();
668 void testBranchPtr();
669 void testDiamond();
670 void testBranchNotEqual();
671 void testBranchNotEqualCommute();
672 void testBranchNotEqualNotEqual();
673 void testBranchEqual();
674 void testBranchEqualEqual();
675 void testBranchEqualCommute();
676 void testBranchEqualEqual1();
677 void testBranchEqualOrUnorderedArgs(double, double);
678 void testBranchEqualOrUnorderedArgs(float, float);
679 void testBranchNotEqualAndOrderedArgs(double, double);
680 void testBranchNotEqualAndOrderedArgs(float, float);
681 void testBranchEqualOrUnorderedDoubleArgImm(double, double);
682 void testBranchEqualOrUnorderedFloatArgImm(float, float);
683 void testBranchEqualOrUnorderedDoubleImms(double, double);
684 void testBranchEqualOrUnorderedFloatImms(float, float);
685 void testBranchEqualOrUnorderedFloatWithUselessDoubleConversion(float, float);
686 void testBranchFold(int value);
687 void testDiamondFold(int value);
688 void testBranchNotEqualFoldPtr(intptr_t value);
689 void testBranchEqualFoldPtr(intptr_t value);
690 void testBranchLoadPtr();
691 void testBranchLoad32();
692 void testBranchLoad8S();
693 void testBranchLoad8Z();
694 void testBranchLoad16S();
695 void testBranchLoad16Z();
696 void testBranch8WithLoad8ZIndex();
697 void testComplex(unsigned numVars, unsigned numConstructs);
698 void testBranchBitTest32TmpImm(uint32_t value, uint32_t imm);
699 void testBranchBitTest32AddrImm(uint32_t value, uint32_t imm);
700 void testBranchBitTest32TmpTmp(uint32_t value, uint32_t value2);
701 void testBranchBitTest64TmpTmp(uint64_t value, uint64_t value2);
702 void testBranchBitTest64AddrTmp(uint64_t value, uint64_t value2);
703 void testBranchBitTestNegation(uint64_t value, uint64_t value2);
704 void testBranchBitTestNegation2(uint64_t value, uint64_t value2);
705 void testSimplePatchpoint();
706 void testSimplePatchpointWithoutOuputClobbersGPArgs();
707 void testSimplePatchpointWithOuputClobbersGPArgs();
708 void testSimplePatchpointWithoutOuputClobbersFPArgs();
709 void testSimplePatchpointWithOuputClobbersFPArgs();
710 void testPatchpointWithEarlyClobber();
711 void testPatchpointCallArg();
712 void testPatchpointFixedRegister();
713 void testPatchpointAny(ValueRep rep);
714 void testPatchpointGPScratch();
715 void testPatchpointFPScratch();
716 void testPatchpointLotsOfLateAnys();
717 void testPatchpointAnyImm(ValueRep rep);
718 void testPatchpointManyImms();
719 void testPatchpointWithRegisterResult();
720 void testPatchpointWithStackArgumentResult();
721 void testPatchpointWithAnyResult();
722 void testSimpleCheck();
723 void testCheckFalse();
724 void testCheckTrue();
725 void testCheckLessThan();
726 void testCheckMegaCombo();
727 void testCheckTrickyMegaCombo();
728 void testCheckTwoMegaCombos();
729 void testCheckTwoNonRedundantMegaCombos();
730 void testCheckAddImm();
731 void testCheckAddImmCommute();
732 void testCheckAddImmSomeRegister();
733 void testCheckAdd();
734 void testCheckAdd64();
735 void testCheckAddFold(int, int);
736 void testCheckAddFoldFail(int, int);
737 void test42();
738 void testLoad42();
739 void testLoadAcq42();
740 void testLoadWithOffsetImpl(int32_t offset64, int32_t offset32);
741 void testLoadOffsetImm9Max();
742 void testLoadOffsetImm9MaxPlusOne();
743 void testLoadOffsetImm9MaxPlusTwo();
744 void testLoadOffsetImm9Min();
745 void testLoadOffsetImm9MinMinusOne();
746 void testLoadOffsetScaledUnsignedImm12Max();
747 void testLoadOffsetScaledUnsignedOverImm12Max();
748 void testBitXorTreeArgs(int64_t, int64_t);
749 void testBitXorTreeArgsEven(int64_t, int64_t);
750 void testBitXorTreeArgImm(int64_t, int64_t);
751 void testAddTreeArg32(int32_t);
752 void testMulTreeArg32(int32_t);
753 void testBitAndTreeArg32(int32_t);
754 void testBitOrTreeArg32(int32_t);
755 void testArg(int argument);
756 void testReturnConst64(int64_t value);
757 void testReturnVoid();
758 void testAddArg(int);
759 void testAddArgs(int, int);
760 void testAddArgImm(int, int);
761 void testAddImmArg(int, int);
762 void testAddArgMem(int64_t, int64_t);
763 void testAddMemArg(int64_t, int64_t);
764 void testAddImmMem(int64_t, int64_t);
765 void testAddArg32(int);
766 void testAddArgs32(int, int);
767 void testAddArgMem32(int32_t, int32_t);
768 void testAddMemArg32(int32_t, int32_t);
769 void testAddImmMem32(int32_t, int32_t);
770 void testAddNeg1(int, int);
771 void testAddNeg2(int, int);
772 void testAddArgZeroImmZDef();
773 void testAddLoadTwice();
774 void testAddArgDouble(double);
775 void testCheckAddArgumentAliasing64();
776 void testCheckAddArgumentAliasing32();
777 void testCheckAddSelfOverflow64();
778 void testCheckAddSelfOverflow32();
779 void testCheckSubImm();
780 void testCheckSubBadImm();
781 void testCheckSub();
782 double doubleSub(double, double);
783 void testCheckSub64();
784 void testCheckSubFold(int, int);
785 void testCheckSubFoldFail(int, int);
786 void testCheckNeg();
787 void testCheckNeg64();
788 void testCheckMul();
789 void testCheckMulMemory();
790 void testCheckMul2();
791 void testCheckMul64();
792 void testCheckMulFold(int, int);
793 void testCheckMulFoldFail(int, int);
794 void testAddArgsDouble(double, double);
795 void testAddArgImmDouble(double, double);
796 void testAddImmArgDouble(double, double);
797 void testAddImmsDouble(double, double);
798 void testAddArgFloat(float);
799 void testAddArgsFloat(float, float);
800 void testAddFPRArgsFloat(float, float);
801 void testAddArgImmFloat(float, float);
802 void testAddImmArgFloat(float, float);
803 void testAddImmsFloat(float, float);
804 void testAddArgFloatWithUselessDoubleConversion(float);
805 void testAddArgsFloatWithUselessDoubleConversion(float, float);
806 void testAddArgsFloatWithEffectfulDoubleConversion(float, float);
807 void testAddMulMulArgs(int64_t, int64_t, int64_t c);
808 void testMulArg(int);
809 void testMulArgStore(int);
810 void testMulAddArg(int);
811 void testMulArgs(int, int);
812 void testMulArgNegArg(int, int);
813 void testCheckMulArgumentAliasing64();
814 void testCheckMulArgumentAliasing32();
815 void testCheckMul64SShr();
816 void testCompareImpl(B3::Opcode opcode, int64_t left, int64_t right);
817 void testCompare(B3::Opcode opcode, int64_t left, int64_t right);
818 void testEqualDouble(double left, double right, bool result);
819 void testCallSimple(int, int);
820 void testCallRare(int, int);
821 void testCallRareLive(int, int, int c);
822 void testCallSimplePure(int, int);
823 void testCallFunctionWithHellaArguments();
824 void testCallFunctionWithHellaArguments2();
825 void testCallFunctionWithHellaArguments3();
826 void testReturnDouble(double value);
827 void testReturnFloat(float value);
828 void testMulNegArgArg(int, int);
829 void testMulArgImm(int64_t, int64_t);
830 void testMulImmArg(int, int);
831 void testMulArgs32(int, int);
832 void testMulArgs32SignExtend(int, int);
833 void testMulImm32SignExtend(const int, int);
834 void testMulLoadTwice();
835 void testMulAddArgsLeft();
836 void testMulAddArgsRight();
837 void testMulAddArgsLeft32();
838 void testMulAddArgsRight32();
839 void testMulSubArgsLeft();
840 void testMulSubArgsRight();
841 void testMulSubArgsLeft32();
842 void testMulSubArgsRight32();
843 void testMulNegArgs();
844 void testMulNegArgs32();
845 void testMulArgDouble(double);
846 void testMulArgsDouble(double, double);
847 void testCallSimpleDouble(double, double);
848 void testCallSimpleFloat(float, float);
849 void testCallFunctionWithHellaDoubleArguments();
850 void testCallFunctionWithHellaFloatArguments();
851 void testLinearScanWithCalleeOnStack();
852 void testChillDiv(int num, int den, int res);
853 void testChillDivTwice(int num1, int den1, int num2, int den2, int res);
854 void testChillDiv64(int64_t num, int64_t den, int64_t res);
855 void testModArg(int64_t value);
856 void testModArgs(int64_t numerator, int64_t denominator);
857 void testModImms(int64_t numerator, int64_t denominator);
858 void testMulArgImmDouble(double, double);
859 void testMulImmArgDouble(double, double);
860 void testMulImmsDouble(double, double);
861 void testMulArgFloat(float);
862 void testMulArgsFloat(float, float);
863 void testMulArgImmFloat(float, float);
864 void testMulImmArgFloat(float, float);
865 void testMulImmsFloat(float, float);
866 void testMulArgFloatWithUselessDoubleConversion(float);
867 void testMulArgsFloatWithUselessDoubleConversion(float, float);
868 void testMulArgsFloatWithEffectfulDoubleConversion(float, float);
869 void testDivArgDouble(double);
870 void testDivArgsDouble(double, double);
871 void testDivArgImmDouble(double, double);
872 void testDivImmArgDouble(double, double);
873 void testDivImmsDouble(double, double);
874 void testDivArgFloat(float);
875 void testDivArgsFloat(float, float);
876 void testDivArgImmFloat(float, float);
877 void testModArg32(int32_t value);
878 void testModArgs32(int32_t numerator, int32_t denominator);
879 void testModImms32(int32_t numerator, int32_t denominator);
880 void testChillModArg(int64_t value);
881 void testChillModArgs(int64_t numerator, int64_t denominator);
882 void testChillModImms(int64_t numerator, int64_t denominator);
883 void testChillModArg32(int32_t value);
884 void testChillModArgs32(int32_t numerator, int32_t denominator);
885 void testChillModImms32(int32_t numerator, int32_t denominator);
886 void testLoopWithMultipleHeaderEdges();
887 void testSwitch(unsigned degree);
888 void testSwitch(unsigned degree, unsigned gap);
889 void testSwitchSameCaseAsDefault();
890 void testSwitchChillDiv(unsigned degree, unsigned gap);
891 void testSwitchTargettingSameBlock();
892 void testSwitchTargettingSameBlockFoldPathConstant();
893 void testTruncFold(int64_t value);
894 void testZExt32(int32_t value);
895 void testZExt32Fold(int32_t value);
896 void testSExt32(int32_t value);
897 void testSExt32Fold(int32_t value);
898 void testTruncZExt32(int32_t value);
899 void testPinRegisters();
900 void testX86LeaAddAddShlLeft();
901 void testX86LeaAddAddShlRight();
902 void testX86LeaAddAdd();
903 void testX86LeaAddShlRight();
904 void testX86LeaAddShlLeftScale1();
905 void testX86LeaAddShlLeftScale2();
906 void testX86LeaAddShlLeftScale4();
907 void testX86LeaAddShlLeftScale8();
908 void testAddShl32();
909 void testAddShl64();
910 void testAddShl65();
911 void testReduceStrengthReassociation(bool flip);
912 void testLoadBaseIndexShift2();
913 void testLoadBaseIndexShift32();
914 void testOptimizeMaterialization();
915 void testLICMPure();
916 void testLICMPureSideExits();
917 void testTruncSExt32(int32_t value);
918 void testSExt8(int32_t value);
919 void testSExt8Fold(int32_t value);
920 void testSExt8SExt8(int32_t value);
921 void testSExt8SExt16(int32_t value);
922 void testSExt8BitAnd(int32_t value, int32_t mask);
923 void testBitAndSExt8(int32_t value, int32_t mask);
924 void testSExt16(int32_t value);
925 void testSExt16Fold(int32_t value);
926 void testSExt16SExt16(int32_t value);
927 void testSExt16SExt8(int32_t value);
928 void testLICMPureWritesPinned();
929 void testLICMPureWrites();
930 void testLICMReadsLocalState();
931 void testLICMReadsPinned();
932 void testLICMReads();
933 void testLICMPureNotBackwardsDominant();
934 void testLICMPureFoiledByChild();
935 void testLICMPureNotBackwardsDominantFoiledByChild();
936 void testLICMExitsSideways();
937 void testLICMWritesLocalState();
938 void testLICMWrites();
939 void testLICMFence();
940 void testLICMWritesPinned();
941 void testLICMControlDependent();
942 void testLICMControlDependentNotBackwardsDominant();
943 void testLICMControlDependentSideExits();
944 void testLICMReadsPinnedWritesPinned();
945 void testLICMReadsWritesDifferentHeaps();
946 void testLICMReadsWritesOverlappingHeaps();
947 void testLICMDefaultCall();
948 void testDepend32();
949 void testDepend64();
950 void testWasmBoundsCheck(unsigned offset);
951 void testWasmAddress();
952 void testFastTLSLoad();
953 void testFastTLSStore();
954 void testDoubleLiteralComparison(double, double);
955 void testFloatEqualOrUnorderedFolding();
956 void testFloatEqualOrUnorderedFoldingNaN();
957 void testFloatEqualOrUnorderedDontFold();
958 void testSExt16BitAnd(int32_t value, int32_t mask);
959 void testBitAndSExt16(int32_t value, int32_t mask);
960 void testSExt32BitAnd(int32_t value, int32_t mask);
961 void testShuffleDoesntTrashCalleeSaves();
962 void testDemotePatchpointTerminal();
963 void testReportUsedRegistersLateUseFollowedByEarlyDefDoesNotMarkUseAsDead();
964 void testInfiniteLoopDoesntCauseBadHoisting();
965 void testDivImmArgFloat(float, float);
966 void testDivImmsFloat(float, float);
967 void testModArgDouble(double);
968 void testModArgsDouble(double, double);
969 void testModArgImmDouble(double, double);
970 void testModImmArgDouble(double, double);
971 void testModImmsDouble(double, double);
972 void testModArgFloat(float);
973 void testModArgsFloat(float, float);
974 void testModArgImmFloat(float, float);
975 void testModImmArgFloat(float, float);
976 void testModImmsFloat(float, float);
977 void testDivArgFloatWithUselessDoubleConversion(float);
978 void testDivArgsFloatWithUselessDoubleConversion(float, float);
979 void testDivArgsFloatWithEffectfulDoubleConversion(float, float);
980 void testUDivArgsInt32(uint32_t, uint32_t);
981 void testUDivArgsInt64(uint64_t, uint64_t);
982 void testUModArgsInt32(uint32_t, uint32_t);
983 void testUModArgsInt64(uint64_t, uint64_t);
984 void testSubArg(int);
985 void testSubArgs(int, int);
986 void testSubArgImm(int64_t, int64_t);
987 void testSubNeg(int, int);
988 void testNegSub(int, int);
989 void testNegValueSubOne(int);
990 void testSubSub(int, int, int c);
991 void testSubSub2(int, int, int c);
992 void testSubAdd(int, int, int c);
993 void testSubFirstNeg(int, int);
994 void testSubImmArg(int, int);
995 void testSubArgMem(int64_t, int64_t);
996 void testSubMemArg(int64_t, int64_t);
997 void testSubImmMem(int64_t, int64_t);
998 void testSubMemImm(int64_t, int64_t);
999 void testSubArgs32(int, int);
1000 void testSubArgImm32(int, int);
1001 void testSubImmArg32(int, int);
1002 void testSubMemArg32(int32_t, int32_t);
1003 void testSubArgMem32(int32_t, int32_t);
1004 void testSubImmMem32(int32_t, int32_t);
1005 void testSubMemImm32(int32_t, int32_t);
1006 void testNegValueSubOne32(int);
1007 void testNegMulArgImm(int64_t, int64_t);
1008 void testSubMulMulArgs(int64_t, int64_t, int64_t c);
1009 void testSubArgDouble(double);
1010 void testSubArgsDouble(double, double);
1011 void testSubArgImmDouble(double, double);
1012 void testSubImmArgDouble(double, double);
1013 void testSubImmsDouble(double, double);
1014 void testSubArgFloat(float);
1015 void testSubArgsFloat(float, float);
1016 void testSubArgImmFloat(float, float);
1017 void testSubImmArgFloat(float, float);
1018 void testSubImmsFloat(float, float);
1019 void testSubArgFloatWithUselessDoubleConversion(float);
1020 void testSubArgsFloatWithUselessDoubleConversion(float, float);
1021 void testSubArgsFloatWithEffectfulDoubleConversion(float, float);
1022 void testTernarySubInstructionSelection(B3::Opcode valueModifier, Type valueType, Air::Opcode expectedOpcode);
1023 void testNegDouble(double);
1024 void testNegFloat(float);
1025 void testNegFloatWithUselessDoubleConversion(float);
1026 void testBitAndArgs(int64_t, int64_t);
1027 void testBitAndSameArg(int64_t);
1028 void testBitAndNotNot(int64_t, int64_t);
1029 void testBitAndNotImm(int64_t, int64_t);
1030 void testBitAndImms(int64_t, int64_t);
1031 void testBitAndArgImm(int64_t, int64_t);
1032 void testBitAndImmArg(int64_t, int64_t);
1033 void testBitAndBitAndArgImmImm(int64_t, int64_t, int64_t c);
1034 void testBitAndImmBitAndArgImm(int64_t, int64_t, int64_t c);
1035 void testBitAndArgs32(int, int);
1036 void testBitAndSameArg32(int);
1037 void testBitAndImms32(int, int);
1038 void testBitAndArgImm32(int, int);
1039 void testBitAndImmArg32(int, int);
1040 void testBitAndBitAndArgImmImm32(int, int, int c);
1041 void testBitAndImmBitAndArgImm32(int, int, int c);
1042 void testBitAndWithMaskReturnsBooleans(int64_t, int64_t);
1043 void testBitAndArgDouble(double);
1044 void testBitAndArgsDouble(double, double);
1045 void testBitAndArgImmDouble(double, double);
1046 void testBitAndImmsDouble(double, double);
1047 void testBitAndArgFloat(float);
1048 void testBitAndArgsFloat(float, float);
1049 void testBitAndArgImmFloat(float, float);
1050 void testBitAndImmsFloat(float, float);
1051 void testBitAndArgsFloatWithUselessDoubleConversion(float, float);
1052 void testBitOrArgs(int64_t, int64_t);
1053 void testBitOrSameArg(int64_t);
1054 void testBitOrAndAndArgs(int64_t, int64_t, int64_t c);
1055 void testBitOrAndSameArgs(int64_t, int64_t);
1056 void testBitOrNotNot(int64_t, int64_t);
1057 void testBitOrNotImm(int64_t, int64_t);
1058 void testBitOrImms(int64_t, int64_t);
1059 void testBitOrArgImm(int64_t, int64_t);
1060 void testBitOrImmArg(int64_t, int64_t);
1061 void testBitOrBitOrArgImmImm(int64_t, int64_t, int64_t c);
1062 void testBitOrImmBitOrArgImm(int64_t, int64_t, int64_t c);
1063 void testBitOrArgs32(int, int);
1064 void testBitOrSameArg32(int);
1065 void testBitOrImms32(int, int);
1066 void testBitOrArgImm32(int, int);
1067 void testBitOrImmArg32(int, int);
1068
1069 void addAtomicTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks);
1070 void addLoadTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks);
1071 bool shouldRun(const char* filter, const char* testName);
1072
1073 #endif // ENABLE(B3_JIT)