Lines Matching refs:masm
93 #define __ masm->
96 static void EntryCode(MacroAssembler* masm) {
105 static void ExitCode(MacroAssembler* masm) {
142 static void TestMoveSmi(MacroAssembler* masm, Label* exit, int id, Smi* value) {
164 MacroAssembler* masm = &assembler; // Create a pointer for the __ macro.
165 masm->set_allow_stub_calls(false);
166 EntryCode(masm);
169 TestMoveSmi(masm, &exit, 1, Smi::FromInt(0));
170 TestMoveSmi(masm, &exit, 2, Smi::FromInt(127));
171 TestMoveSmi(masm, &exit, 3, Smi::FromInt(128));
172 TestMoveSmi(masm, &exit, 4, Smi::FromInt(255));
173 TestMoveSmi(masm, &exit, 5, Smi::FromInt(256));
174 TestMoveSmi(masm, &exit, 6, Smi::FromInt(Smi::kMaxValue));
175 TestMoveSmi(masm, &exit, 7, Smi::FromInt(-1));
176 TestMoveSmi(masm, &exit, 8, Smi::FromInt(-128));
177 TestMoveSmi(masm, &exit, 9, Smi::FromInt(-129));
178 TestMoveSmi(masm, &exit, 10, Smi::FromInt(-256));
179 TestMoveSmi(masm, &exit, 11, Smi::FromInt(-257));
180 TestMoveSmi(masm, &exit, 12, Smi::FromInt(Smi::kMinValue));
184 ExitCode(masm);
188 masm->GetCode(&desc);
195 void TestSmiCompare(MacroAssembler* masm, Label* exit, int id, int x, int y) {
255 MacroAssembler* masm = &assembler;
256 masm->set_allow_stub_calls(false);
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);
307 MacroAssembler* masm = &assembler;
308 masm->set_allow_stub_calls(false);
309 EntryCode(masm);
387 ExitCode(masm);
391 masm->GetCode(&desc);
398 void TestI64PlusConstantToSmi(MacroAssembler* masm,
437 MacroAssembler* masm = &assembler;
438 masm->set_allow_stub_calls(false);
439 EntryCode(masm);
444 TestI64PlusConstantToSmi(masm, &exit, 0x10, 0, 0);
445 TestI64PlusConstantToSmi(masm, &exit, 0x20, 0, 1);
446 TestI64PlusConstantToSmi(masm, &exit, 0x30, 1, 0);
447 TestI64PlusConstantToSmi(masm, &exit, 0x40, Smi::kMaxValue - 5, 5);
448 TestI64PlusConstantToSmi(masm, &exit, 0x50, Smi::kMinValue + 5, 5);
449 TestI64PlusConstantToSmi(masm, &exit, 0x60, twice_max, -Smi::kMaxValue);
450 TestI64PlusConstantToSmi(masm, &exit, 0x70, -twice_max, Smi::kMaxValue);
451 TestI64PlusConstantToSmi(masm, &exit, 0x80, 0, Smi::kMinValue);
452 TestI64PlusConstantToSmi(masm, &exit, 0x90, 0, Smi::kMaxValue);
453 TestI64PlusConstantToSmi(masm, &exit, 0xA0, Smi::kMinValue, 0);
454 TestI64PlusConstantToSmi(masm, &exit, 0xB0, Smi::kMaxValue, 0);
455 TestI64PlusConstantToSmi(masm, &exit, 0xC0, twice_max, Smi::kMinValue);
459 ExitCode(masm);
463 masm->GetCode(&desc);
483 MacroAssembler* masm = &assembler;
484 masm->set_allow_stub_calls(false);
485 EntryCode(masm);
495 cond = masm->CheckSmi(rcx);
500 cond = masm->CheckSmi(rcx);
506 cond = masm->CheckSmi(rcx);
511 cond = masm->CheckSmi(rcx);
517 cond = masm->CheckSmi(rcx);
522 cond = masm->CheckSmi(rcx);
528 cond = masm->CheckSmi(rcx);
533 cond = masm->CheckSmi(rcx);
541 cond = masm->CheckNonNegativeSmi(rcx);
546 cond = masm->CheckNonNegativeSmi(rcx); // "zero" non-smi.
552 cond = masm->CheckNonNegativeSmi(rcx); // Negative smis are not positive.
558 cond = masm->CheckNonNegativeSmi(rcx); // Most negative smi is not positive.
563 cond = masm->CheckNonNegativeSmi(rcx); // "Negative" non-smi.
569 cond = masm->CheckNonNegativeSmi(rcx); // Most positive smi is positive.
574 cond = masm->CheckNonNegativeSmi(rcx); // "Positive" non-smi.
582 cond = masm->CheckIsMinSmi(rcx);
588 cond = masm->CheckIsMinSmi(rcx);
594 cond = masm->CheckIsMinSmi(rcx);
600 cond = masm->CheckIsMinSmi(rcx);
610 cond = masm->CheckBothSmi(rcx, rdx);
615 cond = masm->CheckBothSmi(rcx, rdx);
620 cond = masm->CheckBothSmi(rcx, rdx);
625 cond = masm->CheckBothSmi(rcx, rdx);
629 cond = masm->CheckBothSmi(rcx, rcx);
633 cond = masm->CheckBothSmi(rdx, rdx);
639 cond = masm->CheckInteger32ValidSmiValue(rax);
644 cond = masm->CheckInteger32ValidSmiValue(rax);
649 cond = masm->CheckInteger32ValidSmiValue(rax);
654 cond = masm->CheckInteger32ValidSmiValue(rax);
661 ExitCode(masm);
665 masm->GetCode(&desc);
673 void TestSmiNeg(MacroAssembler* masm, Label* exit, int id, int x) {
733 MacroAssembler* masm = &assembler;
734 masm->set_allow_stub_calls(false);
735 EntryCode(masm);
738 TestSmiNeg(masm, &exit, 0x10, 0);
739 TestSmiNeg(masm, &exit, 0x20, 1);
740 TestSmiNeg(masm, &exit, 0x30, -1);
741 TestSmiNeg(masm, &exit, 0x40, 127);
742 TestSmiNeg(masm, &exit, 0x50, 65535);
743 TestSmiNeg(masm, &exit, 0x60, Smi::kMinValue);
744 TestSmiNeg(masm, &exit, 0x70, Smi::kMaxValue);
745 TestSmiNeg(masm, &exit, 0x80, -Smi::kMaxValue);
749 ExitCode(masm);
753 masm->GetCode(&desc);
762 static void SmiAddTest(MacroAssembler* masm,
823 MacroAssembler* masm = &assembler;
824 masm->set_allow_stub_calls(false);
825 EntryCode(masm);
829 SmiAddTest(masm, &exit, 0x10, 1, 2);
830 SmiAddTest(masm, &exit, 0x20, 1, -2);
831 SmiAddTest(masm, &exit, 0x30, -1, 2);
832 SmiAddTest(masm, &exit, 0x40, -1, -2);
833 SmiAddTest(masm, &exit, 0x50, 0x1000, 0x2000);
834 SmiAddTest(masm, &exit, 0x60, Smi::kMinValue, 5);
835 SmiAddTest(masm, &exit, 0x70, Smi::kMaxValue, -5);
836 SmiAddTest(masm, &exit, 0x80, Smi::kMaxValue, Smi::kMinValue);
840 ExitCode(masm);
844 masm->GetCode(&desc);
851 static void SmiSubTest(MacroAssembler* masm,
895 static void SmiSubOverflowTest(MacroAssembler* masm,
1015 MacroAssembler* masm = &assembler;
1016 masm->set_allow_stub_calls(false);
1017 EntryCode(masm);
1020 SmiSubTest(masm, &exit, 0x10, 1, 2);
1021 SmiSubTest(masm, &exit, 0x20, 1, -2);
1022 SmiSubTest(masm, &exit, 0x30, -1, 2);
1023 SmiSubTest(masm, &exit, 0x40, -1, -2);
1024 SmiSubTest(masm, &exit, 0x50, 0x1000, 0x2000);
1025 SmiSubTest(masm, &exit, 0x60, Smi::kMinValue, -5);
1026 SmiSubTest(masm, &exit, 0x70, Smi::kMaxValue, 5);
1027 SmiSubTest(masm, &exit, 0x80, -Smi::kMaxValue, Smi::kMinValue);
1028 SmiSubTest(masm, &exit, 0x90, 0, Smi::kMaxValue);
1030 SmiSubOverflowTest(masm, &exit, 0xA0, 1);
1031 SmiSubOverflowTest(masm, &exit, 0xB0, 1024);
1032 SmiSubOverflowTest(masm, &exit, 0xC0, Smi::kMaxValue);
1033 SmiSubOverflowTest(masm, &exit, 0xD0, -2);
1034 SmiSubOverflowTest(masm, &exit, 0xE0, -42000);
1035 SmiSubOverflowTest(masm, &exit, 0xF0, Smi::kMinValue);
1036 SmiSubOverflowTest(masm, &exit, 0x100, 0);
1040 ExitCode(masm);
1044 masm->GetCode(&desc);
1052 void TestSmiMul(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1107 MacroAssembler* masm = &assembler;
1108 masm->set_allow_stub_calls(false);
1109 EntryCode(masm);
1112 TestSmiMul(masm, &exit, 0x10, 0, 0);
1113 TestSmiMul(masm, &exit, 0x20, -1, 0);
1114 TestSmiMul(masm, &exit, 0x30, 0, -1);
1115 TestSmiMul(masm, &exit, 0x40, -1, -1);
1116 TestSmiMul(masm, &exit, 0x50, 0x10000, 0x10000);
1117 TestSmiMul(masm, &exit, 0x60, 0x10000, 0xffff);
1118 TestSmiMul(masm, &exit, 0x70, 0x10000, 0xffff);
1119 TestSmiMul(masm, &exit, 0x80, Smi::kMaxValue, -1);
1120 TestSmiMul(masm, &exit, 0x90, Smi::kMaxValue, -2);
1121 TestSmiMul(masm, &exit, 0xa0, Smi::kMaxValue, 2);
1122 TestSmiMul(masm, &exit, 0xb0, (Smi::kMaxValue / 2), 2);
1123 TestSmiMul(masm, &exit, 0xc0, (Smi::kMaxValue / 2) + 1, 2);
1124 TestSmiMul(masm, &exit, 0xd0, (Smi::kMinValue / 2), 2);
1125 TestSmiMul(masm, &exit, 0xe0, (Smi::kMinValue / 2) - 1, 2);
1129 ExitCode(masm);
1133 masm->GetCode(&desc);
1140 void TestSmiDiv(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1215 MacroAssembler* masm = &assembler;
1216 masm->set_allow_stub_calls(false);
1217 EntryCode(masm);
1222 TestSmiDiv(masm, &exit, 0x10, 1, 1);
1223 TestSmiDiv(masm, &exit, 0x20, 1, 0);
1224 TestSmiDiv(masm, &exit, 0x30, -1, 0);
1225 TestSmiDiv(masm, &exit, 0x40, 0, 1);
1226 TestSmiDiv(masm, &exit, 0x50, 0, -1);
1227 TestSmiDiv(masm, &exit, 0x60, 4, 2);
1228 TestSmiDiv(masm, &exit, 0x70, -4, 2);
1229 TestSmiDiv(masm, &exit, 0x80, 4, -2);
1230 TestSmiDiv(masm, &exit, 0x90, -4, -2);
1231 TestSmiDiv(masm, &exit, 0xa0, 3, 2);
1232 TestSmiDiv(masm, &exit, 0xb0, 3, 4);
1233 TestSmiDiv(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1234 TestSmiDiv(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1235 TestSmiDiv(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1236 TestSmiDiv(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1237 TestSmiDiv(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1238 TestSmiDiv(masm, &exit, 0x110, Smi::kMaxValue, -1);
1239 TestSmiDiv(masm, &exit, 0x120, Smi::kMinValue, 1);
1240 TestSmiDiv(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1241 TestSmiDiv(masm, &exit, 0x140, Smi::kMinValue, -1);
1248 ExitCode(masm);
1252 masm->GetCode(&desc);
1259 void TestSmiMod(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1327 MacroAssembler* masm = &assembler;
1328 masm->set_allow_stub_calls(false);
1329 EntryCode(masm);
1334 TestSmiMod(masm, &exit, 0x10, 1, 1);
1335 TestSmiMod(masm, &exit, 0x20, 1, 0);
1336 TestSmiMod(masm, &exit, 0x30, -1, 0);
1337 TestSmiMod(masm, &exit, 0x40, 0, 1);
1338 TestSmiMod(masm, &exit, 0x50, 0, -1);
1339 TestSmiMod(masm, &exit, 0x60, 4, 2);
1340 TestSmiMod(masm, &exit, 0x70, -4, 2);
1341 TestSmiMod(masm, &exit, 0x80, 4, -2);
1342 TestSmiMod(masm, &exit, 0x90, -4, -2);
1343 TestSmiMod(masm, &exit, 0xa0, 3, 2);
1344 TestSmiMod(masm, &exit, 0xb0, 3, 4);
1345 TestSmiMod(masm, &exit, 0xc0, 1, Smi::kMaxValue);
1346 TestSmiMod(masm, &exit, 0xd0, -1, Smi::kMaxValue);
1347 TestSmiMod(masm, &exit, 0xe0, Smi::kMaxValue, 1);
1348 TestSmiMod(masm, &exit, 0xf0, Smi::kMaxValue, Smi::kMaxValue);
1349 TestSmiMod(masm, &exit, 0x100, Smi::kMaxValue, -Smi::kMaxValue);
1350 TestSmiMod(masm, &exit, 0x110, Smi::kMaxValue, -1);
1351 TestSmiMod(masm, &exit, 0x120, Smi::kMinValue, 1);
1352 TestSmiMod(masm, &exit, 0x130, Smi::kMinValue, Smi::kMinValue);
1353 TestSmiMod(masm, &exit, 0x140, Smi::kMinValue, -1);
1360 ExitCode(masm);
1364 masm->GetCode(&desc);
1371 void TestSmiIndex(MacroAssembler* masm, Label* exit, int id, int x) {
1376 SmiIndex index = masm->SmiToIndex(rdx, rcx, i);
1384 index = masm->SmiToIndex(rcx, rcx, i);
1393 index = masm->SmiToNegativeIndex(rdx, rcx, i);
1401 index = masm->SmiToNegativeIndex(rcx, rcx, i);
1425 MacroAssembler* masm = &assembler;
1426 masm->set_allow_stub_calls(false);
1427 EntryCode(masm);
1430 TestSmiIndex(masm, &exit, 0x10, 0);
1431 TestSmiIndex(masm, &exit, 0x20, 1);
1432 TestSmiIndex(masm, &exit, 0x30, 100);
1433 TestSmiIndex(masm, &exit, 0x40, 1000);
1434 TestSmiIndex(masm, &exit, 0x50, Smi::kMaxValue);
1438 ExitCode(masm);
1442 masm->GetCode(&desc);
1449 void TestSelectNonSmi(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1496 MacroAssembler* masm = &assembler;
1497 masm->set_allow_stub_calls(false); // Avoid inline checks.
1498 EntryCode(masm);
1501 TestSelectNonSmi(masm, &exit, 0x10, 0, 0);
1502 TestSelectNonSmi(masm, &exit, 0x20, 0, 1);
1503 TestSelectNonSmi(masm, &exit, 0x30, 1, 0);
1504 TestSelectNonSmi(masm, &exit, 0x40, 0, -1);
1505 TestSelectNonSmi(masm, &exit, 0x50, -1, 0);
1506 TestSelectNonSmi(masm, &exit, 0x60, -1, -1);
1507 TestSelectNonSmi(masm, &exit, 0x70, 1, 1);
1508 TestSelectNonSmi(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1509 TestSelectNonSmi(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1513 ExitCode(masm);
1517 masm->GetCode(&desc);
1524 void TestSmiAnd(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1577 MacroAssembler* masm = &assembler;
1578 masm->set_allow_stub_calls(false);
1579 EntryCode(masm);
1582 TestSmiAnd(masm, &exit, 0x10, 0, 0);
1583 TestSmiAnd(masm, &exit, 0x20, 0, 1);
1584 TestSmiAnd(masm, &exit, 0x30, 1, 0);
1585 TestSmiAnd(masm, &exit, 0x40, 0, -1);
1586 TestSmiAnd(masm, &exit, 0x50, -1, 0);
1587 TestSmiAnd(masm, &exit, 0x60, -1, -1);
1588 TestSmiAnd(masm, &exit, 0x70, 1, 1);
1589 TestSmiAnd(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1590 TestSmiAnd(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1591 TestSmiAnd(masm, &exit, 0xA0, Smi::kMinValue, -1);
1592 TestSmiAnd(masm, &exit, 0xB0, Smi::kMinValue, -1);
1596 ExitCode(masm);
1600 masm->GetCode(&desc);
1607 void TestSmiOr(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1660 MacroAssembler* masm = &assembler;
1661 masm->set_allow_stub_calls(false);
1662 EntryCode(masm);
1665 TestSmiOr(masm, &exit, 0x10, 0, 0);
1666 TestSmiOr(masm, &exit, 0x20, 0, 1);
1667 TestSmiOr(masm, &exit, 0x30, 1, 0);
1668 TestSmiOr(masm, &exit, 0x40, 0, -1);
1669 TestSmiOr(masm, &exit, 0x50, -1, 0);
1670 TestSmiOr(masm, &exit, 0x60, -1, -1);
1671 TestSmiOr(masm, &exit, 0x70, 1, 1);
1672 TestSmiOr(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1673 TestSmiOr(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1674 TestSmiOr(masm, &exit, 0xA0, Smi::kMinValue, -1);
1675 TestSmiOr(masm, &exit, 0xB0, 0x05555555, 0x01234567);
1676 TestSmiOr(masm, &exit, 0xC0, 0x05555555, 0x0fedcba9);
1677 TestSmiOr(masm, &exit, 0xD0, Smi::kMinValue, -1);
1681 ExitCode(masm);
1685 masm->GetCode(&desc);
1692 void TestSmiXor(MacroAssembler* masm, Label* exit, int id, int x, int y) {
1745 MacroAssembler* masm = &assembler;
1746 masm->set_allow_stub_calls(false);
1747 EntryCode(masm);
1750 TestSmiXor(masm, &exit, 0x10, 0, 0);
1751 TestSmiXor(masm, &exit, 0x20, 0, 1);
1752 TestSmiXor(masm, &exit, 0x30, 1, 0);
1753 TestSmiXor(masm, &exit, 0x40, 0, -1);
1754 TestSmiXor(masm, &exit, 0x50, -1, 0);
1755 TestSmiXor(masm, &exit, 0x60, -1, -1);
1756 TestSmiXor(masm, &exit, 0x70, 1, 1);
1757 TestSmiXor(masm, &exit, 0x80, Smi::kMinValue, Smi::kMaxValue);
1758 TestSmiXor(masm, &exit, 0x90, Smi::kMinValue, Smi::kMinValue);
1759 TestSmiXor(masm, &exit, 0xA0, Smi::kMinValue, -1);
1760 TestSmiXor(masm, &exit, 0xB0, 0x5555555, 0x01234567);
1761 TestSmiXor(masm, &exit, 0xC0, 0x5555555, 0x0fedcba9);
1762 TestSmiXor(masm, &exit, 0xD0, Smi::kMinValue, -1);
1766 ExitCode(masm);
1770 masm->GetCode(&desc);
1777 void TestSmiNot(MacroAssembler* masm, Label* exit, int id, int x) {
1814 MacroAssembler* masm = &assembler;
1815 masm->set_allow_stub_calls(false);
1816 EntryCode(masm);
1819 TestSmiNot(masm, &exit, 0x10, 0);
1820 TestSmiNot(masm, &exit, 0x20, 1);
1821 TestSmiNot(masm, &exit, 0x30, -1);
1822 TestSmiNot(masm, &exit, 0x40, 127);
1823 TestSmiNot(masm, &exit, 0x50, 65535);
1824 TestSmiNot(masm, &exit, 0x60, Smi::kMinValue);
1825 TestSmiNot(masm, &exit, 0x70, Smi::kMaxValue);
1826 TestSmiNot(masm, &exit, 0x80, 0x05555555);
1830 ExitCode(masm);
1834 masm->GetCode(&desc);
1841 void TestSmiShiftLeft(MacroAssembler* masm, Label* exit, int id, int x) {
1912 MacroAssembler* masm = &assembler;
1913 masm->set_allow_stub_calls(false);
1914 EntryCode(masm);
1917 TestSmiShiftLeft(masm, &exit, 0x10, 0);
1918 TestSmiShiftLeft(masm, &exit, 0x50, 1);
1919 TestSmiShiftLeft(masm, &exit, 0x90, 127);
1920 TestSmiShiftLeft(masm, &exit, 0xD0, 65535);
1921 TestSmiShiftLeft(masm, &exit, 0x110, Smi::kMaxValue);
1922 TestSmiShiftLeft(masm, &exit, 0x150, Smi::kMinValue);
1923 TestSmiShiftLeft(masm, &exit, 0x190, -1);
1927 ExitCode(masm);
1931 masm->GetCode(&desc);
1938 void TestSmiShiftLogicalRight(MacroAssembler* masm,
2020 MacroAssembler* masm = &assembler;
2021 masm->set_allow_stub_calls(false);
2022 EntryCode(masm);
2025 TestSmiShiftLogicalRight(masm, &exit, 0x10, 0);
2026 TestSmiShiftLogicalRight(masm, &exit, 0x30, 1);
2027 TestSmiShiftLogicalRight(masm, &exit, 0x50, 127);
2028 TestSmiShiftLogicalRight(masm, &exit, 0x70, 65535);
2029 TestSmiShiftLogicalRight(masm, &exit, 0x90, Smi::kMaxValue);
2030 TestSmiShiftLogicalRight(masm, &exit, 0xB0, Smi::kMinValue);
2031 TestSmiShiftLogicalRight(masm, &exit, 0xD0, -1);
2035 ExitCode(masm);
2039 masm->GetCode(&desc);
2046 void TestSmiShiftArithmeticRight(MacroAssembler* masm,
2091 MacroAssembler* masm = &assembler;
2092 masm->set_allow_stub_calls(false);
2093 EntryCode(masm);
2096 TestSmiShiftArithmeticRight(masm, &exit, 0x10, 0);
2097 TestSmiShiftArithmeticRight(masm, &exit, 0x20, 1);
2098 TestSmiShiftArithmeticRight(masm, &exit, 0x30, 127);
2099 TestSmiShiftArithmeticRight(masm, &exit, 0x40, 65535);
2100 TestSmiShiftArithmeticRight(masm, &exit, 0x50, Smi::kMaxValue);
2101 TestSmiShiftArithmeticRight(masm, &exit, 0x60, Smi::kMinValue);
2102 TestSmiShiftArithmeticRight(masm, &exit, 0x70, -1);
2106 ExitCode(masm);
2110 masm->GetCode(&desc);
2117 void TestPositiveSmiPowerUp(MacroAssembler* masm, Label* exit, int id, int x) {
2157 MacroAssembler* masm = &assembler;
2158 masm->set_allow_stub_calls(false);
2159 EntryCode(masm);
2162 TestPositiveSmiPowerUp(masm, &exit, 0x20, 0);
2163 TestPositiveSmiPowerUp(masm, &exit, 0x40, 1);
2164 TestPositiveSmiPowerUp(masm, &exit, 0x60, 127);
2165 TestPositiveSmiPowerUp(masm, &exit, 0x80, 128);
2166 TestPositiveSmiPowerUp(masm, &exit, 0xA0, 255);
2167 TestPositiveSmiPowerUp(masm, &exit, 0xC0, 256);
2168 TestPositiveSmiPowerUp(masm, &exit, 0x100, 65535);
2169 TestPositiveSmiPowerUp(masm, &exit, 0x120, 65536);
2170 TestPositiveSmiPowerUp(masm, &exit, 0x140, Smi::kMaxValue);
2174 ExitCode(masm);
2178 masm->GetCode(&desc);
2202 MacroAssembler* masm = &assembler;
2203 masm->set_allow_stub_calls(false);
2206 EntryCode(masm);
2531 ExitCode(masm);
2536 masm->GetCode(&desc);