Changeset 248098 in webkit


Ignore:
Timestamp:
Jul 31, 2019 10:58:09 PM (5 years ago)
Author:
commit-queue@webkit.org
Message:

Begin organizing b3 tests
​https://bugs.webkit.org/show_bug.cgi?id=200330

Patch by Alex Christensen <​achristensen@webkit.org> on 2019-07-31
Reviewed by Keith Miller.

  • b3/testb3.h:
  • b3/testb3_1.cpp:

(run):
(zero): Deleted.
(negativeZero): Deleted.

  • b3/testb3_2.cpp:

(testBitXorTreeArgs):
(testBitXorTreeArgsEven):
(testBitXorTreeArgImm):
(testBitAndTreeArg32):
(testBitOrTreeArg32):
(testBitAndArgs):
(testBitAndSameArg):
(testBitAndNotNot):
(testBitAndNotImm):
(testBitAndImms):
(testBitAndArgImm):
(testBitAndImmArg):
(testBitAndBitAndArgImmImm):
(testBitAndImmBitAndArgImm):
(testBitAndArgs32):
(testBitAndSameArg32):
(testBitAndImms32):
(testBitAndArgImm32):
(testBitAndImmArg32):
(testBitAndBitAndArgImmImm32):
(testBitAndImmBitAndArgImm32):
(testBitAndWithMaskReturnsBooleans):
(testBitAndArgDouble):
(testBitAndArgsDouble):
(testBitAndArgImmDouble):
(testBitAndImmsDouble):
(testBitAndArgFloat):
(testBitAndArgsFloat):
(testBitAndArgImmFloat):
(testBitAndImmsFloat):
(testBitAndArgsFloatWithUselessDoubleConversion):
(testBitOrArgs):
(testBitOrSameArg):
(testBitOrAndAndArgs):
(testBitOrAndSameArgs):
(testBitOrNotNot):
(testBitOrNotImm):
(testBitOrImms):
(testBitOrArgImm):
(testBitOrImmArg):
(testBitOrBitOrArgImmImm):
(testBitOrImmBitOrArgImm):
(testBitOrArgs32):
(testBitOrSameArg32):
(testBitOrImms32):
(testBitOrArgImm32):
(testBitOrImmArg32):
(addBitTests):

  • b3/testb3_3.cpp:

(testSShrArgs):
(testSShrImms):
(testSShrArgImm):
(testSShrArg32):
(testSShrArgs32):
(testSShrImms32):
(testSShrArgImm32):
(testZShrArgs):
(testZShrImms):
(testZShrArgImm):
(testZShrArg32):
(testZShrArgs32):
(testZShrImms32):
(testZShrArgImm32):
(zero):
(negativeZero):
(addArgTests):
(addCallTests):
(addShrTests):

  • b3/testb3_4.cpp:

(addSExtTests):

  • b3/testb3_6.cpp:

(testSShrShl32):
(testSShrShl64):
(addSShrShTests):

Location:
trunk/Source/JavaScriptCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r248097 r248098  
     12019-07-31  Alex Christensen  <achristensen@webkit.org>
     2
     3        Begin organizing b3 tests
     4        https://bugs.webkit.org/show_bug.cgi?id=200330
     5
     6        Reviewed by Keith Miller.
     7
     8        * b3/testb3.h:
     9        * b3/testb3_1.cpp:
     10        (run):
     11        (zero): Deleted.
     12        (negativeZero): Deleted.
     13        * b3/testb3_2.cpp:
     14        (testBitXorTreeArgs):
     15        (testBitXorTreeArgsEven):
     16        (testBitXorTreeArgImm):
     17        (testBitAndTreeArg32):
     18        (testBitOrTreeArg32):
     19        (testBitAndArgs):
     20        (testBitAndSameArg):
     21        (testBitAndNotNot):
     22        (testBitAndNotImm):
     23        (testBitAndImms):
     24        (testBitAndArgImm):
     25        (testBitAndImmArg):
     26        (testBitAndBitAndArgImmImm):
     27        (testBitAndImmBitAndArgImm):
     28        (testBitAndArgs32):
     29        (testBitAndSameArg32):
     30        (testBitAndImms32):
     31        (testBitAndArgImm32):
     32        (testBitAndImmArg32):
     33        (testBitAndBitAndArgImmImm32):
     34        (testBitAndImmBitAndArgImm32):
     35        (testBitAndWithMaskReturnsBooleans):
     36        (testBitAndArgDouble):
     37        (testBitAndArgsDouble):
     38        (testBitAndArgImmDouble):
     39        (testBitAndImmsDouble):
     40        (testBitAndArgFloat):
     41        (testBitAndArgsFloat):
     42        (testBitAndArgImmFloat):
     43        (testBitAndImmsFloat):
     44        (testBitAndArgsFloatWithUselessDoubleConversion):
     45        (testBitOrArgs):
     46        (testBitOrSameArg):
     47        (testBitOrAndAndArgs):
     48        (testBitOrAndSameArgs):
     49        (testBitOrNotNot):
     50        (testBitOrNotImm):
     51        (testBitOrImms):
     52        (testBitOrArgImm):
     53        (testBitOrImmArg):
     54        (testBitOrBitOrArgImmImm):
     55        (testBitOrImmBitOrArgImm):
     56        (testBitOrArgs32):
     57        (testBitOrSameArg32):
     58        (testBitOrImms32):
     59        (testBitOrArgImm32):
     60        (testBitOrImmArg32):
     61        (addBitTests):
     62        * b3/testb3_3.cpp:
     63        (testSShrArgs):
     64        (testSShrImms):
     65        (testSShrArgImm):
     66        (testSShrArg32):
     67        (testSShrArgs32):
     68        (testSShrImms32):
     69        (testSShrArgImm32):
     70        (testZShrArgs):
     71        (testZShrImms):
     72        (testZShrArgImm):
     73        (testZShrArg32):
     74        (testZShrArgs32):
     75        (testZShrImms32):
     76        (testZShrArgImm32):
     77        (zero):
     78        (negativeZero):
     79        (addArgTests):
     80        (addCallTests):
     81        (addShrTests):
     82        * b3/testb3_4.cpp:
     83        (addSExtTests):
     84        * b3/testb3_6.cpp:
     85        (testSShrShl32):
     86        (testSShrShl64):
     87        (addSShrShTests):
     88
    1892019-07-31  Devin Rousso  <drousso@apple.com>
    290

  • trunk/Source/JavaScriptCore/b3/testb3.h

    r248087 r248098  
    405405void testStore8Load8Z(int32_t value);
    406406void 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);
    409407void testTrivialInfiniteLoop();
    410408void testFoldPathEqual();
    … …  
    489487void testShlArgImm32(int32_t, int32_t);
    490488void 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);
    505489void testClzArg64(int64_t);
    506490void testClzMem64(int64_t);
    … …  
    746730void testLoadOffsetScaledUnsignedImm12Max();
    747731void testLoadOffsetScaledUnsignedOverImm12Max();
    748 void testBitXorTreeArgs(int64_t, int64_t);
    749 void testBitXorTreeArgsEven(int64_t, int64_t);
    750 void testBitXorTreeArgImm(int64_t, int64_t);
    751732void testAddTreeArg32(int32_t);
    752733void testMulTreeArg32(int32_t);
    753 void testBitAndTreeArg32(int32_t);
    754 void testBitOrTreeArg32(int32_t);
    755734void testArg(int argument);
    756735void testReturnConst64(int64_t value);
    … …  
    10241003void testNegFloat(float);
    10251004void 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);
     1005
     1006void addArgTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1007void addBitTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1008void addCallTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1009void addSExtTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1010void addSShrShTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1011void addShrTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1012void addAtomicTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1013void addLoadTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>&);
     1014
    10711015bool shouldRun(const char* filter, const char* testName);
    10721016

  • trunk/Source/JavaScriptCore/b3/testb3_1.cpp

    r248087 r248098  
    3030
    3131Lock crashLock;
    32 
    33 // Make sure the compiler does not try to optimize anything out.
    34 static NEVER_INLINE double zero()
    35 {
    36     return 0.;
    37 }
    38 
    39 static double negativeZero()
    40 {
    41     return -zero();
    42 }
    4332
    4433bool shouldRun(const char* filter, const char* testName)
    … …  
    169158    RUN(testReturnVoid());
    170159
    171     RUN_BINARY(testBitXorTreeArgs, int64Operands(), int64Operands());
    172     RUN_BINARY(testBitXorTreeArgsEven, int64Operands(), int64Operands());
    173     RUN_BINARY(testBitXorTreeArgImm, int64Operands(), int64Operands());
    174160    RUN_UNARY(testAddTreeArg32, int32Operands());
    175161    RUN_UNARY(testMulTreeArg32, int32Operands());
    176     RUN_UNARY(testBitAndTreeArg32, int32Operands());
    177     RUN_UNARY(testBitOrTreeArg32, int32Operands());
    178 
    179     RUN(testAddArg(111));
    180     RUN(testAddArgs(1, 1));
    181     RUN(testAddArgs(1, 2));
    182     RUN(testAddArgImm(1, 2));
    183     RUN(testAddArgImm(0, 2));
    184     RUN(testAddArgImm(1, 0));
    185     RUN(testAddImmArg(1, 2));
    186     RUN(testAddImmArg(0, 2));
    187     RUN(testAddImmArg(1, 0));
    188     RUN_BINARY(testAddArgMem, int64Operands(), int64Operands());
    189     RUN_BINARY(testAddMemArg, int64Operands(), int64Operands());
    190     RUN_BINARY(testAddImmMem, int64Operands(), int64Operands());
    191     RUN_UNARY(testAddArg32, int32Operands());
    192     RUN(testAddArgs32(1, 1));
    193     RUN(testAddArgs32(1, 2));
    194     RUN_BINARY(testAddArgMem32, int32Operands(), int32Operands());
    195     RUN_BINARY(testAddMemArg32, int32Operands(), int32Operands());
    196     RUN_BINARY(testAddImmMem32, int32Operands(), int32Operands());
    197     RUN_BINARY(testAddNeg1, int32Operands(), int32Operands());
    198     RUN_BINARY(testAddNeg2, int32Operands(), int32Operands());
    199     RUN(testAddArgZeroImmZDef());
    200     RUN(testAddLoadTwice());
    201     RUN_TERNARY(testAddMulMulArgs, int64Operands(), int64Operands(), int64Operands());
    202 
    203     RUN(testAddArgDouble(M_PI));
    204     RUN(testAddArgsDouble(M_PI, 1));
    205     RUN(testAddArgsDouble(M_PI, -M_PI));
    206     RUN(testAddArgImmDouble(M_PI, 1));
    207     RUN(testAddArgImmDouble(M_PI, 0));
    208     RUN(testAddArgImmDouble(M_PI, negativeZero()));
    209     RUN(testAddArgImmDouble(0, 0));
    210     RUN(testAddArgImmDouble(0, negativeZero()));
    211     RUN(testAddArgImmDouble(negativeZero(), 0));
    212     RUN(testAddArgImmDouble(negativeZero(), negativeZero()));
    213     RUN(testAddImmArgDouble(M_PI, 1));
    214     RUN(testAddImmArgDouble(M_PI, 0));
    215     RUN(testAddImmArgDouble(M_PI, negativeZero()));
    216     RUN(testAddImmArgDouble(0, 0));
    217     RUN(testAddImmArgDouble(0, negativeZero()));
    218     RUN(testAddImmArgDouble(negativeZero(), 0));
    219     RUN(testAddImmArgDouble(negativeZero(), negativeZero()));
    220     RUN(testAddImmsDouble(M_PI, 1));
    221     RUN(testAddImmsDouble(M_PI, 0));
    222     RUN(testAddImmsDouble(M_PI, negativeZero()));
    223     RUN(testAddImmsDouble(0, 0));
    224     RUN(testAddImmsDouble(0, negativeZero()));
    225     RUN(testAddImmsDouble(negativeZero(), negativeZero()));
    226     RUN_UNARY(testAddArgFloat, floatingPointOperands<float>());
    227     RUN_BINARY(testAddArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    228     RUN_BINARY(testAddFPRArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    229     RUN_BINARY(testAddArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    230     RUN_BINARY(testAddImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    231     RUN_BINARY(testAddImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    232     RUN_UNARY(testAddArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
    233     RUN_BINARY(testAddArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    234     RUN_BINARY(testAddArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    235 
    236     RUN(testMulArg(5));
    237     RUN(testMulAddArg(5));
    238     RUN(testMulAddArg(85));
    239     RUN(testMulArgStore(5));
    240     RUN(testMulArgStore(85));
    241     RUN(testMulArgs(1, 1));
    242     RUN(testMulArgs(1, 2));
    243     RUN(testMulArgs(3, 3));
    244     RUN(testMulArgImm(1, 2));
    245     RUN(testMulArgImm(1, 4));
    246     RUN(testMulArgImm(1, 8));
    247     RUN(testMulArgImm(1, 16));
    248     RUN(testMulArgImm(1, 0x80000000llu));
    249     RUN(testMulArgImm(1, 0x800000000000llu));
    250     RUN(testMulArgImm(7, 2));
    251     RUN(testMulArgImm(7, 4));
    252     RUN(testMulArgImm(7, 8));
    253     RUN(testMulArgImm(7, 16));
    254     RUN(testMulArgImm(7, 0x80000000llu));
    255     RUN(testMulArgImm(7, 0x800000000000llu));
    256     RUN(testMulArgImm(-42, 2));
    257     RUN(testMulArgImm(-42, 4));
    258     RUN(testMulArgImm(-42, 8));
    259     RUN(testMulArgImm(-42, 16));
    260     RUN(testMulArgImm(-42, 0x80000000llu));
    261     RUN(testMulArgImm(-42, 0x800000000000llu));
    262     RUN(testMulArgImm(0, 2));
    263     RUN(testMulArgImm(1, 0));
    264     RUN(testMulArgImm(3, 3));
    265     RUN(testMulArgImm(3, -1));
    266     RUN(testMulArgImm(-3, -1));
    267     RUN(testMulArgImm(0, -1));
    268     RUN(testMulImmArg(1, 2));
    269     RUN(testMulImmArg(0, 2));
    270     RUN(testMulImmArg(1, 0));
    271     RUN(testMulImmArg(3, 3));
    272     RUN(testMulImm32SignExtend(1, 2));
    273     RUN(testMulImm32SignExtend(0, 2));
    274     RUN(testMulImm32SignExtend(1, 0));
    275     RUN(testMulImm32SignExtend(3, 3));
    276     RUN(testMulImm32SignExtend(0xFFFFFFFF, 0xFFFFFFFF));
    277     RUN(testMulImm32SignExtend(0xFFFFFFFE, 0xFFFFFFFF));
    278     RUN(testMulImm32SignExtend(0xFFFFFFFF, 0xFFFFFFFE));
    279     RUN(testMulArgs32(1, 1));
    280     RUN(testMulArgs32(1, 2));
    281     RUN(testMulArgs32(0xFFFFFFFF, 0xFFFFFFFF));
    282     RUN(testMulArgs32(0xFFFFFFFE, 0xFFFFFFFF));
    283     RUN(testMulArgs32SignExtend(1, 1));
    284     RUN(testMulArgs32SignExtend(1, 2));
    285     RUN(testMulArgs32SignExtend(0xFFFFFFFF, 0xFFFFFFFF));
    286     RUN(testMulArgs32SignExtend(0xFFFFFFFE, 0xFFFFFFFF));
    287     RUN(testMulLoadTwice());
    288     RUN(testMulAddArgsLeft());
    289     RUN(testMulAddArgsRight());
    290     RUN(testMulAddArgsLeft32());
    291     RUN(testMulAddArgsRight32());
    292     RUN(testMulSubArgsLeft());
    293     RUN(testMulSubArgsRight());
    294     RUN(testMulSubArgsLeft32());
    295     RUN(testMulSubArgsRight32());
    296     RUN(testMulNegArgs());
    297     RUN(testMulNegArgs32());
    298 
    299     RUN_BINARY(testMulArgNegArg, int64Operands(), int64Operands())
    300     RUN_BINARY(testMulNegArgArg, int64Operands(), int64Operands())
    301     RUN_UNARY(testMulArgDouble, floatingPointOperands<double>());
    302     RUN_BINARY(testMulArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    303     RUN_BINARY(testMulArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    304     RUN_BINARY(testMulImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    305     RUN_BINARY(testMulImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    306     RUN_UNARY(testMulArgFloat, floatingPointOperands<float>());
    307     RUN_BINARY(testMulArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    308     RUN_BINARY(testMulArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    309     RUN_BINARY(testMulImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    310     RUN_BINARY(testMulImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    311     RUN_UNARY(testMulArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
    312     RUN_BINARY(testMulArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    313     RUN_BINARY(testMulArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    314 
    315     RUN(testDivArgDouble(M_PI));
    316     RUN(testDivArgsDouble(M_PI, 1));
    317     RUN(testDivArgsDouble(M_PI, -M_PI));
    318     RUN(testDivArgImmDouble(M_PI, 1));
    319     RUN(testDivArgImmDouble(M_PI, 0));
    320     RUN(testDivArgImmDouble(M_PI, negativeZero()));
    321     RUN(testDivArgImmDouble(0, 0));
    322     RUN(testDivArgImmDouble(0, negativeZero()));
    323     RUN(testDivArgImmDouble(negativeZero(), 0));
    324     RUN(testDivArgImmDouble(negativeZero(), negativeZero()));
    325     RUN(testDivImmArgDouble(M_PI, 1));
    326     RUN(testDivImmArgDouble(M_PI, 0));
    327     RUN(testDivImmArgDouble(M_PI, negativeZero()));
    328     RUN(testDivImmArgDouble(0, 0));
    329     RUN(testDivImmArgDouble(0, negativeZero()));
    330     RUN(testDivImmArgDouble(negativeZero(), 0));
    331     RUN(testDivImmArgDouble(negativeZero(), negativeZero()));
    332     RUN(testDivImmsDouble(M_PI, 1));
    333     RUN(testDivImmsDouble(M_PI, 0));
    334     RUN(testDivImmsDouble(M_PI, negativeZero()));
    335     RUN(testDivImmsDouble(0, 0));
    336     RUN(testDivImmsDouble(0, negativeZero()));
    337     RUN(testDivImmsDouble(negativeZero(), negativeZero()));
    338     RUN_UNARY(testDivArgFloat, floatingPointOperands<float>());
    339     RUN_BINARY(testDivArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    340     RUN_BINARY(testDivArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    341     RUN_BINARY(testDivImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    342     RUN_BINARY(testDivImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    343     RUN_UNARY(testDivArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
    344     RUN_BINARY(testDivArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    345     RUN_BINARY(testDivArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    346 
    347     RUN_BINARY(testUDivArgsInt32, int32Operands(), int32Operands());
    348     RUN_BINARY(testUDivArgsInt64, int64Operands(), int64Operands());
    349 
    350     RUN_UNARY(testModArgDouble, floatingPointOperands<double>());
    351     RUN_BINARY(testModArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    352     RUN_BINARY(testModArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    353     RUN_BINARY(testModImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    354     RUN_BINARY(testModImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    355     RUN_UNARY(testModArgFloat, floatingPointOperands<float>());
    356     RUN_BINARY(testModArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    357     RUN_BINARY(testModArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    358     RUN_BINARY(testModImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    359     RUN_BINARY(testModImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    360 
    361     RUN_BINARY(testUModArgsInt32, int32Operands(), int32Operands());
    362     RUN_BINARY(testUModArgsInt64, int64Operands(), int64Operands());
    363 
    364     RUN(testSubArg(24));
    365     RUN(testSubArgs(1, 1));
    366     RUN(testSubArgs(1, 2));
    367     RUN(testSubArgs(13, -42));
    368     RUN(testSubArgs(-13, 42));
    369     RUN(testSubArgImm(1, 1));
    370     RUN(testSubArgImm(1, 2));
    371     RUN(testSubArgImm(13, -42));
    372     RUN(testSubArgImm(-13, 42));
    373     RUN(testSubArgImm(42, 0));
    374     RUN(testSubImmArg(1, 1));
    375     RUN(testSubImmArg(1, 2));
    376     RUN(testSubImmArg(13, -42));
    377     RUN(testSubImmArg(-13, 42));
    378     RUN_BINARY(testSubArgMem, int64Operands(), int64Operands());
    379     RUN_BINARY(testSubMemArg, int64Operands(), int64Operands());
    380     RUN_BINARY(testSubImmMem, int32Operands(), int32Operands());
    381     RUN_BINARY(testSubMemImm, int32Operands(), int32Operands());
    382     RUN_BINARY(testSubNeg, int32Operands(), int32Operands());
    383     RUN_BINARY(testNegSub, int32Operands(), int32Operands());
    384     RUN_UNARY(testNegValueSubOne, int32Operands());
    385     RUN_BINARY(testNegMulArgImm, int64Operands(), int64Operands());
    386     RUN_TERNARY(testSubMulMulArgs, int64Operands(), int64Operands(), int64Operands());
    387 
    388     RUN_TERNARY(testSubSub, int32Operands(), int32Operands(), int32Operands());
    389     RUN_TERNARY(testSubSub2, int32Operands(), int32Operands(), int32Operands());
    390     RUN_TERNARY(testSubAdd, int32Operands(), int32Operands(), int32Operands());
    391     RUN_BINARY(testSubFirstNeg, int32Operands(), int32Operands());
    392 
    393     RUN(testSubArgs32(1, 1));
    394     RUN(testSubArgs32(1, 2));
    395     RUN(testSubArgs32(13, -42));
    396     RUN(testSubArgs32(-13, 42));
    397     RUN(testSubArgImm32(1, 1));
    398     RUN(testSubArgImm32(1, 2));
    399     RUN(testSubArgImm32(13, -42));
    400     RUN(testSubArgImm32(-13, 42));
    401     RUN(testSubImmArg32(1, 1));
    402     RUN(testSubImmArg32(1, 2));
    403     RUN(testSubImmArg32(13, -42));
    404     RUN(testSubImmArg32(-13, 42));
    405     RUN_BINARY(testSubArgMem32, int32Operands(), int32Operands());
    406     RUN_BINARY(testSubMemArg32, int32Operands(), int32Operands());
    407     RUN_BINARY(testSubImmMem32, int32Operands(), int32Operands());
    408     RUN_BINARY(testSubMemImm32, int32Operands(), int32Operands());
    409     RUN_UNARY(testNegValueSubOne32, int64Operands());
    410 
    411     RUN_UNARY(testSubArgDouble, floatingPointOperands<double>());
    412     RUN_BINARY(testSubArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    413     RUN_BINARY(testSubArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    414     RUN_BINARY(testSubImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    415     RUN_BINARY(testSubImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    416     RUN_UNARY(testSubArgFloat, floatingPointOperands<float>());
    417     RUN_BINARY(testSubArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    418     RUN_BINARY(testSubArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    419     RUN_BINARY(testSubImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    420     RUN_BINARY(testSubImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    421     RUN_UNARY(testSubArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
    422     RUN_BINARY(testSubArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    423     RUN_BINARY(testSubArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     162
     163    addArgTests(filter, tasks);
    424164
    425165    RUN_UNARY(testNegDouble, floatingPointOperands<double>());
    … …  
    427167    RUN_UNARY(testNegFloatWithUselessDoubleConversion, floatingPointOperands<float>());
    428168
    429     RUN(testBitAndArgs(43, 43));
    430     RUN(testBitAndArgs(43, 0));
    431     RUN(testBitAndArgs(10, 3));
    432     RUN(testBitAndArgs(42, 0xffffffffffffffff));
    433     RUN(testBitAndSameArg(43));
    434     RUN(testBitAndSameArg(0));
    435     RUN(testBitAndSameArg(3));
    436     RUN(testBitAndSameArg(0xffffffffffffffff));
    437     RUN(testBitAndImms(43, 43));
    438     RUN(testBitAndImms(43, 0));
    439     RUN(testBitAndImms(10, 3));
    440     RUN(testBitAndImms(42, 0xffffffffffffffff));
    441     RUN(testBitAndArgImm(43, 43));
    442     RUN(testBitAndArgImm(43, 0));
    443     RUN(testBitAndArgImm(10, 3));
    444     RUN(testBitAndArgImm(42, 0xffffffffffffffff));
    445     RUN(testBitAndArgImm(42, 0xff));
    446     RUN(testBitAndArgImm(300, 0xff));
    447     RUN(testBitAndArgImm(-300, 0xff));
    448     RUN(testBitAndArgImm(42, 0xffff));
    449     RUN(testBitAndArgImm(40000, 0xffff));
    450     RUN(testBitAndArgImm(-40000, 0xffff));
    451     RUN(testBitAndImmArg(43, 43));
    452     RUN(testBitAndImmArg(43, 0));
    453     RUN(testBitAndImmArg(10, 3));
    454     RUN(testBitAndImmArg(42, 0xffffffffffffffff));
    455     RUN(testBitAndBitAndArgImmImm(2, 7, 3));
    456     RUN(testBitAndBitAndArgImmImm(1, 6, 6));
    457     RUN(testBitAndBitAndArgImmImm(0xffff, 24, 7));
    458     RUN(testBitAndImmBitAndArgImm(7, 2, 3));
    459     RUN(testBitAndImmBitAndArgImm(6, 1, 6));
    460     RUN(testBitAndImmBitAndArgImm(24, 0xffff, 7));
    461     RUN(testBitAndArgs32(43, 43));
    462     RUN(testBitAndArgs32(43, 0));
    463     RUN(testBitAndArgs32(10, 3));
    464     RUN(testBitAndArgs32(42, 0xffffffff));
    465     RUN(testBitAndSameArg32(43));
    466     RUN(testBitAndSameArg32(0));
    467     RUN(testBitAndSameArg32(3));
    468     RUN(testBitAndSameArg32(0xffffffff));
    469     RUN(testBitAndImms32(43, 43));
    470     RUN(testBitAndImms32(43, 0));
    471     RUN(testBitAndImms32(10, 3));
    472     RUN(testBitAndImms32(42, 0xffffffff));
    473     RUN(testBitAndArgImm32(43, 43));
    474     RUN(testBitAndArgImm32(43, 0));
    475     RUN(testBitAndArgImm32(10, 3));
    476     RUN(testBitAndArgImm32(42, 0xffffffff));
    477     RUN(testBitAndImmArg32(43, 43));
    478     RUN(testBitAndImmArg32(43, 0));
    479     RUN(testBitAndImmArg32(10, 3));
    480     RUN(testBitAndImmArg32(42, 0xffffffff));
    481     RUN(testBitAndImmArg32(42, 0xff));
    482     RUN(testBitAndImmArg32(300, 0xff));
    483     RUN(testBitAndImmArg32(-300, 0xff));
    484     RUN(testBitAndImmArg32(42, 0xffff));
    485     RUN(testBitAndImmArg32(40000, 0xffff));
    486     RUN(testBitAndImmArg32(-40000, 0xffff));
    487     RUN(testBitAndBitAndArgImmImm32(2, 7, 3));
    488     RUN(testBitAndBitAndArgImmImm32(1, 6, 6));
    489     RUN(testBitAndBitAndArgImmImm32(0xffff, 24, 7));
    490     RUN(testBitAndImmBitAndArgImm32(7, 2, 3));
    491     RUN(testBitAndImmBitAndArgImm32(6, 1, 6));
    492     RUN(testBitAndImmBitAndArgImm32(24, 0xffff, 7));
    493     RUN_BINARY(testBitAndWithMaskReturnsBooleans, int64Operands(), int64Operands());
    494     RUN_UNARY(testBitAndArgDouble, floatingPointOperands<double>());
    495     RUN_BINARY(testBitAndArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    496     RUN_BINARY(testBitAndArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    497     RUN_BINARY(testBitAndImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    498     RUN_UNARY(testBitAndArgFloat, floatingPointOperands<float>());
    499     RUN_BINARY(testBitAndArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    500     RUN_BINARY(testBitAndArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    501     RUN_BINARY(testBitAndImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    502     RUN_BINARY(testBitAndArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    503     RUN_BINARY(testBitAndNotNot, int64Operands(), int64Operands());
    504     RUN_BINARY(testBitAndNotImm, int64Operands(), int64Operands());
    505 
    506     RUN(testBitOrArgs(43, 43));
    507     RUN(testBitOrArgs(43, 0));
    508     RUN(testBitOrArgs(10, 3));
    509     RUN(testBitOrArgs(42, 0xffffffffffffffff));
    510     RUN(testBitOrSameArg(43));
    511     RUN(testBitOrSameArg(0));
    512     RUN(testBitOrSameArg(3));
    513     RUN(testBitOrSameArg(0xffffffffffffffff));
    514     RUN(testBitOrImms(43, 43));
    515     RUN(testBitOrImms(43, 0));
    516     RUN(testBitOrImms(10, 3));
    517     RUN(testBitOrImms(42, 0xffffffffffffffff));
    518     RUN(testBitOrArgImm(43, 43));
    519     RUN(testBitOrArgImm(43, 0));
    520     RUN(testBitOrArgImm(10, 3));
    521     RUN(testBitOrArgImm(42, 0xffffffffffffffff));
    522     RUN(testBitOrImmArg(43, 43));
    523     RUN(testBitOrImmArg(43, 0));
    524     RUN(testBitOrImmArg(10, 3));
    525     RUN(testBitOrImmArg(42, 0xffffffffffffffff));
    526     RUN(testBitOrBitOrArgImmImm(2, 7, 3));
    527     RUN(testBitOrBitOrArgImmImm(1, 6, 6));
    528     RUN(testBitOrBitOrArgImmImm(0xffff, 24, 7));
    529     RUN(testBitOrImmBitOrArgImm(7, 2, 3));
    530     RUN(testBitOrImmBitOrArgImm(6, 1, 6));
    531     RUN(testBitOrImmBitOrArgImm(24, 0xffff, 7));
    532     RUN(testBitOrArgs32(43, 43));
    533     RUN(testBitOrArgs32(43, 0));
    534     RUN(testBitOrArgs32(10, 3));
    535     RUN(testBitOrArgs32(42, 0xffffffff));
    536     RUN(testBitOrSameArg32(43));
    537     RUN(testBitOrSameArg32(0));
    538     RUN(testBitOrSameArg32(3));
    539     RUN(testBitOrSameArg32(0xffffffff));
    540     RUN(testBitOrImms32(43, 43));
    541     RUN(testBitOrImms32(43, 0));
    542     RUN(testBitOrImms32(10, 3));
    543     RUN(testBitOrImms32(42, 0xffffffff));
    544     RUN(testBitOrArgImm32(43, 43));
    545     RUN(testBitOrArgImm32(43, 0));
    546     RUN(testBitOrArgImm32(10, 3));
    547     RUN(testBitOrArgImm32(42, 0xffffffff));
    548     RUN(testBitOrImmArg32(43, 43));
    549     RUN(testBitOrImmArg32(43, 0));
    550     RUN(testBitOrImmArg32(10, 3));
    551     RUN(testBitOrImmArg32(42, 0xffffffff));
    552     RUN(testBitOrBitOrArgImmImm32(2, 7, 3));
    553     RUN(testBitOrBitOrArgImmImm32(1, 6, 6));
    554     RUN(testBitOrBitOrArgImmImm32(0xffff, 24, 7));
    555     RUN(testBitOrImmBitOrArgImm32(7, 2, 3));
    556     RUN(testBitOrImmBitOrArgImm32(6, 1, 6));
    557     RUN(testBitOrImmBitOrArgImm32(24, 0xffff, 7));
    558     RUN_UNARY(testBitOrArgDouble, floatingPointOperands<double>());
    559     RUN_BINARY(testBitOrArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    560     RUN_BINARY(testBitOrArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    561     RUN_BINARY(testBitOrImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
    562     RUN_UNARY(testBitOrArgFloat, floatingPointOperands<float>());
    563     RUN_BINARY(testBitOrArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    564     RUN_BINARY(testBitOrArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    565     RUN_BINARY(testBitOrImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    566     RUN_BINARY(testBitOrArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
    567     RUN_TERNARY(testBitOrAndAndArgs, int64Operands(), int64Operands(), int64Operands());
    568     RUN_BINARY(testBitOrAndSameArgs, int64Operands(), int64Operands());
    569     RUN_BINARY(testBitOrNotNot, int64Operands(), int64Operands());
    570     RUN_BINARY(testBitOrNotImm, int64Operands(), int64Operands());
    571 
    572     RUN_BINARY(testBitXorArgs, int64Operands(), int64Operands());
    573     RUN_UNARY(testBitXorSameArg, int64Operands());
    574     RUN_BINARY(testBitXorImms, int64Operands(), int64Operands());
    575     RUN_BINARY(testBitXorArgImm, int64Operands(), int64Operands());
    576     RUN_BINARY(testBitXorImmArg, int64Operands(), int64Operands());
    577     RUN(testBitXorBitXorArgImmImm(2, 7, 3));
    578     RUN(testBitXorBitXorArgImmImm(1, 6, 6));
    579     RUN(testBitXorBitXorArgImmImm(0xffff, 24, 7));
    580     RUN(testBitXorImmBitXorArgImm(7, 2, 3));
    581     RUN(testBitXorImmBitXorArgImm(6, 1, 6));
    582     RUN(testBitXorImmBitXorArgImm(24, 0xffff, 7));
    583     RUN(testBitXorArgs32(43, 43));
    584     RUN(testBitXorArgs32(43, 0));
    585     RUN(testBitXorArgs32(10, 3));
    586     RUN(testBitXorArgs32(42, 0xffffffff));
    587     RUN(testBitXorSameArg32(43));
    588     RUN(testBitXorSameArg32(0));
    589     RUN(testBitXorSameArg32(3));
    590     RUN(testBitXorSameArg32(0xffffffff));
    591     RUN(testBitXorImms32(43, 43));
    592     RUN(testBitXorImms32(43, 0));
    593     RUN(testBitXorImms32(10, 3));
    594     RUN(testBitXorImms32(42, 0xffffffff));
    595     RUN(testBitXorArgImm32(43, 43));
    596     RUN(testBitXorArgImm32(43, 0));
    597     RUN(testBitXorArgImm32(10, 3));
    598     RUN(testBitXorArgImm32(42, 0xffffffff));
    599     RUN(testBitXorImmArg32(43, 43));
    600     RUN(testBitXorImmArg32(43, 0));
    601     RUN(testBitXorImmArg32(10, 3));
    602     RUN(testBitXorImmArg32(42, 0xffffffff));
    603     RUN(testBitXorBitXorArgImmImm32(2, 7, 3));
    604     RUN(testBitXorBitXorArgImmImm32(1, 6, 6));
    605     RUN(testBitXorBitXorArgImmImm32(0xffff, 24, 7));
    606     RUN(testBitXorImmBitXorArgImm32(7, 2, 3));
    607     RUN(testBitXorImmBitXorArgImm32(6, 1, 6));
    608     RUN(testBitXorImmBitXorArgImm32(24, 0xffff, 7));
    609     RUN_TERNARY(testBitXorAndAndArgs, int64Operands(), int64Operands(), int64Operands());
    610     RUN_BINARY(testBitXorAndSameArgs, int64Operands(), int64Operands());
    611 
    612     RUN_UNARY(testBitNotArg, int64Operands());
    613     RUN_UNARY(testBitNotImm, int64Operands());
    614     RUN_UNARY(testBitNotMem, int64Operands());
    615     RUN_UNARY(testBitNotArg32, int32Operands());
    616     RUN_UNARY(testBitNotImm32, int32Operands());
    617     RUN_UNARY(testBitNotMem32, int32Operands());
    618     RUN_BINARY(testNotOnBooleanAndBranch32, int32Operands(), int32Operands());
    619     RUN_BINARY(testBitNotOnBooleanAndBranch32, int32Operands(), int32Operands());
     169    addBitTests(filter, tasks);
    620170
    621171    RUN(testShlArgs(1, 0));
    … …  
    676226    RUN(testShlZShrArgImm32(0xffffffff, 63));
    677227
    678     RUN(testSShrArgs(1, 0));
    679     RUN(testSShrArgs(1, 1));
    680     RUN(testSShrArgs(1, 62));
    681     RUN(testSShrArgs(0xffffffffffffffff, 0));
    682     RUN(testSShrArgs(0xffffffffffffffff, 1));
    683     RUN(testSShrArgs(0xffffffffffffffff, 63));
    684     RUN(testSShrImms(1, 0));
    685     RUN(testSShrImms(1, 1));
    686     RUN(testSShrImms(1, 62));
    687     RUN(testSShrImms(1, 65));
    688     RUN(testSShrImms(0xffffffffffffffff, 0));
    689     RUN(testSShrImms(0xffffffffffffffff, 1));
    690     RUN(testSShrImms(0xffffffffffffffff, 63));
    691     RUN(testSShrArgImm(1, 0));
    692     RUN(testSShrArgImm(1, 1));
    693     RUN(testSShrArgImm(1, 62));
    694     RUN(testSShrArgImm(1, 65));
    695     RUN(testSShrArgImm(0xffffffffffffffff, 0));
    696     RUN(testSShrArgImm(0xffffffffffffffff, 1));
    697     RUN(testSShrArgImm(0xffffffffffffffff, 63));
    698     RUN(testSShrArg32(32));
    699     RUN(testSShrArgs32(1, 0));
    700     RUN(testSShrArgs32(1, 1));
    701     RUN(testSShrArgs32(1, 62));
    702     RUN(testSShrArgs32(1, 33));
    703     RUN(testSShrArgs32(0xffffffff, 0));
    704     RUN(testSShrArgs32(0xffffffff, 1));
    705     RUN(testSShrArgs32(0xffffffff, 63));
    706     RUN(testSShrImms32(1, 0));
    707     RUN(testSShrImms32(1, 1));
    708     RUN(testSShrImms32(1, 62));
    709     RUN(testSShrImms32(1, 33));
    710     RUN(testSShrImms32(0xffffffff, 0));
    711     RUN(testSShrImms32(0xffffffff, 1));
    712     RUN(testSShrImms32(0xffffffff, 63));
    713     RUN(testSShrArgImm32(1, 0));
    714     RUN(testSShrArgImm32(1, 1));
    715     RUN(testSShrArgImm32(1, 62));
    716     RUN(testSShrArgImm32(0xffffffff, 0));
    717     RUN(testSShrArgImm32(0xffffffff, 1));
    718     RUN(testSShrArgImm32(0xffffffff, 63));
    719 
    720     RUN(testZShrArgs(1, 0));
    721     RUN(testZShrArgs(1, 1));
    722     RUN(testZShrArgs(1, 62));
    723     RUN(testZShrArgs(0xffffffffffffffff, 0));
    724     RUN(testZShrArgs(0xffffffffffffffff, 1));
    725     RUN(testZShrArgs(0xffffffffffffffff, 63));
    726     RUN(testZShrImms(1, 0));
    727     RUN(testZShrImms(1, 1));
    728     RUN(testZShrImms(1, 62));
    729     RUN(testZShrImms(1, 65));
    730     RUN(testZShrImms(0xffffffffffffffff, 0));
    731     RUN(testZShrImms(0xffffffffffffffff, 1));
    732     RUN(testZShrImms(0xffffffffffffffff, 63));
    733     RUN(testZShrArgImm(1, 0));
    734     RUN(testZShrArgImm(1, 1));
    735     RUN(testZShrArgImm(1, 62));
    736     RUN(testZShrArgImm(1, 65));
    737     RUN(testZShrArgImm(0xffffffffffffffff, 0));
    738     RUN(testZShrArgImm(0xffffffffffffffff, 1));
    739     RUN(testZShrArgImm(0xffffffffffffffff, 63));
    740     RUN(testZShrArg32(32));
    741     RUN(testZShrArgs32(1, 0));
    742     RUN(testZShrArgs32(1, 1));
    743     RUN(testZShrArgs32(1, 62));
    744     RUN(testZShrArgs32(1, 33));
    745     RUN(testZShrArgs32(0xffffffff, 0));
    746     RUN(testZShrArgs32(0xffffffff, 1));
    747     RUN(testZShrArgs32(0xffffffff, 63));
    748     RUN(testZShrImms32(1, 0));
    749     RUN(testZShrImms32(1, 1));
    750     RUN(testZShrImms32(1, 62));
    751     RUN(testZShrImms32(1, 33));
    752     RUN(testZShrImms32(0xffffffff, 0));
    753     RUN(testZShrImms32(0xffffffff, 1));
    754     RUN(testZShrImms32(0xffffffff, 63));
    755     RUN(testZShrArgImm32(1, 0));
    756     RUN(testZShrArgImm32(1, 1));
    757     RUN(testZShrArgImm32(1, 62));
    758     RUN(testZShrArgImm32(0xffffffff, 0));
    759     RUN(testZShrArgImm32(0xffffffff, 1));
    760     RUN(testZShrArgImm32(0xffffffff, 63));
     228    addShrTests(filter, tasks);
    761229
    762230    RUN_UNARY(testClzArg64, int64Operands());
    … …  
    1075543    RUN(testInt32ToDoublePartialRegisterWithoutStall());
    1076544
    1077     RUN(testCallSimple(1, 2));
    1078     RUN(testCallRare(1, 2));
    1079     RUN(testCallRareLive(1, 2, 3));
    1080     RUN(testCallSimplePure(1, 2));
    1081     RUN(testCallFunctionWithHellaArguments());
    1082     RUN(testCallFunctionWithHellaArguments2());
    1083     RUN(testCallFunctionWithHellaArguments3());
    1084 
    1085     RUN(testReturnDouble(0.0));
    1086     RUN(testReturnDouble(negativeZero()));
    1087     RUN(testReturnDouble(42.5));
    1088     RUN_UNARY(testReturnFloat, floatingPointOperands<float>());
    1089 
    1090     RUN(testCallSimpleDouble(1, 2));
    1091     RUN(testCallFunctionWithHellaDoubleArguments());
    1092     RUN_BINARY(testCallSimpleFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
    1093     RUN(testCallFunctionWithHellaFloatArguments());
     545    addCallTests(filter, tasks);
    1094546
    1095547    RUN(testLinearScanWithCalleeOnStack());
    … …  
    1195647    RUN(testTruncSExt32(-1000000000ll));
    1196648
    1197     RUN(testSExt8(0));
    1198     RUN(testSExt8(1));
    1199     RUN(testSExt8(42));
    1200     RUN(testSExt8(-1));
    1201     RUN(testSExt8(0xff));
    1202     RUN(testSExt8(0x100));
    1203     RUN(testSExt8Fold(0));
    1204     RUN(testSExt8Fold(1));
    1205     RUN(testSExt8Fold(42));
    1206     RUN(testSExt8Fold(-1));
    1207     RUN(testSExt8Fold(0xff));
    1208     RUN(testSExt8Fold(0x100));
    1209     RUN(testSExt8SExt8(0));
    1210     RUN(testSExt8SExt8(1));
    1211     RUN(testSExt8SExt8(42));
    1212     RUN(testSExt8SExt8(-1));
    1213     RUN(testSExt8SExt8(0xff));
    1214     RUN(testSExt8SExt8(0x100));
    1215     RUN(testSExt8SExt16(0));
    1216     RUN(testSExt8SExt16(1));
    1217     RUN(testSExt8SExt16(42));
    1218     RUN(testSExt8SExt16(-1));
    1219     RUN(testSExt8SExt16(0xff));
    1220     RUN(testSExt8SExt16(0x100));
    1221     RUN(testSExt8SExt16(0xffff));
    1222     RUN(testSExt8SExt16(0x10000));
    1223     RUN(testSExt8BitAnd(0, 0));
    1224     RUN(testSExt8BitAnd(1, 0));
    1225     RUN(testSExt8BitAnd(42, 0));
    1226     RUN(testSExt8BitAnd(-1, 0));
    1227     RUN(testSExt8BitAnd(0xff, 0));
    1228     RUN(testSExt8BitAnd(0x100, 0));
    1229     RUN(testSExt8BitAnd(0xffff, 0));
    1230     RUN(testSExt8BitAnd(0x10000, 0));
    1231     RUN(testSExt8BitAnd(0, 0xf));
    1232     RUN(testSExt8BitAnd(1, 0xf));
    1233     RUN(testSExt8BitAnd(42, 0xf));
    1234     RUN(testSExt8BitAnd(-1, 0xf));
    1235     RUN(testSExt8BitAnd(0xff, 0xf));
    1236     RUN(testSExt8BitAnd(0x100, 0xf));
    1237     RUN(testSExt8BitAnd(0xffff, 0xf));
    1238     RUN(testSExt8BitAnd(0x10000, 0xf));
    1239     RUN(testSExt8BitAnd(0, 0xff));
    1240     RUN(testSExt8BitAnd(1, 0xff));
    1241     RUN(testSExt8BitAnd(42, 0xff));
    1242     RUN(testSExt8BitAnd(-1, 0xff));
    1243     RUN(testSExt8BitAnd(0xff, 0xff));
    1244     RUN(testSExt8BitAnd(0x100, 0xff));
    1245     RUN(testSExt8BitAnd(0xffff, 0xff));
    1246     RUN(testSExt8BitAnd(0x10000, 0xff));
    1247     RUN(testSExt8BitAnd(0, 0x80));
    1248     RUN(testSExt8BitAnd(1, 0x80));
    1249     RUN(testSExt8BitAnd(42, 0x80));
    1250     RUN(testSExt8BitAnd(-1, 0x80));
    1251     RUN(testSExt8BitAnd(0xff, 0x80));
    1252     RUN(testSExt8BitAnd(0x100, 0x80));
    1253     RUN(testSExt8BitAnd(0xffff, 0x80));
    1254     RUN(testSExt8BitAnd(0x10000, 0x80));
    1255     RUN(testBitAndSExt8(0, 0xf));
    1256     RUN(testBitAndSExt8(1, 0xf));
    1257     RUN(testBitAndSExt8(42, 0xf));
    1258     RUN(testBitAndSExt8(-1, 0xf));
    1259     RUN(testBitAndSExt8(0xff, 0xf));
    1260     RUN(testBitAndSExt8(0x100, 0xf));
    1261     RUN(testBitAndSExt8(0xffff, 0xf));
    1262     RUN(testBitAndSExt8(0x10000, 0xf));
    1263     RUN(testBitAndSExt8(0, 0xff));
    1264     RUN(testBitAndSExt8(1, 0xff));
    1265     RUN(testBitAndSExt8(42, 0xff));
    1266     RUN(testBitAndSExt8(-1, 0xff));
    1267     RUN(testBitAndSExt8(0xff, 0xff));
    1268     RUN(testBitAndSExt8(0x100, 0xff));
    1269     RUN(testBitAndSExt8(0xffff, 0xff));
    1270     RUN(testBitAndSExt8(0x10000, 0xff));
    1271     RUN(testBitAndSExt8(0, 0xfff));
    1272     RUN(testBitAndSExt8(1, 0xfff));
    1273     RUN(testBitAndSExt8(42, 0xfff));
    1274     RUN(testBitAndSExt8(-1, 0xfff));
    1275     RUN(testBitAndSExt8(0xff, 0xfff));
    1276     RUN(testBitAndSExt8(0x100, 0xfff));
    1277     RUN(testBitAndSExt8(0xffff, 0xfff));
    1278     RUN(testBitAndSExt8(0x10000, 0xfff));
    1279 
    1280     RUN(testSExt16(0));
    1281     RUN(testSExt16(1));
    1282     RUN(testSExt16(42));
    1283     RUN(testSExt16(-1));
    1284     RUN(testSExt16(0xffff));
    1285     RUN(testSExt16(0x10000));
    1286     RUN(testSExt16Fold(0));
    1287     RUN(testSExt16Fold(1));
    1288     RUN(testSExt16Fold(42));
    1289     RUN(testSExt16Fold(-1));
    1290     RUN(testSExt16Fold(0xffff));
    1291     RUN(testSExt16Fold(0x10000));
    1292     RUN(testSExt16SExt8(0));
    1293     RUN(testSExt16SExt8(1));
    1294     RUN(testSExt16SExt8(42));
    1295     RUN(testSExt16SExt8(-1));
    1296     RUN(testSExt16SExt8(0xffff));
    1297     RUN(testSExt16SExt8(0x10000));
    1298     RUN(testSExt16SExt16(0));
    1299     RUN(testSExt16SExt16(1));
    1300     RUN(testSExt16SExt16(42));
    1301     RUN(testSExt16SExt16(-1));
    1302     RUN(testSExt16SExt16(0xffff));
    1303     RUN(testSExt16SExt16(0x10000));
    1304     RUN(testSExt16SExt16(0xffffff));
    1305     RUN(testSExt16SExt16(0x1000000));
    1306     RUN(testSExt16BitAnd(0, 0));
    1307     RUN(testSExt16BitAnd(1, 0));
    1308     RUN(testSExt16BitAnd(42, 0));
    1309     RUN(testSExt16BitAnd(-1, 0));
    1310     RUN(testSExt16BitAnd(0xffff, 0));
    1311     RUN(testSExt16BitAnd(0x10000, 0));
    1312     RUN(testSExt16BitAnd(0xffffff, 0));
    1313     RUN(testSExt16BitAnd(0x1000000, 0));
    1314     RUN(testSExt16BitAnd(0, 0xf));
    1315     RUN(testSExt16BitAnd(1, 0xf));
    1316     RUN(testSExt16BitAnd(42, 0xf));
    1317     RUN(testSExt16BitAnd(-1, 0xf));
    1318     RUN(testSExt16BitAnd(0xffff, 0xf));
    1319     RUN(testSExt16BitAnd(0x10000, 0xf));
    1320     RUN(testSExt16BitAnd(0xffffff, 0xf));
    1321     RUN(testSExt16BitAnd(0x1000000, 0xf));
    1322     RUN(testSExt16BitAnd(0, 0xffff));
    1323     RUN(testSExt16BitAnd(1, 0xffff));
    1324     RUN(testSExt16BitAnd(42, 0xffff));
    1325     RUN(testSExt16BitAnd(-1, 0xffff));
    1326     RUN(testSExt16BitAnd(0xffff, 0xffff));
    1327     RUN(testSExt16BitAnd(0x10000, 0xffff));
    1328     RUN(testSExt16BitAnd(0xffffff, 0xffff));
    1329     RUN(testSExt16BitAnd(0x1000000, 0xffff));
    1330     RUN(testSExt16BitAnd(0, 0x8000));
    1331     RUN(testSExt16BitAnd(1, 0x8000));
    1332     RUN(testSExt16BitAnd(42, 0x8000));
    1333     RUN(testSExt16BitAnd(-1, 0x8000));
    1334     RUN(testSExt16BitAnd(0xffff, 0x8000));
    1335     RUN(testSExt16BitAnd(0x10000, 0x8000));
    1336     RUN(testSExt16BitAnd(0xffffff, 0x8000));
    1337     RUN(testSExt16BitAnd(0x1000000, 0x8000));
    1338     RUN(testBitAndSExt16(0, 0xf));
    1339     RUN(testBitAndSExt16(1, 0xf));
    1340     RUN(testBitAndSExt16(42, 0xf));
    1341     RUN(testBitAndSExt16(-1, 0xf));
    1342     RUN(testBitAndSExt16(0xffff, 0xf));
    1343     RUN(testBitAndSExt16(0x10000, 0xf));
    1344     RUN(testBitAndSExt16(0xffffff, 0xf));
    1345     RUN(testBitAndSExt16(0x1000000, 0xf));
    1346     RUN(testBitAndSExt16(0, 0xffff));
    1347     RUN(testBitAndSExt16(1, 0xffff));
    1348     RUN(testBitAndSExt16(42, 0xffff));
    1349     RUN(testBitAndSExt16(-1, 0xffff));
    1350     RUN(testBitAndSExt16(0xffff, 0xffff));
    1351     RUN(testBitAndSExt16(0x10000, 0xffff));
    1352     RUN(testBitAndSExt16(0xffffff, 0xffff));
    1353     RUN(testBitAndSExt16(0x1000000, 0xffff));
    1354     RUN(testBitAndSExt16(0, 0xfffff));
    1355     RUN(testBitAndSExt16(1, 0xfffff));
    1356     RUN(testBitAndSExt16(42, 0xfffff));
    1357     RUN(testBitAndSExt16(-1, 0xfffff));
    1358     RUN(testBitAndSExt16(0xffff, 0xfffff));
    1359     RUN(testBitAndSExt16(0x10000, 0xfffff));
    1360     RUN(testBitAndSExt16(0xffffff, 0xfffff));
    1361     RUN(testBitAndSExt16(0x1000000, 0xfffff));
    1362 
    1363     RUN(testSExt32BitAnd(0, 0));
    1364     RUN(testSExt32BitAnd(1, 0));
    1365     RUN(testSExt32BitAnd(42, 0));
    1366     RUN(testSExt32BitAnd(-1, 0));
    1367     RUN(testSExt32BitAnd(0x80000000, 0));
    1368     RUN(testSExt32BitAnd(0, 0xf));
    1369     RUN(testSExt32BitAnd(1, 0xf));
    1370     RUN(testSExt32BitAnd(42, 0xf));
    1371     RUN(testSExt32BitAnd(-1, 0xf));
    1372     RUN(testSExt32BitAnd(0x80000000, 0xf));
    1373     RUN(testSExt32BitAnd(0, 0x80000000));
    1374     RUN(testSExt32BitAnd(1, 0x80000000));
    1375     RUN(testSExt32BitAnd(42, 0x80000000));
    1376     RUN(testSExt32BitAnd(-1, 0x80000000));
    1377     RUN(testSExt32BitAnd(0x80000000, 0x80000000));
    1378     RUN(testBitAndSExt32(0, 0xf));
    1379     RUN(testBitAndSExt32(1, 0xf));
    1380     RUN(testBitAndSExt32(42, 0xf));
    1381     RUN(testBitAndSExt32(-1, 0xf));
    1382     RUN(testBitAndSExt32(0xffff, 0xf));
    1383     RUN(testBitAndSExt32(0x10000, 0xf));
    1384     RUN(testBitAndSExt32(0xffffff, 0xf));
    1385     RUN(testBitAndSExt32(0x1000000, 0xf));
    1386     RUN(testBitAndSExt32(0, 0xffff00000000llu));
    1387     RUN(testBitAndSExt32(1, 0xffff00000000llu));
    1388     RUN(testBitAndSExt32(42, 0xffff00000000llu));
    1389     RUN(testBitAndSExt32(-1, 0xffff00000000llu));
    1390     RUN(testBitAndSExt32(0x80000000, 0xffff00000000llu));
     649    addSExtTests(filter, tasks);
    1391650
    1392651    RUN(testBasicSelect());
    … …  
    1447706    RUN(testStore16Load16Z(-123));
    1448707
    1449     RUN(testSShrShl32(42, 24, 24));
    1450     RUN(testSShrShl32(-42, 24, 24));
    1451     RUN(testSShrShl32(4200, 24, 24));
    1452     RUN(testSShrShl32(-4200, 24, 24));
    1453     RUN(testSShrShl32(4200000, 24, 24));
    1454     RUN(testSShrShl32(-4200000, 24, 24));
    1455 
    1456     RUN(testSShrShl32(42, 16, 16));
    1457     RUN(testSShrShl32(-42, 16, 16));
    1458     RUN(testSShrShl32(4200, 16, 16));
    1459     RUN(testSShrShl32(-4200, 16, 16));
    1460     RUN(testSShrShl32(4200000, 16, 16));
    1461     RUN(testSShrShl32(-4200000, 16, 16));
    1462 
    1463     RUN(testSShrShl32(42, 8, 8));
    1464     RUN(testSShrShl32(-42, 8, 8));
    1465     RUN(testSShrShl32(4200, 8, 8));
    1466     RUN(testSShrShl32(-4200, 8, 8));
    1467     RUN(testSShrShl32(4200000, 8, 8));
    1468     RUN(testSShrShl32(-4200000, 8, 8));
    1469     RUN(testSShrShl32(420000000, 8, 8));
    1470     RUN(testSShrShl32(-420000000, 8, 8));
    1471 
    1472     RUN(testSShrShl64(42, 56, 56));
    1473     RUN(testSShrShl64(-42, 56, 56));
    1474     RUN(testSShrShl64(4200, 56, 56));
    1475     RUN(testSShrShl64(-4200, 56, 56));
    1476     RUN(testSShrShl64(4200000, 56, 56));
    1477     RUN(testSShrShl64(-4200000, 56, 56));
    1478     RUN(testSShrShl64(420000000, 56, 56));
    1479     RUN(testSShrShl64(-420000000, 56, 56));
    1480     RUN(testSShrShl64(42000000000, 56, 56));
    1481     RUN(testSShrShl64(-42000000000, 56, 56));
    1482 
    1483     RUN(testSShrShl64(42, 48, 48));
    1484     RUN(testSShrShl64(-42, 48, 48));
    1485     RUN(testSShrShl64(4200, 48, 48));
    1486     RUN(testSShrShl64(-4200, 48, 48));
    1487     RUN(testSShrShl64(4200000, 48, 48));
    1488     RUN(testSShrShl64(-4200000, 48, 48));
    1489     RUN(testSShrShl64(420000000, 48, 48));
    1490     RUN(testSShrShl64(-420000000, 48, 48));
    1491     RUN(testSShrShl64(42000000000, 48, 48));
    1492     RUN(testSShrShl64(-42000000000, 48, 48));
    1493 
    1494     RUN(testSShrShl64(42, 32, 32));
    1495     RUN(testSShrShl64(-42, 32, 32));
    1496     RUN(testSShrShl64(4200, 32, 32));
    1497     RUN(testSShrShl64(-4200, 32, 32));
    1498     RUN(testSShrShl64(4200000, 32, 32));
    1499     RUN(testSShrShl64(-4200000, 32, 32));
    1500     RUN(testSShrShl64(420000000, 32, 32));
    1501     RUN(testSShrShl64(-420000000, 32, 32));
    1502     RUN(testSShrShl64(42000000000, 32, 32));
    1503     RUN(testSShrShl64(-42000000000, 32, 32));
    1504 
    1505     RUN(testSShrShl64(42, 24, 24));
    1506     RUN(testSShrShl64(-42, 24, 24));
    1507     RUN(testSShrShl64(4200, 24, 24));
    1508     RUN(testSShrShl64(-4200, 24, 24));
    1509     RUN(testSShrShl64(4200000, 24, 24));
    1510     RUN(testSShrShl64(-4200000, 24, 24));
    1511     RUN(testSShrShl64(420000000, 24, 24));
    1512     RUN(testSShrShl64(-420000000, 24, 24));
    1513     RUN(testSShrShl64(42000000000, 24, 24));
    1514     RUN(testSShrShl64(-42000000000, 24, 24));
    1515 
    1516     RUN(testSShrShl64(42, 16, 16));
    1517     RUN(testSShrShl64(-42, 16, 16));
    1518     RUN(testSShrShl64(4200, 16, 16));
    1519     RUN(testSShrShl64(-4200, 16, 16));
    1520     RUN(testSShrShl64(4200000, 16, 16));
    1521     RUN(testSShrShl64(-4200000, 16, 16));
    1522     RUN(testSShrShl64(420000000, 16, 16));
    1523     RUN(testSShrShl64(-420000000, 16, 16));
    1524     RUN(testSShrShl64(42000000000, 16, 16));
    1525     RUN(testSShrShl64(-42000000000, 16, 16));
    1526 
    1527     RUN(testSShrShl64(42, 8, 8));
    1528     RUN(testSShrShl64(-42, 8, 8));
    1529     RUN(testSShrShl64(4200, 8, 8));
    1530     RUN(testSShrShl64(-4200, 8, 8));
    1531     RUN(testSShrShl64(4200000, 8, 8));
    1532     RUN(testSShrShl64(-4200000, 8, 8));
    1533     RUN(testSShrShl64(420000000, 8, 8));
    1534     RUN(testSShrShl64(-420000000, 8, 8));
    1535     RUN(testSShrShl64(42000000000, 8, 8));
    1536     RUN(testSShrShl64(-42000000000, 8, 8));
     708    addSShrShTests(filter, tasks);
    1537709
    1538710    RUN(testCheckMul64SShr());

  • trunk/Source/JavaScriptCore/b3/testb3_2.cpp

    r248087 r248098  
    142142}
    143143
    144 void testBitXorTreeArgs(int64_t a, int64_t b)
     144static void testBitXorTreeArgs(int64_t a, int64_t b)
    145145{
    146146    Procedure proc;
    … …  
    157157}
    158158
    159 void testBitXorTreeArgsEven(int64_t a, int64_t b)
     159static void testBitXorTreeArgsEven(int64_t a, int64_t b)
    160160{
    161161    Procedure proc;
    … …  
    171171}
    172172
    173 void testBitXorTreeArgImm(int64_t a, int64_t b)
     173static void testBitXorTreeArgImm(int64_t a, int64_t b)
    174174{
    175175    Procedure proc;
    … …  
    234234}
    235235
    236 void testBitAndTreeArg32(int32_t a)
     236static void testBitAndTreeArg32(int32_t a)
    237237{
    238238    Procedure proc;
    … …  
    251251}
    252252
    253 void testBitOrTreeArg32(int32_t a)
     253static void testBitOrTreeArg32(int32_t a)
    254254{
    255255    Procedure proc;
    … …  
    25192519}
    25202520
    2521 void testBitAndArgs(int64_t a, int64_t b)
     2521static void testBitAndArgs(int64_t a, int64_t b)
    25222522{
    25232523    Procedure proc;
    … …  
    25332533}
    25342534
    2535 void testBitAndSameArg(int64_t a)
     2535static void testBitAndSameArg(int64_t a)
    25362536{
    25372537    Procedure proc;
    … …  
    25482548}
    25492549
    2550 void testBitAndNotNot(int64_t a, int64_t b)
     2550static void testBitAndNotNot(int64_t a, int64_t b)
    25512551{
    25522552    Procedure proc;
    … …  
    25662566}
    25672567
    2568 void testBitAndNotImm(int64_t a, int64_t b)
     2568static void testBitAndNotImm(int64_t a, int64_t b)
    25692569{
    25702570    Procedure proc;
    … …  
    25832583}
    25842584
    2585 void testBitAndImms(int64_t a, int64_t b)
     2585static void testBitAndImms(int64_t a, int64_t b)
    25862586{
    25872587    Procedure proc;
    … …  
    25972597}
    25982598
    2599 void testBitAndArgImm(int64_t a, int64_t b)
     2599static void testBitAndArgImm(int64_t a, int64_t b)
    26002600{
    26012601    Procedure proc;
    … …  
    26112611}
    26122612
    2613 void testBitAndImmArg(int64_t a, int64_t b)
     2613static void testBitAndImmArg(int64_t a, int64_t b)
    26142614{
    26152615    Procedure proc;
    … …  
    26252625}
    26262626
    2627 void testBitAndBitAndArgImmImm(int64_t a, int64_t b, int64_t c)
     2627static void testBitAndBitAndArgImmImm(int64_t a, int64_t b, int64_t c)
    26282628{
    26292629    Procedure proc;
    … …  
    26432643}
    26442644
    2645 void testBitAndImmBitAndArgImm(int64_t a, int64_t b, int64_t c)
     2645static void testBitAndImmBitAndArgImm(int64_t a, int64_t b, int64_t c)
    26462646{
    26472647    Procedure proc;
    … …  
    26612661}
    26622662
    2663 void testBitAndArgs32(int a, int b)
     2663static void testBitAndArgs32(int a, int b)
    26642664{
    26652665    Procedure proc;
    … …  
    26792679}
    26802680
    2681 void testBitAndSameArg32(int a)
     2681static void testBitAndSameArg32(int a)
    26822682{
    26832683    Procedure proc;
    … …  
    26952695}
    26962696
    2697 void testBitAndImms32(int a, int b)
     2697static void testBitAndImms32(int a, int b)
    26982698{
    26992699    Procedure proc;
    … …  
    27092709}
    27102710
    2711 void testBitAndArgImm32(int a, int b)
     2711static void testBitAndArgImm32(int a, int b)
    27122712{
    27132713    Procedure proc;
    … …  
    27252725}
    27262726
    2727 void testBitAndImmArg32(int a, int b)
     2727static void testBitAndImmArg32(int a, int b)
    27282728{
    27292729    Procedure proc;
    … …  
    27412741}
    27422742
    2743 void testBitAndBitAndArgImmImm32(int a, int b, int c)
     2743static void testBitAndBitAndArgImmImm32(int a, int b, int c)
    27442744{
    27452745    Procedure proc;
    … …  
    27612761}
    27622762
    2763 void testBitAndImmBitAndArgImm32(int a, int b, int c)
     2763static void testBitAndImmBitAndArgImm32(int a, int b, int c)
    27642764{
    27652765    Procedure proc;
    … …  
    27812781}
    27822782
    2783 void testBitAndWithMaskReturnsBooleans(int64_t a, int64_t b)
     2783static void testBitAndWithMaskReturnsBooleans(int64_t a, int64_t b)
    27842784{
    27852785    Procedure proc;
    … …  
    28092809}
    28102810
    2811 void testBitAndArgDouble(double a)
     2811static void testBitAndArgDouble(double a)
    28122812{
    28132813    Procedure proc;
    … …  
    28202820}
    28212821
    2822 void testBitAndArgsDouble(double a, double b)
     2822static void testBitAndArgsDouble(double a, double b)
    28232823{
    28242824    Procedure proc;
    … …  
    28322832}
    28332833
    2834 void testBitAndArgImmDouble(double a, double b)
     2834static void testBitAndArgImmDouble(double a, double b)
    28352835{
    28362836    Procedure proc;
    … …  
    28442844}
    28452845
    2846 void testBitAndImmsDouble(double a, double b)
     2846static void testBitAndImmsDouble(double a, double b)
    28472847{
    28482848    Procedure proc;
    … …  
    28612861}
    28622862
    2863 void testBitAndArgFloat(float a)
     2863static void testBitAndArgFloat(float a)
    28642864{
    28652865    Procedure proc;
    … …  
    28742874}
    28752875
    2876 void testBitAndArgsFloat(float a, float b)
     2876static void testBitAndArgsFloat(float a, float b)
    28772877{
    28782878    Procedure proc;
    … …  
    28902890}
    28912891
    2892 void testBitAndArgImmFloat(float a, float b)
     2892static void testBitAndArgImmFloat(float a, float b)
    28932893{
    28942894    Procedure proc;
    … …  
    29042904}
    29052905
    2906 void testBitAndImmsFloat(float a, float b)
     2906static void testBitAndImmsFloat(float a, float b)
    29072907{
    29082908    Procedure proc;
    … …  
    29162916}
    29172917
    2918 void testBitAndArgsFloatWithUselessDoubleConversion(float a, float b)
     2918static void testBitAndArgsFloatWithUselessDoubleConversion(float a, float b)
    29192919{
    29202920    Procedure proc;
    … …  
    29382938}
    29392939
    2940 void testBitOrArgs(int64_t a, int64_t b)
     2940static void testBitOrArgs(int64_t a, int64_t b)
    29412941{
    29422942    Procedure proc;
    … …  
    29522952}
    29532953
    2954 void testBitOrSameArg(int64_t a)
     2954static void testBitOrSameArg(int64_t a)
    29552955{
    29562956    Procedure proc;
    … …  
    29672967}
    29682968
    2969 void testBitOrAndAndArgs(int64_t a, int64_t b, int64_t c)
     2969static void testBitOrAndAndArgs(int64_t a, int64_t b, int64_t c)
    29702970{
    29712971    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
    … …  
    29952995}
    29962996
    2997 void testBitOrAndSameArgs(int64_t a, int64_t b)
     2997static void testBitOrAndSameArgs(int64_t a, int64_t b)
    29982998{
    29992999    // We want to check every possible ordering of arguments (to properly check every path in B3ReduceStrength):
    … …  
    30173017}
    30183018
    3019 void testBitOrNotNot(int64_t a, int64_t b)
     3019static void testBitOrNotNot(int64_t a, int64_t b)
    30203020{
    30213021    Procedure proc;
    … …  
    30353035}
    30363036
    3037 void testBitOrNotImm(int64_t a, int64_t b)
     3037static void testBitOrNotImm(int64_t a, int64_t b)
    30383038{
    30393039    Procedure proc;
    … …  
    30523052}
    30533053
    3054 void testBitOrImms(int64_t a, int64_t b)
     3054static void testBitOrImms(int64_t a, int64_t b)
    30553055{
    30563056    Procedure proc;
    … …  
    30663066}
    30673067
    3068 void testBitOrArgImm(int64_t a, int64_t b)
     3068static void testBitOrArgImm(int64_t a, int64_t b)
    30693069{
    30703070    Procedure proc;
    … …  
    30803080}
    30813081
    3082 void testBitOrImmArg(int64_t a, int64_t b)
     3082static void testBitOrImmArg(int64_t a, int64_t b)
    30833083{
    30843084    Procedure proc;
    … …  
    30943094}
    30953095
    3096 void testBitOrBitOrArgImmImm(int64_t a, int64_t b, int64_t c)
     3096static void testBitOrBitOrArgImmImm(int64_t a, int64_t b, int64_t c)
    30973097{
    30983098    Procedure proc;
    … …  
    31123112}
    31133113
    3114 void testBitOrImmBitOrArgImm(int64_t a, int64_t b, int64_t c)
     3114static void testBitOrImmBitOrArgImm(int64_t a, int64_t b, int64_t c)
    31153115{
    31163116    Procedure proc;
    … …  
    31303130}
    31313131
    3132 void testBitOrArgs32(int a, int b)
     3132static void testBitOrArgs32(int a, int b)
    31333133{
    31343134    Procedure proc;
    … …  
    31483148}
    31493149
    3150 void testBitOrSameArg32(int a)
     3150static void testBitOrSameArg32(int a)
    31513151{
    31523152    Procedure proc;
    … …  
    31653165}
    31663166
    3167 void testBitOrImms32(int a, int b)
     3167static void testBitOrImms32(int a, int b)
    31683168{
    31693169    Procedure proc;
    … …  
    31793179}
    31803180
    3181 void testBitOrArgImm32(int a, int b)
     3181static void testBitOrArgImm32(int a, int b)
    31823182{
    31833183    Procedure proc;
    … …  
    31953195}
    31963196
    3197 void testBitOrImmArg32(int a, int b)
     3197static void testBitOrImmArg32(int a, int b)
    31983198{
    31993199    Procedure proc;
    … …  
    32113211}
    32123212
     3213void addBitTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     3214{
     3215    RUN(testBitAndArgs(43, 43));
     3216    RUN(testBitAndArgs(43, 0));
     3217    RUN(testBitAndArgs(10, 3));
     3218    RUN(testBitAndArgs(42, 0xffffffffffffffff));
     3219    RUN(testBitAndSameArg(43));
     3220    RUN(testBitAndSameArg(0));
     3221    RUN(testBitAndSameArg(3));
     3222    RUN(testBitAndSameArg(0xffffffffffffffff));
     3223    RUN(testBitAndImms(43, 43));
     3224    RUN(testBitAndImms(43, 0));
     3225    RUN(testBitAndImms(10, 3));
     3226    RUN(testBitAndImms(42, 0xffffffffffffffff));
     3227    RUN(testBitAndArgImm(43, 43));
     3228    RUN(testBitAndArgImm(43, 0));
     3229    RUN(testBitAndArgImm(10, 3));
     3230    RUN(testBitAndArgImm(42, 0xffffffffffffffff));
     3231    RUN(testBitAndArgImm(42, 0xff));
     3232    RUN(testBitAndArgImm(300, 0xff));
     3233    RUN(testBitAndArgImm(-300, 0xff));
     3234    RUN(testBitAndArgImm(42, 0xffff));
     3235    RUN(testBitAndArgImm(40000, 0xffff));
     3236    RUN(testBitAndArgImm(-40000, 0xffff));
     3237    RUN(testBitAndImmArg(43, 43));
     3238    RUN(testBitAndImmArg(43, 0));
     3239    RUN(testBitAndImmArg(10, 3));
     3240    RUN(testBitAndImmArg(42, 0xffffffffffffffff));
     3241    RUN(testBitAndBitAndArgImmImm(2, 7, 3));
     3242    RUN(testBitAndBitAndArgImmImm(1, 6, 6));
     3243    RUN(testBitAndBitAndArgImmImm(0xffff, 24, 7));
     3244    RUN(testBitAndImmBitAndArgImm(7, 2, 3));
     3245    RUN(testBitAndImmBitAndArgImm(6, 1, 6));
     3246    RUN(testBitAndImmBitAndArgImm(24, 0xffff, 7));
     3247    RUN(testBitAndArgs32(43, 43));
     3248    RUN(testBitAndArgs32(43, 0));
     3249    RUN(testBitAndArgs32(10, 3));
     3250    RUN(testBitAndArgs32(42, 0xffffffff));
     3251    RUN(testBitAndSameArg32(43));
     3252    RUN(testBitAndSameArg32(0));
     3253    RUN(testBitAndSameArg32(3));
     3254    RUN(testBitAndSameArg32(0xffffffff));
     3255    RUN(testBitAndImms32(43, 43));
     3256    RUN(testBitAndImms32(43, 0));
     3257    RUN(testBitAndImms32(10, 3));
     3258    RUN(testBitAndImms32(42, 0xffffffff));
     3259    RUN(testBitAndArgImm32(43, 43));
     3260    RUN(testBitAndArgImm32(43, 0));
     3261    RUN(testBitAndArgImm32(10, 3));
     3262    RUN(testBitAndArgImm32(42, 0xffffffff));
     3263    RUN(testBitAndImmArg32(43, 43));
     3264    RUN(testBitAndImmArg32(43, 0));
     3265    RUN(testBitAndImmArg32(10, 3));
     3266    RUN(testBitAndImmArg32(42, 0xffffffff));
     3267    RUN(testBitAndImmArg32(42, 0xff));
     3268    RUN(testBitAndImmArg32(300, 0xff));
     3269    RUN(testBitAndImmArg32(-300, 0xff));
     3270    RUN(testBitAndImmArg32(42, 0xffff));
     3271    RUN(testBitAndImmArg32(40000, 0xffff));
     3272    RUN(testBitAndImmArg32(-40000, 0xffff));
     3273    RUN(testBitAndBitAndArgImmImm32(2, 7, 3));
     3274    RUN(testBitAndBitAndArgImmImm32(1, 6, 6));
     3275    RUN(testBitAndBitAndArgImmImm32(0xffff, 24, 7));
     3276    RUN(testBitAndImmBitAndArgImm32(7, 2, 3));
     3277    RUN(testBitAndImmBitAndArgImm32(6, 1, 6));
     3278    RUN(testBitAndImmBitAndArgImm32(24, 0xffff, 7));
     3279    RUN_BINARY(testBitAndWithMaskReturnsBooleans, int64Operands(), int64Operands());
     3280    RUN_UNARY(testBitAndArgDouble, floatingPointOperands<double>());
     3281    RUN_BINARY(testBitAndArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3282    RUN_BINARY(testBitAndArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3283    RUN_BINARY(testBitAndImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3284    RUN_UNARY(testBitAndArgFloat, floatingPointOperands<float>());
     3285    RUN_BINARY(testBitAndArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3286    RUN_BINARY(testBitAndArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3287    RUN_BINARY(testBitAndImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3288    RUN_BINARY(testBitAndArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3289    RUN_BINARY(testBitAndNotNot, int64Operands(), int64Operands());
     3290    RUN_BINARY(testBitAndNotImm, int64Operands(), int64Operands());
     3291   
     3292    RUN(testBitOrArgs(43, 43));
     3293    RUN(testBitOrArgs(43, 0));
     3294    RUN(testBitOrArgs(10, 3));
     3295    RUN(testBitOrArgs(42, 0xffffffffffffffff));
     3296    RUN(testBitOrSameArg(43));
     3297    RUN(testBitOrSameArg(0));
     3298    RUN(testBitOrSameArg(3));
     3299    RUN(testBitOrSameArg(0xffffffffffffffff));
     3300    RUN(testBitOrImms(43, 43));
     3301    RUN(testBitOrImms(43, 0));
     3302    RUN(testBitOrImms(10, 3));
     3303    RUN(testBitOrImms(42, 0xffffffffffffffff));
     3304    RUN(testBitOrArgImm(43, 43));
     3305    RUN(testBitOrArgImm(43, 0));
     3306    RUN(testBitOrArgImm(10, 3));
     3307    RUN(testBitOrArgImm(42, 0xffffffffffffffff));
     3308    RUN(testBitOrImmArg(43, 43));
     3309    RUN(testBitOrImmArg(43, 0));
     3310    RUN(testBitOrImmArg(10, 3));
     3311    RUN(testBitOrImmArg(42, 0xffffffffffffffff));
     3312    RUN(testBitOrBitOrArgImmImm(2, 7, 3));
     3313    RUN(testBitOrBitOrArgImmImm(1, 6, 6));
     3314    RUN(testBitOrBitOrArgImmImm(0xffff, 24, 7));
     3315    RUN(testBitOrImmBitOrArgImm(7, 2, 3));
     3316    RUN(testBitOrImmBitOrArgImm(6, 1, 6));
     3317    RUN(testBitOrImmBitOrArgImm(24, 0xffff, 7));
     3318    RUN(testBitOrArgs32(43, 43));
     3319    RUN(testBitOrArgs32(43, 0));
     3320    RUN(testBitOrArgs32(10, 3));
     3321    RUN(testBitOrArgs32(42, 0xffffffff));
     3322    RUN(testBitOrSameArg32(43));
     3323    RUN(testBitOrSameArg32(0));
     3324    RUN(testBitOrSameArg32(3));
     3325    RUN(testBitOrSameArg32(0xffffffff));
     3326    RUN(testBitOrImms32(43, 43));
     3327    RUN(testBitOrImms32(43, 0));
     3328    RUN(testBitOrImms32(10, 3));
     3329    RUN(testBitOrImms32(42, 0xffffffff));
     3330    RUN(testBitOrArgImm32(43, 43));
     3331    RUN(testBitOrArgImm32(43, 0));
     3332    RUN(testBitOrArgImm32(10, 3));
     3333    RUN(testBitOrArgImm32(42, 0xffffffff));
     3334    RUN(testBitOrImmArg32(43, 43));
     3335    RUN(testBitOrImmArg32(43, 0));
     3336    RUN(testBitOrImmArg32(10, 3));
     3337    RUN(testBitOrImmArg32(42, 0xffffffff));
     3338    RUN(testBitOrBitOrArgImmImm32(2, 7, 3));
     3339    RUN(testBitOrBitOrArgImmImm32(1, 6, 6));
     3340    RUN(testBitOrBitOrArgImmImm32(0xffff, 24, 7));
     3341    RUN(testBitOrImmBitOrArgImm32(7, 2, 3));
     3342    RUN(testBitOrImmBitOrArgImm32(6, 1, 6));
     3343    RUN(testBitOrImmBitOrArgImm32(24, 0xffff, 7));
     3344    RUN_UNARY(testBitOrArgDouble, floatingPointOperands<double>());
     3345    RUN_BINARY(testBitOrArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3346    RUN_BINARY(testBitOrArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3347    RUN_BINARY(testBitOrImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3348    RUN_UNARY(testBitOrArgFloat, floatingPointOperands<float>());
     3349    RUN_BINARY(testBitOrArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3350    RUN_BINARY(testBitOrArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3351    RUN_BINARY(testBitOrImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3352    RUN_BINARY(testBitOrArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3353    RUN_TERNARY(testBitOrAndAndArgs, int64Operands(), int64Operands(), int64Operands());
     3354    RUN_BINARY(testBitOrAndSameArgs, int64Operands(), int64Operands());
     3355    RUN_BINARY(testBitOrNotNot, int64Operands(), int64Operands());
     3356    RUN_BINARY(testBitOrNotImm, int64Operands(), int64Operands());
     3357   
     3358    RUN_BINARY(testBitXorArgs, int64Operands(), int64Operands());
     3359    RUN_UNARY(testBitXorSameArg, int64Operands());
     3360    RUN_BINARY(testBitXorImms, int64Operands(), int64Operands());
     3361    RUN_BINARY(testBitXorArgImm, int64Operands(), int64Operands());
     3362    RUN_BINARY(testBitXorImmArg, int64Operands(), int64Operands());
     3363    RUN(testBitXorBitXorArgImmImm(2, 7, 3));
     3364    RUN(testBitXorBitXorArgImmImm(1, 6, 6));
     3365    RUN(testBitXorBitXorArgImmImm(0xffff, 24, 7));
     3366    RUN(testBitXorImmBitXorArgImm(7, 2, 3));
     3367    RUN(testBitXorImmBitXorArgImm(6, 1, 6));
     3368    RUN(testBitXorImmBitXorArgImm(24, 0xffff, 7));
     3369    RUN(testBitXorArgs32(43, 43));
     3370    RUN(testBitXorArgs32(43, 0));
     3371    RUN(testBitXorArgs32(10, 3));
     3372    RUN(testBitXorArgs32(42, 0xffffffff));
     3373    RUN(testBitXorSameArg32(43));
     3374    RUN(testBitXorSameArg32(0));
     3375    RUN(testBitXorSameArg32(3));
     3376    RUN(testBitXorSameArg32(0xffffffff));
     3377    RUN(testBitXorImms32(43, 43));
     3378    RUN(testBitXorImms32(43, 0));
     3379    RUN(testBitXorImms32(10, 3));
     3380    RUN(testBitXorImms32(42, 0xffffffff));
     3381    RUN(testBitXorArgImm32(43, 43));
     3382    RUN(testBitXorArgImm32(43, 0));
     3383    RUN(testBitXorArgImm32(10, 3));
     3384    RUN(testBitXorArgImm32(42, 0xffffffff));
     3385    RUN(testBitXorImmArg32(43, 43));
     3386    RUN(testBitXorImmArg32(43, 0));
     3387    RUN(testBitXorImmArg32(10, 3));
     3388    RUN(testBitXorImmArg32(42, 0xffffffff));
     3389    RUN(testBitXorBitXorArgImmImm32(2, 7, 3));
     3390    RUN(testBitXorBitXorArgImmImm32(1, 6, 6));
     3391    RUN(testBitXorBitXorArgImmImm32(0xffff, 24, 7));
     3392    RUN(testBitXorImmBitXorArgImm32(7, 2, 3));
     3393    RUN(testBitXorImmBitXorArgImm32(6, 1, 6));
     3394    RUN(testBitXorImmBitXorArgImm32(24, 0xffff, 7));
     3395    RUN_TERNARY(testBitXorAndAndArgs, int64Operands(), int64Operands(), int64Operands());
     3396    RUN_BINARY(testBitXorAndSameArgs, int64Operands(), int64Operands());
     3397   
     3398    RUN_UNARY(testBitNotArg, int64Operands());
     3399    RUN_UNARY(testBitNotImm, int64Operands());
     3400    RUN_UNARY(testBitNotMem, int64Operands());
     3401    RUN_UNARY(testBitNotArg32, int32Operands());
     3402    RUN_UNARY(testBitNotImm32, int32Operands());
     3403    RUN_UNARY(testBitNotMem32, int32Operands());
     3404    RUN_BINARY(testNotOnBooleanAndBranch32, int32Operands(), int32Operands());
     3405    RUN_BINARY(testBitNotOnBooleanAndBranch32, int32Operands(), int32Operands());
     3406   
     3407    RUN_BINARY(testBitXorTreeArgs, int64Operands(), int64Operands());
     3408    RUN_BINARY(testBitXorTreeArgsEven, int64Operands(), int64Operands());
     3409    RUN_BINARY(testBitXorTreeArgImm, int64Operands(), int64Operands());
     3410    RUN_UNARY(testBitAndTreeArg32, int32Operands());
     3411    RUN_UNARY(testBitOrTreeArg32, int32Operands());
     3412}
     3413
    32133414#endif // ENABLE(B3_JIT)

  • trunk/Source/JavaScriptCore/b3/testb3_3.cpp

    r248087 r248098  
    781781}
    782782
    783 void testSShrArgs(int64_t a, int64_t b)
     783static void testSShrArgs(int64_t a, int64_t b)
    784784{
    785785    Procedure proc;
    … …  
    797797}
    798798
    799 void testSShrImms(int64_t a, int64_t b)
     799static void testSShrImms(int64_t a, int64_t b)
    800800{
    801801    Procedure proc;
    … …  
    811811}
    812812
    813 void testSShrArgImm(int64_t a, int64_t b)
     813static void testSShrArgImm(int64_t a, int64_t b)
    814814{
    815815    Procedure proc;
    … …  
    825825}
    826826
    827 void testSShrArg32(int32_t a)
     827static void testSShrArg32(int32_t a)
    828828{
    829829    Procedure proc;
    … …  
    839839}
    840840
    841 void testSShrArgs32(int32_t a, int32_t b)
     841static void testSShrArgs32(int32_t a, int32_t b)
    842842{
    843843    Procedure proc;
    … …  
    857857}
    858858
    859 void testSShrImms32(int32_t a, int32_t b)
     859static void testSShrImms32(int32_t a, int32_t b)
    860860{
    861861    Procedure proc;
    … …  
    871871}
    872872
    873 void testSShrArgImm32(int32_t a, int32_t b)
     873static void testSShrArgImm32(int32_t a, int32_t b)
    874874{
    875875    Procedure proc;
    … …  
    887887}
    888888
    889 void testZShrArgs(uint64_t a, uint64_t b)
     889static void testZShrArgs(uint64_t a, uint64_t b)
    890890{
    891891    Procedure proc;
    … …  
    903903}
    904904
    905 void testZShrImms(uint64_t a, uint64_t b)
     905static void testZShrImms(uint64_t a, uint64_t b)
    906906{
    907907    Procedure proc;
    … …  
    917917}
    918918
    919 void testZShrArgImm(uint64_t a, uint64_t b)
     919static void testZShrArgImm(uint64_t a, uint64_t b)
    920920{
    921921    Procedure proc;
    … …  
    931931}
    932932
    933 void testZShrArg32(uint32_t a)
     933static void testZShrArg32(uint32_t a)
    934934{
    935935    Procedure proc;
    … …  
    945945}
    946946
    947 void testZShrArgs32(uint32_t a, uint32_t b)
     947static void testZShrArgs32(uint32_t a, uint32_t b)
    948948{
    949949    Procedure proc;
    … …  
    963963}
    964964
    965 void testZShrImms32(uint32_t a, uint32_t b)
     965static void testZShrImms32(uint32_t a, uint32_t b)
    966966{
    967967    Procedure proc;
    … …  
    977977}
    978978
    979 void testZShrArgImm32(uint32_t a, uint32_t b)
     979static void testZShrArgImm32(uint32_t a, uint32_t b)
    980980{
    981981    Procedure proc;
    … …  
    29992999}
    30003000
     3001// Make sure the compiler does not try to optimize anything out.
     3002static NEVER_INLINE double zero()
     3003{
     3004    return 0.;
     3005}
     3006
     3007static double negativeZero()
     3008{
     3009    return -zero();
     3010}
     3011
     3012void addArgTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     3013{
     3014    RUN(testAddArg(111));
     3015    RUN(testAddArgs(1, 1));
     3016    RUN(testAddArgs(1, 2));
     3017    RUN(testAddArgImm(1, 2));
     3018    RUN(testAddArgImm(0, 2));
     3019    RUN(testAddArgImm(1, 0));
     3020    RUN(testAddImmArg(1, 2));
     3021    RUN(testAddImmArg(0, 2));
     3022    RUN(testAddImmArg(1, 0));
     3023    RUN_BINARY(testAddArgMem, int64Operands(), int64Operands());
     3024    RUN_BINARY(testAddMemArg, int64Operands(), int64Operands());
     3025    RUN_BINARY(testAddImmMem, int64Operands(), int64Operands());
     3026    RUN_UNARY(testAddArg32, int32Operands());
     3027    RUN(testAddArgs32(1, 1));
     3028    RUN(testAddArgs32(1, 2));
     3029    RUN_BINARY(testAddArgMem32, int32Operands(), int32Operands());
     3030    RUN_BINARY(testAddMemArg32, int32Operands(), int32Operands());
     3031    RUN_BINARY(testAddImmMem32, int32Operands(), int32Operands());
     3032    RUN_BINARY(testAddNeg1, int32Operands(), int32Operands());
     3033    RUN_BINARY(testAddNeg2, int32Operands(), int32Operands());
     3034    RUN(testAddArgZeroImmZDef());
     3035    RUN(testAddLoadTwice());
     3036    RUN_TERNARY(testAddMulMulArgs, int64Operands(), int64Operands(), int64Operands());
     3037   
     3038    RUN(testAddArgDouble(M_PI));
     3039    RUN(testAddArgsDouble(M_PI, 1));
     3040    RUN(testAddArgsDouble(M_PI, -M_PI));
     3041    RUN(testAddArgImmDouble(M_PI, 1));
     3042    RUN(testAddArgImmDouble(M_PI, 0));
     3043    RUN(testAddArgImmDouble(M_PI, negativeZero()));
     3044    RUN(testAddArgImmDouble(0, 0));
     3045    RUN(testAddArgImmDouble(0, negativeZero()));
     3046    RUN(testAddArgImmDouble(negativeZero(), 0));
     3047    RUN(testAddArgImmDouble(negativeZero(), negativeZero()));
     3048    RUN(testAddImmArgDouble(M_PI, 1));
     3049    RUN(testAddImmArgDouble(M_PI, 0));
     3050    RUN(testAddImmArgDouble(M_PI, negativeZero()));
     3051    RUN(testAddImmArgDouble(0, 0));
     3052    RUN(testAddImmArgDouble(0, negativeZero()));
     3053    RUN(testAddImmArgDouble(negativeZero(), 0));
     3054    RUN(testAddImmArgDouble(negativeZero(), negativeZero()));
     3055    RUN(testAddImmsDouble(M_PI, 1));
     3056    RUN(testAddImmsDouble(M_PI, 0));
     3057    RUN(testAddImmsDouble(M_PI, negativeZero()));
     3058    RUN(testAddImmsDouble(0, 0));
     3059    RUN(testAddImmsDouble(0, negativeZero()));
     3060    RUN(testAddImmsDouble(negativeZero(), negativeZero()));
     3061    RUN_UNARY(testAddArgFloat, floatingPointOperands<float>());
     3062    RUN_BINARY(testAddArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3063    RUN_BINARY(testAddFPRArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3064    RUN_BINARY(testAddArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3065    RUN_BINARY(testAddImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3066    RUN_BINARY(testAddImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3067    RUN_UNARY(testAddArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
     3068    RUN_BINARY(testAddArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3069    RUN_BINARY(testAddArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3070   
     3071    RUN(testMulArg(5));
     3072    RUN(testMulAddArg(5));
     3073    RUN(testMulAddArg(85));
     3074    RUN(testMulArgStore(5));
     3075    RUN(testMulArgStore(85));
     3076    RUN(testMulArgs(1, 1));
     3077    RUN(testMulArgs(1, 2));
     3078    RUN(testMulArgs(3, 3));
     3079    RUN(testMulArgImm(1, 2));
     3080    RUN(testMulArgImm(1, 4));
     3081    RUN(testMulArgImm(1, 8));
     3082    RUN(testMulArgImm(1, 16));
     3083    RUN(testMulArgImm(1, 0x80000000llu));
     3084    RUN(testMulArgImm(1, 0x800000000000llu));
     3085    RUN(testMulArgImm(7, 2));
     3086    RUN(testMulArgImm(7, 4));
     3087    RUN(testMulArgImm(7, 8));
     3088    RUN(testMulArgImm(7, 16));
     3089    RUN(testMulArgImm(7, 0x80000000llu));
     3090    RUN(testMulArgImm(7, 0x800000000000llu));
     3091    RUN(testMulArgImm(-42, 2));
     3092    RUN(testMulArgImm(-42, 4));
     3093    RUN(testMulArgImm(-42, 8));
     3094    RUN(testMulArgImm(-42, 16));
     3095    RUN(testMulArgImm(-42, 0x80000000llu));
     3096    RUN(testMulArgImm(-42, 0x800000000000llu));
     3097    RUN(testMulArgImm(0, 2));
     3098    RUN(testMulArgImm(1, 0));
     3099    RUN(testMulArgImm(3, 3));
     3100    RUN(testMulArgImm(3, -1));
     3101    RUN(testMulArgImm(-3, -1));
     3102    RUN(testMulArgImm(0, -1));
     3103    RUN(testMulImmArg(1, 2));
     3104    RUN(testMulImmArg(0, 2));
     3105    RUN(testMulImmArg(1, 0));
     3106    RUN(testMulImmArg(3, 3));
     3107    RUN(testMulImm32SignExtend(1, 2));
     3108    RUN(testMulImm32SignExtend(0, 2));
     3109    RUN(testMulImm32SignExtend(1, 0));
     3110    RUN(testMulImm32SignExtend(3, 3));
     3111    RUN(testMulImm32SignExtend(0xFFFFFFFF, 0xFFFFFFFF));
     3112    RUN(testMulImm32SignExtend(0xFFFFFFFE, 0xFFFFFFFF));
     3113    RUN(testMulImm32SignExtend(0xFFFFFFFF, 0xFFFFFFFE));
     3114    RUN(testMulArgs32(1, 1));
     3115    RUN(testMulArgs32(1, 2));
     3116    RUN(testMulArgs32(0xFFFFFFFF, 0xFFFFFFFF));
     3117    RUN(testMulArgs32(0xFFFFFFFE, 0xFFFFFFFF));
     3118    RUN(testMulArgs32SignExtend(1, 1));
     3119    RUN(testMulArgs32SignExtend(1, 2));
     3120    RUN(testMulArgs32SignExtend(0xFFFFFFFF, 0xFFFFFFFF));
     3121    RUN(testMulArgs32SignExtend(0xFFFFFFFE, 0xFFFFFFFF));
     3122    RUN(testMulLoadTwice());
     3123    RUN(testMulAddArgsLeft());
     3124    RUN(testMulAddArgsRight());
     3125    RUN(testMulAddArgsLeft32());
     3126    RUN(testMulAddArgsRight32());
     3127    RUN(testMulSubArgsLeft());
     3128    RUN(testMulSubArgsRight());
     3129    RUN(testMulSubArgsLeft32());
     3130    RUN(testMulSubArgsRight32());
     3131    RUN(testMulNegArgs());
     3132    RUN(testMulNegArgs32());
     3133   
     3134    RUN_BINARY(testMulArgNegArg, int64Operands(), int64Operands())
     3135    RUN_BINARY(testMulNegArgArg, int64Operands(), int64Operands())
     3136    RUN_UNARY(testMulArgDouble, floatingPointOperands<double>());
     3137    RUN_BINARY(testMulArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3138    RUN_BINARY(testMulArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3139    RUN_BINARY(testMulImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3140    RUN_BINARY(testMulImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3141    RUN_UNARY(testMulArgFloat, floatingPointOperands<float>());
     3142    RUN_BINARY(testMulArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3143    RUN_BINARY(testMulArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3144    RUN_BINARY(testMulImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3145    RUN_BINARY(testMulImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3146    RUN_UNARY(testMulArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
     3147    RUN_BINARY(testMulArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3148    RUN_BINARY(testMulArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3149   
     3150    RUN(testDivArgDouble(M_PI));
     3151    RUN(testDivArgsDouble(M_PI, 1));
     3152    RUN(testDivArgsDouble(M_PI, -M_PI));
     3153    RUN(testDivArgImmDouble(M_PI, 1));
     3154    RUN(testDivArgImmDouble(M_PI, 0));
     3155    RUN(testDivArgImmDouble(M_PI, negativeZero()));
     3156    RUN(testDivArgImmDouble(0, 0));
     3157    RUN(testDivArgImmDouble(0, negativeZero()));
     3158    RUN(testDivArgImmDouble(negativeZero(), 0));
     3159    RUN(testDivArgImmDouble(negativeZero(), negativeZero()));
     3160    RUN(testDivImmArgDouble(M_PI, 1));
     3161    RUN(testDivImmArgDouble(M_PI, 0));
     3162    RUN(testDivImmArgDouble(M_PI, negativeZero()));
     3163    RUN(testDivImmArgDouble(0, 0));
     3164    RUN(testDivImmArgDouble(0, negativeZero()));
     3165    RUN(testDivImmArgDouble(negativeZero(), 0));
     3166    RUN(testDivImmArgDouble(negativeZero(), negativeZero()));
     3167    RUN(testDivImmsDouble(M_PI, 1));
     3168    RUN(testDivImmsDouble(M_PI, 0));
     3169    RUN(testDivImmsDouble(M_PI, negativeZero()));
     3170    RUN(testDivImmsDouble(0, 0));
     3171    RUN(testDivImmsDouble(0, negativeZero()));
     3172    RUN(testDivImmsDouble(negativeZero(), negativeZero()));
     3173    RUN_UNARY(testDivArgFloat, floatingPointOperands<float>());
     3174    RUN_BINARY(testDivArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3175    RUN_BINARY(testDivArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3176    RUN_BINARY(testDivImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3177    RUN_BINARY(testDivImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3178    RUN_UNARY(testDivArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
     3179    RUN_BINARY(testDivArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3180    RUN_BINARY(testDivArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3181   
     3182    RUN_BINARY(testUDivArgsInt32, int32Operands(), int32Operands());
     3183    RUN_BINARY(testUDivArgsInt64, int64Operands(), int64Operands());
     3184   
     3185    RUN_UNARY(testModArgDouble, floatingPointOperands<double>());
     3186    RUN_BINARY(testModArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3187    RUN_BINARY(testModArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3188    RUN_BINARY(testModImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3189    RUN_BINARY(testModImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3190    RUN_UNARY(testModArgFloat, floatingPointOperands<float>());
     3191    RUN_BINARY(testModArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3192    RUN_BINARY(testModArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3193    RUN_BINARY(testModImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3194    RUN_BINARY(testModImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3195   
     3196    RUN_BINARY(testUModArgsInt32, int32Operands(), int32Operands());
     3197    RUN_BINARY(testUModArgsInt64, int64Operands(), int64Operands());
     3198   
     3199    RUN(testSubArg(24));
     3200    RUN(testSubArgs(1, 1));
     3201    RUN(testSubArgs(1, 2));
     3202    RUN(testSubArgs(13, -42));
     3203    RUN(testSubArgs(-13, 42));
     3204    RUN(testSubArgImm(1, 1));
     3205    RUN(testSubArgImm(1, 2));
     3206    RUN(testSubArgImm(13, -42));
     3207    RUN(testSubArgImm(-13, 42));
     3208    RUN(testSubArgImm(42, 0));
     3209    RUN(testSubImmArg(1, 1));
     3210    RUN(testSubImmArg(1, 2));
     3211    RUN(testSubImmArg(13, -42));
     3212    RUN(testSubImmArg(-13, 42));
     3213    RUN_BINARY(testSubArgMem, int64Operands(), int64Operands());
     3214    RUN_BINARY(testSubMemArg, int64Operands(), int64Operands());
     3215    RUN_BINARY(testSubImmMem, int32Operands(), int32Operands());
     3216    RUN_BINARY(testSubMemImm, int32Operands(), int32Operands());
     3217    RUN_BINARY(testSubNeg, int32Operands(), int32Operands());
     3218    RUN_BINARY(testNegSub, int32Operands(), int32Operands());
     3219    RUN_UNARY(testNegValueSubOne, int32Operands());
     3220    RUN_BINARY(testNegMulArgImm, int64Operands(), int64Operands());
     3221    RUN_TERNARY(testSubMulMulArgs, int64Operands(), int64Operands(), int64Operands());
     3222   
     3223    RUN_TERNARY(testSubSub, int32Operands(), int32Operands(), int32Operands());
     3224    RUN_TERNARY(testSubSub2, int32Operands(), int32Operands(), int32Operands());
     3225    RUN_TERNARY(testSubAdd, int32Operands(), int32Operands(), int32Operands());
     3226    RUN_BINARY(testSubFirstNeg, int32Operands(), int32Operands());
     3227   
     3228    RUN(testSubArgs32(1, 1));
     3229    RUN(testSubArgs32(1, 2));
     3230    RUN(testSubArgs32(13, -42));
     3231    RUN(testSubArgs32(-13, 42));
     3232    RUN(testSubArgImm32(1, 1));
     3233    RUN(testSubArgImm32(1, 2));
     3234    RUN(testSubArgImm32(13, -42));
     3235    RUN(testSubArgImm32(-13, 42));
     3236    RUN(testSubImmArg32(1, 1));
     3237    RUN(testSubImmArg32(1, 2));
     3238    RUN(testSubImmArg32(13, -42));
     3239    RUN(testSubImmArg32(-13, 42));
     3240    RUN_BINARY(testSubArgMem32, int32Operands(), int32Operands());
     3241    RUN_BINARY(testSubMemArg32, int32Operands(), int32Operands());
     3242    RUN_BINARY(testSubImmMem32, int32Operands(), int32Operands());
     3243    RUN_BINARY(testSubMemImm32, int32Operands(), int32Operands());
     3244    RUN_UNARY(testNegValueSubOne32, int64Operands());
     3245   
     3246    RUN_UNARY(testSubArgDouble, floatingPointOperands<double>());
     3247    RUN_BINARY(testSubArgsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3248    RUN_BINARY(testSubArgImmDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3249    RUN_BINARY(testSubImmArgDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3250    RUN_BINARY(testSubImmsDouble, floatingPointOperands<double>(), floatingPointOperands<double>());
     3251    RUN_UNARY(testSubArgFloat, floatingPointOperands<float>());
     3252    RUN_BINARY(testSubArgsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3253    RUN_BINARY(testSubArgImmFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3254    RUN_BINARY(testSubImmArgFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3255    RUN_BINARY(testSubImmsFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3256    RUN_UNARY(testSubArgFloatWithUselessDoubleConversion, floatingPointOperands<float>());
     3257    RUN_BINARY(testSubArgsFloatWithUselessDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3258    RUN_BINARY(testSubArgsFloatWithEffectfulDoubleConversion, floatingPointOperands<float>(), floatingPointOperands<float>());
     3259}
     3260
     3261void addCallTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     3262{
     3263    RUN(testCallSimple(1, 2));
     3264    RUN(testCallRare(1, 2));
     3265    RUN(testCallRareLive(1, 2, 3));
     3266    RUN(testCallSimplePure(1, 2));
     3267    RUN(testCallFunctionWithHellaArguments());
     3268    RUN(testCallFunctionWithHellaArguments2());
     3269    RUN(testCallFunctionWithHellaArguments3());
     3270   
     3271    RUN(testReturnDouble(0.0));
     3272    RUN(testReturnDouble(negativeZero()));
     3273    RUN(testReturnDouble(42.5));
     3274    RUN_UNARY(testReturnFloat, floatingPointOperands<float>());
     3275   
     3276    RUN(testCallSimpleDouble(1, 2));
     3277    RUN(testCallFunctionWithHellaDoubleArguments());
     3278    RUN_BINARY(testCallSimpleFloat, floatingPointOperands<float>(), floatingPointOperands<float>());
     3279    RUN(testCallFunctionWithHellaFloatArguments());
     3280}
     3281
     3282void addShrTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     3283{
     3284    RUN(testSShrArgs(1, 0));
     3285    RUN(testSShrArgs(1, 1));
     3286    RUN(testSShrArgs(1, 62));
     3287    RUN(testSShrArgs(0xffffffffffffffff, 0));
     3288    RUN(testSShrArgs(0xffffffffffffffff, 1));
     3289    RUN(testSShrArgs(0xffffffffffffffff, 63));
     3290    RUN(testSShrImms(1, 0));
     3291    RUN(testSShrImms(1, 1));
     3292    RUN(testSShrImms(1, 62));
     3293    RUN(testSShrImms(1, 65));
     3294    RUN(testSShrImms(0xffffffffffffffff, 0));
     3295    RUN(testSShrImms(0xffffffffffffffff, 1));
     3296    RUN(testSShrImms(0xffffffffffffffff, 63));
     3297    RUN(testSShrArgImm(1, 0));
     3298    RUN(testSShrArgImm(1, 1));
     3299    RUN(testSShrArgImm(1, 62));
     3300    RUN(testSShrArgImm(1, 65));
     3301    RUN(testSShrArgImm(0xffffffffffffffff, 0));
     3302    RUN(testSShrArgImm(0xffffffffffffffff, 1));
     3303    RUN(testSShrArgImm(0xffffffffffffffff, 63));
     3304    RUN(testSShrArg32(32));
     3305    RUN(testSShrArgs32(1, 0));
     3306    RUN(testSShrArgs32(1, 1));
     3307    RUN(testSShrArgs32(1, 62));
     3308    RUN(testSShrArgs32(1, 33));
     3309    RUN(testSShrArgs32(0xffffffff, 0));
     3310    RUN(testSShrArgs32(0xffffffff, 1));
     3311    RUN(testSShrArgs32(0xffffffff, 63));
     3312    RUN(testSShrImms32(1, 0));
     3313    RUN(testSShrImms32(1, 1));
     3314    RUN(testSShrImms32(1, 62));
     3315    RUN(testSShrImms32(1, 33));
     3316    RUN(testSShrImms32(0xffffffff, 0));
     3317    RUN(testSShrImms32(0xffffffff, 1));
     3318    RUN(testSShrImms32(0xffffffff, 63));
     3319    RUN(testSShrArgImm32(1, 0));
     3320    RUN(testSShrArgImm32(1, 1));
     3321    RUN(testSShrArgImm32(1, 62));
     3322    RUN(testSShrArgImm32(0xffffffff, 0));
     3323    RUN(testSShrArgImm32(0xffffffff, 1));
     3324    RUN(testSShrArgImm32(0xffffffff, 63));
     3325   
     3326    RUN(testZShrArgs(1, 0));
     3327    RUN(testZShrArgs(1, 1));
     3328    RUN(testZShrArgs(1, 62));
     3329    RUN(testZShrArgs(0xffffffffffffffff, 0));
     3330    RUN(testZShrArgs(0xffffffffffffffff, 1));
     3331    RUN(testZShrArgs(0xffffffffffffffff, 63));
     3332    RUN(testZShrImms(1, 0));
     3333    RUN(testZShrImms(1, 1));
     3334    RUN(testZShrImms(1, 62));
     3335    RUN(testZShrImms(1, 65));
     3336    RUN(testZShrImms(0xffffffffffffffff, 0));
     3337    RUN(testZShrImms(0xffffffffffffffff, 1));
     3338    RUN(testZShrImms(0xffffffffffffffff, 63));
     3339    RUN(testZShrArgImm(1, 0));
     3340    RUN(testZShrArgImm(1, 1));
     3341    RUN(testZShrArgImm(1, 62));
     3342    RUN(testZShrArgImm(1, 65));
     3343    RUN(testZShrArgImm(0xffffffffffffffff, 0));
     3344    RUN(testZShrArgImm(0xffffffffffffffff, 1));
     3345    RUN(testZShrArgImm(0xffffffffffffffff, 63));
     3346    RUN(testZShrArg32(32));
     3347    RUN(testZShrArgs32(1, 0));
     3348    RUN(testZShrArgs32(1, 1));
     3349    RUN(testZShrArgs32(1, 62));
     3350    RUN(testZShrArgs32(1, 33));
     3351    RUN(testZShrArgs32(0xffffffff, 0));
     3352    RUN(testZShrArgs32(0xffffffff, 1));
     3353    RUN(testZShrArgs32(0xffffffff, 63));
     3354    RUN(testZShrImms32(1, 0));
     3355    RUN(testZShrImms32(1, 1));
     3356    RUN(testZShrImms32(1, 62));
     3357    RUN(testZShrImms32(1, 33));
     3358    RUN(testZShrImms32(0xffffffff, 0));
     3359    RUN(testZShrImms32(0xffffffff, 1));
     3360    RUN(testZShrImms32(0xffffffff, 63));
     3361    RUN(testZShrArgImm32(1, 0));
     3362    RUN(testZShrArgImm32(1, 1));
     3363    RUN(testZShrArgImm32(1, 62));
     3364    RUN(testZShrArgImm32(0xffffffff, 0));
     3365    RUN(testZShrArgImm32(0xffffffff, 1));
     3366    RUN(testZShrArgImm32(0xffffffff, 63));
     3367}
     3368
    30013369#endif // ENABLE(B3_JIT)

  • trunk/Source/JavaScriptCore/b3/testb3_4.cpp

    r248087 r248098  
    29132913}
    29142914
     2915void addSExtTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     2916{
     2917    RUN(testSExt8(0));
     2918    RUN(testSExt8(1));
     2919    RUN(testSExt8(42));
     2920    RUN(testSExt8(-1));
     2921    RUN(testSExt8(0xff));
     2922    RUN(testSExt8(0x100));
     2923    RUN(testSExt8Fold(0));
     2924    RUN(testSExt8Fold(1));
     2925    RUN(testSExt8Fold(42));
     2926    RUN(testSExt8Fold(-1));
     2927    RUN(testSExt8Fold(0xff));
     2928    RUN(testSExt8Fold(0x100));
     2929    RUN(testSExt8SExt8(0));
     2930    RUN(testSExt8SExt8(1));
     2931    RUN(testSExt8SExt8(42));
     2932    RUN(testSExt8SExt8(-1));
     2933    RUN(testSExt8SExt8(0xff));
     2934    RUN(testSExt8SExt8(0x100));
     2935    RUN(testSExt8SExt16(0));
     2936    RUN(testSExt8SExt16(1));
     2937    RUN(testSExt8SExt16(42));
     2938    RUN(testSExt8SExt16(-1));
     2939    RUN(testSExt8SExt16(0xff));
     2940    RUN(testSExt8SExt16(0x100));
     2941    RUN(testSExt8SExt16(0xffff));
     2942    RUN(testSExt8SExt16(0x10000));
     2943    RUN(testSExt8BitAnd(0, 0));
     2944    RUN(testSExt8BitAnd(1, 0));
     2945    RUN(testSExt8BitAnd(42, 0));
     2946    RUN(testSExt8BitAnd(-1, 0));
     2947    RUN(testSExt8BitAnd(0xff, 0));
     2948    RUN(testSExt8BitAnd(0x100, 0));
     2949    RUN(testSExt8BitAnd(0xffff, 0));
     2950    RUN(testSExt8BitAnd(0x10000, 0));
     2951    RUN(testSExt8BitAnd(0, 0xf));
     2952    RUN(testSExt8BitAnd(1, 0xf));
     2953    RUN(testSExt8BitAnd(42, 0xf));
     2954    RUN(testSExt8BitAnd(-1, 0xf));
     2955    RUN(testSExt8BitAnd(0xff, 0xf));
     2956    RUN(testSExt8BitAnd(0x100, 0xf));
     2957    RUN(testSExt8BitAnd(0xffff, 0xf));
     2958    RUN(testSExt8BitAnd(0x10000, 0xf));
     2959    RUN(testSExt8BitAnd(0, 0xff));
     2960    RUN(testSExt8BitAnd(1, 0xff));
     2961    RUN(testSExt8BitAnd(42, 0xff));
     2962    RUN(testSExt8BitAnd(-1, 0xff));
     2963    RUN(testSExt8BitAnd(0xff, 0xff));
     2964    RUN(testSExt8BitAnd(0x100, 0xff));
     2965    RUN(testSExt8BitAnd(0xffff, 0xff));
     2966    RUN(testSExt8BitAnd(0x10000, 0xff));
     2967    RUN(testSExt8BitAnd(0, 0x80));
     2968    RUN(testSExt8BitAnd(1, 0x80));
     2969    RUN(testSExt8BitAnd(42, 0x80));
     2970    RUN(testSExt8BitAnd(-1, 0x80));
     2971    RUN(testSExt8BitAnd(0xff, 0x80));
     2972    RUN(testSExt8BitAnd(0x100, 0x80));
     2973    RUN(testSExt8BitAnd(0xffff, 0x80));
     2974    RUN(testSExt8BitAnd(0x10000, 0x80));
     2975    RUN(testBitAndSExt8(0, 0xf));
     2976    RUN(testBitAndSExt8(1, 0xf));
     2977    RUN(testBitAndSExt8(42, 0xf));
     2978    RUN(testBitAndSExt8(-1, 0xf));
     2979    RUN(testBitAndSExt8(0xff, 0xf));
     2980    RUN(testBitAndSExt8(0x100, 0xf));
     2981    RUN(testBitAndSExt8(0xffff, 0xf));
     2982    RUN(testBitAndSExt8(0x10000, 0xf));
     2983    RUN(testBitAndSExt8(0, 0xff));
     2984    RUN(testBitAndSExt8(1, 0xff));
     2985    RUN(testBitAndSExt8(42, 0xff));
     2986    RUN(testBitAndSExt8(-1, 0xff));
     2987    RUN(testBitAndSExt8(0xff, 0xff));
     2988    RUN(testBitAndSExt8(0x100, 0xff));
     2989    RUN(testBitAndSExt8(0xffff, 0xff));
     2990    RUN(testBitAndSExt8(0x10000, 0xff));
     2991    RUN(testBitAndSExt8(0, 0xfff));
     2992    RUN(testBitAndSExt8(1, 0xfff));
     2993    RUN(testBitAndSExt8(42, 0xfff));
     2994    RUN(testBitAndSExt8(-1, 0xfff));
     2995    RUN(testBitAndSExt8(0xff, 0xfff));
     2996    RUN(testBitAndSExt8(0x100, 0xfff));
     2997    RUN(testBitAndSExt8(0xffff, 0xfff));
     2998    RUN(testBitAndSExt8(0x10000, 0xfff));
     2999   
     3000    RUN(testSExt16(0));
     3001    RUN(testSExt16(1));
     3002    RUN(testSExt16(42));
     3003    RUN(testSExt16(-1));
     3004    RUN(testSExt16(0xffff));
     3005    RUN(testSExt16(0x10000));
     3006    RUN(testSExt16Fold(0));
     3007    RUN(testSExt16Fold(1));
     3008    RUN(testSExt16Fold(42));
     3009    RUN(testSExt16Fold(-1));
     3010    RUN(testSExt16Fold(0xffff));
     3011    RUN(testSExt16Fold(0x10000));
     3012    RUN(testSExt16SExt8(0));
     3013    RUN(testSExt16SExt8(1));
     3014    RUN(testSExt16SExt8(42));
     3015    RUN(testSExt16SExt8(-1));
     3016    RUN(testSExt16SExt8(0xffff));
     3017    RUN(testSExt16SExt8(0x10000));
     3018    RUN(testSExt16SExt16(0));
     3019    RUN(testSExt16SExt16(1));
     3020    RUN(testSExt16SExt16(42));
     3021    RUN(testSExt16SExt16(-1));
     3022    RUN(testSExt16SExt16(0xffff));
     3023    RUN(testSExt16SExt16(0x10000));
     3024    RUN(testSExt16SExt16(0xffffff));
     3025    RUN(testSExt16SExt16(0x1000000));
     3026    RUN(testSExt16BitAnd(0, 0));
     3027    RUN(testSExt16BitAnd(1, 0));
     3028    RUN(testSExt16BitAnd(42, 0));
     3029    RUN(testSExt16BitAnd(-1, 0));
     3030    RUN(testSExt16BitAnd(0xffff, 0));
     3031    RUN(testSExt16BitAnd(0x10000, 0));
     3032    RUN(testSExt16BitAnd(0xffffff, 0));
     3033    RUN(testSExt16BitAnd(0x1000000, 0));
     3034    RUN(testSExt16BitAnd(0, 0xf));
     3035    RUN(testSExt16BitAnd(1, 0xf));
     3036    RUN(testSExt16BitAnd(42, 0xf));
     3037    RUN(testSExt16BitAnd(-1, 0xf));
     3038    RUN(testSExt16BitAnd(0xffff, 0xf));
     3039    RUN(testSExt16BitAnd(0x10000, 0xf));
     3040    RUN(testSExt16BitAnd(0xffffff, 0xf));
     3041    RUN(testSExt16BitAnd(0x1000000, 0xf));
     3042    RUN(testSExt16BitAnd(0, 0xffff));
     3043    RUN(testSExt16BitAnd(1, 0xffff));
     3044    RUN(testSExt16BitAnd(42, 0xffff));
     3045    RUN(testSExt16BitAnd(-1, 0xffff));
     3046    RUN(testSExt16BitAnd(0xffff, 0xffff));
     3047    RUN(testSExt16BitAnd(0x10000, 0xffff));
     3048    RUN(testSExt16BitAnd(0xffffff, 0xffff));
     3049    RUN(testSExt16BitAnd(0x1000000, 0xffff));
     3050    RUN(testSExt16BitAnd(0, 0x8000));
     3051    RUN(testSExt16BitAnd(1, 0x8000));
     3052    RUN(testSExt16BitAnd(42, 0x8000));
     3053    RUN(testSExt16BitAnd(-1, 0x8000));
     3054    RUN(testSExt16BitAnd(0xffff, 0x8000));
     3055    RUN(testSExt16BitAnd(0x10000, 0x8000));
     3056    RUN(testSExt16BitAnd(0xffffff, 0x8000));
     3057    RUN(testSExt16BitAnd(0x1000000, 0x8000));
     3058    RUN(testBitAndSExt16(0, 0xf));
     3059    RUN(testBitAndSExt16(1, 0xf));
     3060    RUN(testBitAndSExt16(42, 0xf));
     3061    RUN(testBitAndSExt16(-1, 0xf));
     3062    RUN(testBitAndSExt16(0xffff, 0xf));
     3063    RUN(testBitAndSExt16(0x10000, 0xf));
     3064    RUN(testBitAndSExt16(0xffffff, 0xf));
     3065    RUN(testBitAndSExt16(0x1000000, 0xf));
     3066    RUN(testBitAndSExt16(0, 0xffff));
     3067    RUN(testBitAndSExt16(1, 0xffff));
     3068    RUN(testBitAndSExt16(42, 0xffff));
     3069    RUN(testBitAndSExt16(-1, 0xffff));
     3070    RUN(testBitAndSExt16(0xffff, 0xffff));
     3071    RUN(testBitAndSExt16(0x10000, 0xffff));
     3072    RUN(testBitAndSExt16(0xffffff, 0xffff));
     3073    RUN(testBitAndSExt16(0x1000000, 0xffff));
     3074    RUN(testBitAndSExt16(0, 0xfffff));
     3075    RUN(testBitAndSExt16(1, 0xfffff));
     3076    RUN(testBitAndSExt16(42, 0xfffff));
     3077    RUN(testBitAndSExt16(-1, 0xfffff));
     3078    RUN(testBitAndSExt16(0xffff, 0xfffff));
     3079    RUN(testBitAndSExt16(0x10000, 0xfffff));
     3080    RUN(testBitAndSExt16(0xffffff, 0xfffff));
     3081    RUN(testBitAndSExt16(0x1000000, 0xfffff));
     3082   
     3083    RUN(testSExt32BitAnd(0, 0));
     3084    RUN(testSExt32BitAnd(1, 0));
     3085    RUN(testSExt32BitAnd(42, 0));
     3086    RUN(testSExt32BitAnd(-1, 0));
     3087    RUN(testSExt32BitAnd(0x80000000, 0));
     3088    RUN(testSExt32BitAnd(0, 0xf));
     3089    RUN(testSExt32BitAnd(1, 0xf));
     3090    RUN(testSExt32BitAnd(42, 0xf));
     3091    RUN(testSExt32BitAnd(-1, 0xf));
     3092    RUN(testSExt32BitAnd(0x80000000, 0xf));
     3093    RUN(testSExt32BitAnd(0, 0x80000000));
     3094    RUN(testSExt32BitAnd(1, 0x80000000));
     3095    RUN(testSExt32BitAnd(42, 0x80000000));
     3096    RUN(testSExt32BitAnd(-1, 0x80000000));
     3097    RUN(testSExt32BitAnd(0x80000000, 0x80000000));
     3098    RUN(testBitAndSExt32(0, 0xf));
     3099    RUN(testBitAndSExt32(1, 0xf));
     3100    RUN(testBitAndSExt32(42, 0xf));
     3101    RUN(testBitAndSExt32(-1, 0xf));
     3102    RUN(testBitAndSExt32(0xffff, 0xf));
     3103    RUN(testBitAndSExt32(0x10000, 0xf));
     3104    RUN(testBitAndSExt32(0xffffff, 0xf));
     3105    RUN(testBitAndSExt32(0x1000000, 0xf));
     3106    RUN(testBitAndSExt32(0, 0xffff00000000llu));
     3107    RUN(testBitAndSExt32(1, 0xffff00000000llu));
     3108    RUN(testBitAndSExt32(42, 0xffff00000000llu));
     3109    RUN(testBitAndSExt32(-1, 0xffff00000000llu));
     3110    RUN(testBitAndSExt32(0x80000000, 0xffff00000000llu));
     3111}
     3112
    29153113#endif // ENABLE(B3_JIT)

  • trunk/Source/JavaScriptCore/b3/testb3_6.cpp

    r248087 r248098  
    11901190}
    11911191
    1192 void testSShrShl32(int32_t value, int32_t sshrAmount, int32_t shlAmount)
     1192static void testSShrShl32(int32_t value, int32_t sshrAmount, int32_t shlAmount)
    11931193{
    11941194    Procedure proc;
    … …  
    12121212}
    12131213
    1214 void testSShrShl64(int64_t value, int32_t sshrAmount, int32_t shlAmount)
     1214static void testSShrShl64(int64_t value, int32_t sshrAmount, int32_t shlAmount)
    12151215{
    12161216    Procedure proc;
    … …  
    28602860}
    28612861
     2862void addSShrShTests(const char* filter, Deque<RefPtr<SharedTask<void()>>>& tasks)
     2863{
     2864    RUN(testSShrShl32(42, 24, 24));
     2865    RUN(testSShrShl32(-42, 24, 24));
     2866    RUN(testSShrShl32(4200, 24, 24));
     2867    RUN(testSShrShl32(-4200, 24, 24));
     2868    RUN(testSShrShl32(4200000, 24, 24));
     2869    RUN(testSShrShl32(-4200000, 24, 24));
     2870   
     2871    RUN(testSShrShl32(42, 16, 16));
     2872    RUN(testSShrShl32(-42, 16, 16));
     2873    RUN(testSShrShl32(4200, 16, 16));
     2874    RUN(testSShrShl32(-4200, 16, 16));
     2875    RUN(testSShrShl32(4200000, 16, 16));
     2876    RUN(testSShrShl32(-4200000, 16, 16));
     2877   
     2878    RUN(testSShrShl32(42, 8, 8));
     2879    RUN(testSShrShl32(-42, 8, 8));
     2880    RUN(testSShrShl32(4200, 8, 8));
     2881    RUN(testSShrShl32(-4200, 8, 8));
     2882    RUN(testSShrShl32(4200000, 8, 8));
     2883    RUN(testSShrShl32(-4200000, 8, 8));
     2884    RUN(testSShrShl32(420000000, 8, 8));
     2885    RUN(testSShrShl32(-420000000, 8, 8));
     2886   
     2887    RUN(testSShrShl64(42, 56, 56));
     2888    RUN(testSShrShl64(-42, 56, 56));
     2889    RUN(testSShrShl64(4200, 56, 56));
     2890    RUN(testSShrShl64(-4200, 56, 56));
     2891    RUN(testSShrShl64(4200000, 56, 56));
     2892    RUN(testSShrShl64(-4200000, 56, 56));
     2893    RUN(testSShrShl64(420000000, 56, 56));
     2894    RUN(testSShrShl64(-420000000, 56, 56));
     2895    RUN(testSShrShl64(42000000000, 56, 56));
     2896    RUN(testSShrShl64(-42000000000, 56, 56));
     2897   
     2898    RUN(testSShrShl64(42, 48, 48));
     2899    RUN(testSShrShl64(-42, 48, 48));
     2900    RUN(testSShrShl64(4200, 48, 48));
     2901    RUN(testSShrShl64(-4200, 48, 48));
     2902    RUN(testSShrShl64(4200000, 48, 48));
     2903    RUN(testSShrShl64(-4200000, 48, 48));
     2904    RUN(testSShrShl64(420000000, 48, 48));
     2905    RUN(testSShrShl64(-420000000, 48, 48));
     2906    RUN(testSShrShl64(42000000000, 48, 48));
     2907    RUN(testSShrShl64(-42000000000, 48, 48));
     2908   
     2909    RUN(testSShrShl64(42, 32, 32));
     2910    RUN(testSShrShl64(-42, 32, 32));
     2911    RUN(testSShrShl64(4200, 32, 32));
     2912    RUN(testSShrShl64(-4200, 32, 32));
     2913    RUN(testSShrShl64(4200000, 32, 32));
     2914    RUN(testSShrShl64(-4200000, 32, 32));
     2915    RUN(testSShrShl64(420000000, 32, 32));
     2916    RUN(testSShrShl64(-420000000, 32, 32));
     2917    RUN(testSShrShl64(42000000000, 32, 32));
     2918    RUN(testSShrShl64(-42000000000, 32, 32));
     2919   
     2920    RUN(testSShrShl64(42, 24, 24));
     2921    RUN(testSShrShl64(-42, 24, 24));
     2922    RUN(testSShrShl64(4200, 24, 24));
     2923    RUN(testSShrShl64(-4200, 24, 24));
     2924    RUN(testSShrShl64(4200000, 24, 24));
     2925    RUN(testSShrShl64(-4200000, 24, 24));
     2926    RUN(testSShrShl64(420000000, 24, 24));
     2927    RUN(testSShrShl64(-420000000, 24, 24));
     2928    RUN(testSShrShl64(42000000000, 24, 24));
     2929    RUN(testSShrShl64(-42000000000, 24, 24));
     2930   
     2931    RUN(testSShrShl64(42, 16, 16));
     2932    RUN(testSShrShl64(-42, 16, 16));
     2933    RUN(testSShrShl64(4200, 16, 16));
     2934    RUN(testSShrShl64(-4200, 16, 16));
     2935    RUN(testSShrShl64(4200000, 16, 16));
     2936    RUN(testSShrShl64(-4200000, 16, 16));
     2937    RUN(testSShrShl64(420000000, 16, 16));
     2938    RUN(testSShrShl64(-420000000, 16, 16));
     2939    RUN(testSShrShl64(42000000000, 16, 16));
     2940    RUN(testSShrShl64(-42000000000, 16, 16));
     2941   
     2942    RUN(testSShrShl64(42, 8, 8));
     2943    RUN(testSShrShl64(-42, 8, 8));
     2944    RUN(testSShrShl64(4200, 8, 8));
     2945    RUN(testSShrShl64(-4200, 8, 8));
     2946    RUN(testSShrShl64(4200000, 8, 8));
     2947    RUN(testSShrShl64(-4200000, 8, 8));
     2948    RUN(testSShrShl64(420000000, 8, 8));
     2949    RUN(testSShrShl64(-420000000, 8, 8));
     2950    RUN(testSShrShl64(42000000000, 8, 8));
     2951    RUN(testSShrShl64(-42000000000, 8, 8));
     2952}
     2953
    28622954#endif // ENABLE(B3_JIT)
Note: See TracChangeset for help on using the changeset viewer.