Lines Matching full:masm
97 #define __ masm->
100 static void EntryCode(MacroAssembler* masm) {
109 static void ExitCode(MacroAssembler* masm) {
146 static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) {
167 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
168 EntryCode(masm);
171 TestMoveSmi(masm, &exit, 1, Smi::FromInt(0));
172 TestMoveSmi(masm, &exit, 2, Smi::FromInt(127));
173 TestMoveSmi(masm, &exit, 3, Smi::FromInt(128));
174 TestMoveSmi(masm, &exit, 4, Smi::FromInt(255));
175 TestMoveSmi(masm, &exit, 5, Smi::FromInt(256));
176 TestMoveSmi(masm, &exit, 6, Smi::FromInt(Smi::kMaxValue));
177 TestMoveSmi(masm, &exit, 7, Smi::FromInt(-1));
178 TestMoveSmi(masm, &exit, 8, Smi::FromInt(-128));
179 TestMoveSmi(masm, &exit, 9, Smi::FromInt(-129));
180 TestMoveSmi(masm, &exit, 10, Smi::FromInt(-256));
181 TestMoveSmi(masm, &exit, 11, Smi::FromInt(-257));
182 TestMoveSmi(masm, &exit, 12, Smi::FromInt(Smi::kMinValue));
186 ExitCode(masm);
190 masm->GetCode(&desc);
197 void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) {
256 MacroAssembler* masm = &assembler;
257 EntryCode(masm);
260 TestSmiCompare(masm, &exit, 0x10, 0, 0);
261 TestSmiCompare(masm, &exit, 0x20, 0, 1);
262 TestSmiCompare(masm, &exit, 0x30, 1, 0);
263 TestSmiCompare(masm, &exit, 0x40, 1, 1);
264 TestSmiCompare(masm, &exit, 0x50, 0, -1);
265 TestSmiCompare(masm, &exit, 0x60, -1, 0);
266 TestSmiCompare(masm, &exit, 0x70, -1, -1);
267 TestSmiCompare(masm, &exit, 0x80, 0, Smi::kMinValue);
268 TestSmiCompare(masm, &exit, 0x90, Smi::kMinValue, 0);
269 TestSmiCompare(masm, &exit, 0xA0, 0, Smi::kMaxValue);
270 TestSmiCompare(masm, &exit, 0xB0, Smi::kMaxValue, 0);
271 TestSmiCompare(masm, &exit, 0xC0, -1, Smi::kMinValue);
272 TestSmiCompare(masm, &exit, 0xD0, Smi::kMinValue, -1);
273 TestSmiCompare(masm, &exit, 0xE0, -1, Smi::kMaxValue);
274 TestSmiCompare(masm, &exit, 0xF0, Smi::kMaxValue, -1);
275 TestSmiCompare(masm, &exit, 0x100, Smi::kMinValue, Smi::kMinValue);
276 TestSmiCompare(masm, &exit, 0x110, Smi::kMinValue, Smi::kMaxValue);
277 TestSmiCompare(masm, &exit, 0x120, Smi::kMaxValue, Smi::kMinValue);
278 TestSmiCompare(masm, &exit, 0x130, Smi::kMaxValue, Smi::kMaxValue);
282 ExitCode(masm);
286 masm->GetCode(&desc);
306 MacroAssembler* masm = &assembler;
307 EntryCode(masm);
385 ExitCode(masm);
389 masm->GetCode(&desc);
396 void TestI64PlusConstantToSmi(MacroAssembler* masm,
434 MacroAssembler* masm = &assembler;
435 EntryCode(masm);
440 TestI64PlusConstantToSmi(masm, &exit, 0x10, 0, 0);
441 TestI64PlusConstantToSmi(masm, &exit, 0x20, 0, 1);
442 TestI64PlusConstantToSmi(masm, &exit, 0x30, 1, 0);
443 TestI64PlusConstantToSmi(masm, &exit, 0x40, Smi::kMaxValue - 5, 5);
444 TestI64PlusConstantToSmi(masm, &exit, 0x50, Smi::kMinValue + 5, 5);
445 TestI64PlusConstantToSmi(masm, &exit, 0x60, twice_max, -Smi::kMaxValue);
446 TestI64PlusConstantToSmi(masm, &exit, 0x70, -twice_max, Smi::kMaxValue);
447 TestI64PlusConstantToSmi(masm, &exit, 0x80, 0, Smi::kMinValue);
448 TestI64PlusConstantToSmi(masm, &exit, 0x90, 0, Smi::kMaxValue);
449 TestI64PlusConstantToSmi(masm, &exit, 0xA0, Smi::kMinValue, 0);
450 TestI64PlusConstantToSmi(masm, &exit, 0xB0, Smi::kMaxValue, 0);
451 TestI64PlusConstantToSmi(masm, &exit, 0xC0, twice_max, Smi::kMinValue);
455 ExitCode(masm);
459 masm->GetCode(&desc);
478 MacroAssembler* masm = &assembler;
479 EntryCode(masm);
489 cond = masm->CheckSmi(rcx);
494 cond = masm->CheckSmi(rcx);
500 cond = masm->CheckSmi(rcx);
505 cond = masm->CheckSmi(rcx);
511 cond = masm->CheckSmi(rcx);
516 cond = masm->CheckSmi(rcx);
522 cond = masm->CheckSmi(rcx);
527 cond = masm->CheckSmi(rcx);
535 cond = masm->CheckNonNegativeSmi(rcx);
540 cond = masm->CheckNonNegativeSmi(rcx); // "zero" non-smi.
546 cond = masm->CheckNonNegativeSmi(rcx); // Negative smis are not positive.
552 cond = masm->CheckNonNegativeSmi(rcx); // Most negative smi is not positive.
557 cond = masm->CheckNonNegativeSmi(rcx); // "Negative" non-smi.
563 cond = masm->CheckNonNegativeSmi(rcx); // Most positive smi is positive.
568 cond = masm->CheckNonNegativeSmi(rcx); // "Positive" non-smi.
576 cond = masm->CheckIsMinSmi(rcx);
582 cond = masm->CheckIsMinSmi(rcx);
588 cond = masm->CheckIsMinSmi(rcx);
594 cond = masm->CheckIsMinSmi(rcx);
604 cond = masm->CheckBothSmi(rcx, rdx);
609 cond = masm->CheckBothSmi(rcx, rdx);
614 cond = masm->CheckBothSmi(rcx, rdx);
619 cond = masm->CheckBothSmi(rcx, rdx);
623 cond = masm->CheckBothSmi(rcx, rcx);
627 cond = masm->CheckBothSmi(rdx, rdx);
633 cond = masm->CheckInteger32ValidSmiValue(rax);
638 cond = masm->CheckInteger32ValidSmiValue(rax);
643 cond = masm->CheckInteger32ValidSmiValue(rax);
648 cond = masm->CheckInteger32ValidSmiValue(rax);
655 ExitCode(masm);
659 masm->GetCode(&desc);
667 void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
726 MacroAssembler* masm = &assembler;
727 EntryCode(masm);
730 TestSmiNeg(masm, &exit, 0x10, 0);
731 TestSmiNeg(masm, &exit, 0x20, 1);
732 TestSmiNeg(masm, &exit, 0x30, -1);
733 TestSmiNeg(masm, &exit, 0x40, 127);
734 TestSmiNeg(masm, &exit, 0x50, 65535);
735 TestSmiNeg(masm, &exit, 0x60, Smi::kMinValue);
736 TestSmiNeg(masm, &exit, 0x70, Smi::kMaxValue);
737 TestSmiNeg(masm, &exit, 0x80, -Smi::kMaxValue);
741 ExitCode(masm);
745 masm->GetCode(&desc);
752 static void SmiAddTest(MacroAssembler* masm,
818 static void SmiAddOverflowTest(MacroAssembler* masm,
942 MacroAssembler* masm = &assembler;
943 EntryCode(masm);
947 SmiAddTest(masm, &exit, 0x10, 1, 2);
948 SmiAddTest(masm, &exit, 0x20, 1, -2);
949 SmiAddTest(masm, &exit, 0x30, -1, 2);
950 SmiAddTest(masm, &exit, 0x40, -1, -2);
951 SmiAddTest(masm, &exit, 0x50, 0x1000, 0x2000);
952 SmiAddTest(masm, &exit, 0x60, Smi::kMinValue, 5);
953 SmiAddTest(masm, &exit, 0x70, Smi::kMaxValue, -5);
954 SmiAddTest(masm, &exit, 0x80, Smi::kMaxValue, Smi::kMinValue);
956 SmiAddOverflowTest(masm, &exit, 0x90, -1);
957 SmiAddOverflowTest(masm, &exit, 0xA0, 1);
958 SmiAddOverflowTest(masm, &exit, 0xB0, 1024);
959 SmiAddOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue);
960 SmiAddOverflowTest(masm, &exit, 0xD0, -2);
961 SmiAddOverflowTest(masm, &exit, 0xE0, -42000);
962 SmiAddOverflowTest(masm, &exit, 0xF0, Smi::kMinValue);
966 ExitCode(masm);
970 masm->GetCode(&desc);
977 static void SmiSubTest(MacroAssembler* masm,
1037 static void SmiSubOverflowTest(MacroAssembler* masm,
1163 MacroAssembler* masm = &assembler;
1164 EntryCode(masm);
1167 SmiSubTest(masm, &exit, 0x10, 1, 2);
1168 SmiSubTest(masm, &exit, 0x20, 1, -2);
1169 SmiSubTest(masm, &exit, 0x30, -1, 2);
1170 SmiSubTest(masm, &exit, 0x40, -1, -2);
1171 SmiSubTest(masm, &exit, 0x50, 0x1000, 0x2000);
1172 SmiSubTest(masm, &exit, 0x60, Smi::kMinValue, -5);
1173 SmiSubTest(masm, &exit, 0x70, Smi::kMaxValue, 5);
1174 SmiSubTest(masm, &exit, 0x80, -Smi::kMaxValue, Smi::kMinValue);
1175 SmiSubTest(masm
1177 SmiSubOverflowTest(masm, &exit, 0xA0, 1);
1178 SmiSubOverflowTest(masm, &exit, 0xB0, 1024);
1179 SmiSubOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue);
1180 SmiSubOverflowTest(masm, &exit, 0xD0, -2);
1181 SmiSubOverflowTest(masm, &exit, 0xE0, -42000);
1182 SmiSubOverflowTest(masm, &exit, 0xF0, Smi::kMinValue);
1183 SmiSubOverflowTest(masm, &exit, 0x100, 0);
1187 ExitCode(masm);
1191 masm->GetCode(&desc);
1199 void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1253 MacroAssembler* masm = &assembler;
1254 EntryCode(masm);
1257 TestSmiMul(masm, &exit, 0x10, 0, 0);
1258 TestSmiMul(masm, &exit, 0x20, -1, 0);
1259 TestSmiMul(masm, &exit, 0x30, 0, -1);
1260 TestSmiMul(masm, &exit, 0x40, -1, -1);
1261 TestSmiMul(masm, &exit, 0x50, 0x10000, 0x10000);
1262 TestSmiMul(masm, &exit, 0x60, 0x10000, 0xffff);
1263 TestSmiMul(masm, &exit, 0x70, 0x10000, 0xffff);
1264 TestSmiMul(masm, &exit, 0x80, Smi::kMaxValue, -1);
1265 TestSmiMul(masm, &exit, 0x90, Smi::kMaxValue, -2);
1266 TestSmiMul(masm, &exit, 0xa0, Smi::kMaxValue, 2);
1267 TestSmiMul(masm, &exit, 0xb0, (Smi::kMaxValue / 2), 2);
1268 TestSmiMul(masm, &exit, 0xc0, (Smi::kMaxValue / 2) + 1, 2);
1269 TestSmiMul(masm, &exit, 0xd0, (Smi::kMinValue / 2), 2);
1270 TestSmiMul(masm, &exit, 0xe0, (Smi::kMinValue / 2) - 1, 2);
1274 ExitCode(masm);
1278 masm->GetCode(&desc);
1285 void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1359 MacroAssembler* masm = &assembler;
1360 EntryCode(masm);
1365 TestSmiDiv(masm, &exit, 0x10, 1, 1);
1366 TestSmiDiv(masm, &exit, 0x20, 1, 0);
1367 TestSmiDiv(masm, &exit, 0x30, -1, 0);
1368 TestSmiDiv(masm, &exit, 0x40, 0, 1);
1369 TestSmiDiv(masm, &exit, 0x50, 0, -1);
1370 TestSmiDiv(masm, &exit, 0x60, 4, 2);
1371 TestSmiDiv(masm, &exit, 0x70, -4, 2);
1372 TestSmiDiv(masm, &exit, 0x80, 4, -2);
1373 TestSmiDiv(masm, &exit, 0x90, -4, -2);
1374 TestSmiDiv(masm, &exit, 0xa0, 3, 2);
1375 TestSmiDiv(masm, &exit, 0xb0, 3, 4);
1376 TestSmiDiv(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1377 TestSmiDiv(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1378 TestSmiDiv(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1379 TestSmiDiv(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1380 TestSmiDiv(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1381 TestSmiDiv(masm, &exit, 0x110, Smi::kMaxValue, -1);
1382 TestSmiDiv(masm, &exit, 0x120, Smi::kMinValue, 1);
1383 TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1384 TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1);
1391 ExitCode(masm);
1395 masm->GetCode(&desc);
1402 void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1469 MacroAssembler* masm = &assembler;
1470 EntryCode(masm);
1475 TestSmiMod(masm, &exit, 0x10, 1, 1);
1476 TestSmiMod(masm, &exit, 0x20, 1, 0);
1477 TestSmiMod(masm, &exit, 0x30, -1, 0);
1478 TestSmiMod(masm, &exit, 0x40, 0, 1);
1479 TestSmiMod(masm, &exit, 0x50, 0, -1);
1480 TestSmiMod(masm, &exit, 0x60, 4, 2);
1481 TestSmiMod(masm, &exit, 0x70, -4, 2);
1482 TestSmiMod(masm, &exit, 0x80, 4, -2);
1483 TestSmiMod(masm, &exit, 0x90, -4, -2);
1484 TestSmiMod(masm, &exit, 0xa0, 3, 2);
1485 TestSmiMod(masm, &exit, 0xb0, 3, 4);
1486 TestSmiMod(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1487 TestSmiMod(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1488 TestSmiMod(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1489 TestSmiMod(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1490 TestSmiMod(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1491 TestSmiMod(masm, &exit, 0x110, Smi::kMaxValue, -1);
1492 TestSmiMod(masm, &exit, 0x120, Smi::kMinValue, 1);
1493 TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1494 TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1);
1501 ExitCode(masm);
1505 masm->GetCode(&desc);
1512 void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
1517 SmiIndex index = masm->SmiToIndex(rdx, rcx, i);
1525 index = masm->SmiToIndex(rcx, rcx, i);
1534 index = masm->SmiToNegativeIndex(rdx, rcx, i);
1542 index = masm->SmiToNegativeIndex(rcx, rcx, i);
1566 MacroAssembler* masm = &assembler;
1567 EntryCode(masm);
1570 TestSmiIndex(masm, &exit, 0x10, 0);
1571 TestSmiIndex(masm, &exit, 0x20, 1);
1572 TestSmiIndex(masm, &exit, 0x30, 100);
1573 TestSmiIndex(masm, &exit, 0x40, 1000);
1574 TestSmiIndex(masm, &exit, 0x50, Smi::kMaxValue);
1578 ExitCode(masm);
1582 masm->GetCode(&desc);
1589 void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1635 MacroAssembler* masm = &assembler;
1636 EntryCode(masm);
1639 TestSelectNonSmi(masm, &exit, 0x10, 0, 0);
1640 TestSelectNonSmi(masm, &exit, 0x20, 0, 1);
1641 TestSelectNonSmi(masm, &exit, 0x30, 1, 0);
1642 TestSelectNonSmi(masm, &exit, 0x40, 0, -1);
1643 TestSelectNonSmi(masm, &exit, 0x50, -1, 0);
1644 TestSelectNonSmi(masm, &exit, 0x60, -1, -1);
1645 TestSelectNonSmi(masm, &exit, 0x70, 1, 1);
1646 TestSelectNonSmi(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1647 TestSelectNonSmi(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1651 ExitCode(masm);
1655 masm->GetCode(&desc);
1662 void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1714 MacroAssembler* masm = &assembler;
1715 EntryCode(masm);
1718 TestSmiAnd(masm, &exit, 0x10, 0, 0);
1719 TestSmiAnd(masm, &exit, 0x20, 0, 1);
1720 TestSmiAnd(masm, &exit, 0x30, 1, 0);
1721 TestSmiAnd(masm, &exit, 0x40, 0, -1);
1722 TestSmiAnd(masm, &exit, 0x50, -1, 0);
1723 TestSmiAnd(masm, &exit, 0x60, -1, -1);
1724 TestSmiAnd(masm, &exit, 0x70, 1, 1);
1725 TestSmiAnd(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1726 TestSmiAnd(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1727 TestSmiAnd(masm, &exit, 0xA0, Smi::kMinValue, -1);
1728 TestSmiAnd(masm, &exit, 0xB0, Smi::kMinValue, -1);
1732 ExitCode(masm);
1736 masm->GetCode(&desc);
1743 void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1795 MacroAssembler* masm = &assembler;
1796 EntryCode(masm);
1799 TestSmiOr(masm, &exit, 0x10, 0, 0);
1800 TestSmiOr(masm, &exit, 0x20, 0, 1);
1801 TestSmiOr(masm, &exit, 0x30, 1, 0);
1802 TestSmiOr(masm, &exit, 0x40, 0, -1);
1803 TestSmiOr(masm, &exit, 0x50, -1, 0);
1804 TestSmiOr(masm, &exit, 0x60, -1, -1);
1805 TestSmiOr(masm, &exit, 0x70, 1, 1);
1806 TestSmiOr(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1807 TestSmiOr(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1808 TestSmiOr(masm, &exit, 0xA0, Smi::kMinValue, -1);
1809 TestSmiOr(masm, &exit, 0xB0, 0x05555555, 0x01234567);
1810 TestSmiOr(masm, &exit, 0xC0, 0x05555555, 0x0fedcba9);
1811 TestSmiOr(masm, &exit, 0xD0, Smi::kMinValue, -1);
1815 ExitCode(masm);
1819 masm->GetCode(&desc);
1826 void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1878 MacroAssembler* masm = &assembler;
1879 EntryCode(masm);
1882 TestSmiXor(masm, &exit, 0x10, 0, 0);
1883 TestSmiXor(masm, &exit, 0x20, 0, 1);
1884 TestSmiXor(masm, &exit, 0x30, 1, 0);
1885 TestSmiXor(masm, &exit, 0x40, 0, -1);
1886 TestSmiXor(masm, &exit, 0x50, -1, 0);
1887 TestSmiXor(masm, &exit, 0x60, -1, -1);
1888 TestSmiXor(masm, &exit, 0x70, 1, 1);
1889 TestSmiXor(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1890 TestSmiXor(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1891 TestSmiXor(masm, &exit, 0xA0, Smi::kMinValue, -1);
1892 TestSmiXor(masm, &exit, 0xB0, 0x5555555, 0x01234567);
1893 TestSmiXor(masm, &exit, 0xC0, 0x5555555, 0x0fedcba9);
1894 TestSmiXor(masm, &exit, 0xD0, Smi::kMinValue, -1);
1898 ExitCode(masm);
1902 masm->GetCode(&desc);
1909 void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) {
1945 MacroAssembler* masm = &assembler;
1946 EntryCode(masm);
1949 TestSmiNot(masm, &exit, 0x10, 0);
1950 TestSmiNot(masm, &exit, 0x20, 1);
1951 TestSmiNot(masm, &exit, 0x30, -1);
1952 TestSmiNot(masm, &exit, 0x40, 127);
1953 TestSmiNot(masm, &exit, 0x50, 65535);
1954 TestSmiNot(masm, &exit, 0x60, Smi::kMinValue);
1955 TestSmiNot(masm, &exit, 0x70, Smi::kMaxValue);
1956 TestSmiNot(masm, &exit, 0x80, 0x05555555);
1960 ExitCode(masm);
1964 masm->GetCode(&desc);
1971 void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
2041 MacroAssembler* masm = &assembler;
2042 EntryCode(masm);
2045 TestSmiShiftLeft(masm, &exit, 0x10, 0);
2046 TestSmiShiftLeft(masm, &exit, 0x50, 1);
2047 TestSmiShiftLeft(masm, &exit, 0x90, 127);
2048 TestSmiShiftLeft(masm, &exit, 0xD0, 65535);
2049 TestSmiShiftLeft(masm, &exit, 0x110, Smi::kMaxValue);
2050 TestSmiShiftLeft(masm, &exit, 0x150, Smi::kMinValue);
2051 TestSmiShiftLeft(masm, &exit, 0x190, -1);
2055 ExitCode(masm);
2059 masm->GetCode(&desc);
2066 void TestSmiShiftLogicalRight(MacroAssembler* masm,
2147 MacroAssembler* masm = &assembler;
2148 EntryCode(masm);
2151 TestSmiShiftLogicalRight(masm, &exit, 0x10, 0);
2152 TestSmiShiftLogicalRight(masm, &exit, 0x30, 1);
2153 TestSmiShiftLogicalRight(masm, &exit, 0x50, 127);
2154 TestSmiShiftLogicalRight(masm, &exit, 0x70, 65535);
2155 TestSmiShiftLogicalRight(masm, &exit, 0x90, Smi::kMaxValue);
2156 TestSmiShiftLogicalRight(masm, &exit, 0xB0, Smi::kMinValue);
2157 TestSmiShiftLogicalRight(masm, &exit, 0xD0, -1);
2161 ExitCode(masm);
2165 masm->GetCode(&desc);
2172 void TestSmiShiftArithmeticRight(MacroAssembler* masm,
2216 MacroAssembler* masm = &assembler;
2217 EntryCode(masm);
2220 TestSmiShiftArithmeticRight(masm, &exit, 0x10, 0);
2221 TestSmiShiftArithmeticRight(masm, &exit, 0x20, 1);
2222 TestSmiShiftArithmeticRight(masm, &exit, 0x30, 127);
2223 TestSmiShiftArithmeticRight(masm, &exit, 0x40, 65535);
2224 TestSmiShiftArithmeticRight(masm, &exit, 0x50, Smi::kMaxValue);
2225 TestSmiShiftArithmeticRight(masm, &exit, 0x60, Smi::kMinValue);
2226 TestSmiShiftArithmeticRight(masm, &exit, 0x70, -1);
2230 ExitCode(masm);
2234 masm->GetCode(&desc);
2241 void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) {
2280 MacroAssembler* masm = &assembler;
2281 EntryCode(masm);
2284 TestPositiveSmiPowerUp(masm, &exit, 0x20, 0);
2285 TestPositiveSmiPowerUp(masm, &exit, 0x40, 1);
2286 TestPositiveSmiPowerUp(masm, &exit, 0x60, 127);
2287 TestPositiveSmiPowerUp(masm, &exit, 0x80, 128);
2288 TestPositiveSmiPowerUp(masm, &exit, 0xA0, 255);
2289 TestPositiveSmiPowerUp(masm, &exit, 0xC0, 256);
2290 TestPositiveSmiPowerUp(masm, &exit, 0x100, 65535);
2291 TestPositiveSmiPowerUp(masm, &exit, 0x120, 65536);
2292 TestPositiveSmiPowerUp(masm, &exit, 0x140, Smi::kMaxValue);
2296 ExitCode(masm);
2300 masm->GetCode(&desc);
2323 MacroAssembler* masm = &assembler;
2326 EntryCode(masm);
2651 ExitCode(masm);
2656 masm->GetCode(&desc);
2675 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
2676 EntryCode(masm);
2802 ExitCode(masm);
2806 masm->GetCode(&desc);
