Changeset 203331 in webkit
- Timestamp:
- Jul 17, 2016 7:33:26 AM (8 years ago)
- Location:
- trunk/Source/JavaScriptCore
- Files:
-
- 10 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/ChangeLog
r203329 r203331 1 2016-07-17 Yusuke Suzuki <utatane.tea@gmail.com> 2 3 [JSC] Mask TrustedImm32 to 8bit in MacroAssembler for 8bit operations 4 https://bugs.webkit.org/show_bug.cgi?id=159334 5 6 Reviewed by Filip Pizlo. 7 8 Previously, in 8bit operations (like add8, compare8, test8, branch8, branchTest8 etc.), 9 we require that the given TrustedImm32 is in range of 8bit. While achieving this in 10 the manual MacroAssembler calling is easy, in Air, we don't guarantee that the higher bit 11 of the 8bit argument is cleared. So the current assertions are invalid. 12 13 This patch relaxes the above restriction. By removing this assertion, 14 8bit operations can take arbitrary 32bit imms. And only lower 8bit are effective when 15 emitting the code in these methods. 16 17 * assembler/MacroAssembler.h: 18 (JSC::MacroAssembler::branchTest8): 19 * assembler/MacroAssemblerARM.h: 20 (JSC::MacroAssemblerARM::store8): 21 (JSC::MacroAssemblerARM::branch8): 22 (JSC::MacroAssemblerARM::branchTest8): 23 (JSC::MacroAssemblerARM::compare8): 24 (JSC::MacroAssemblerARM::test8): 25 * assembler/MacroAssemblerARM64.h: 26 (JSC::MacroAssemblerARM64::store8): 27 (JSC::MacroAssemblerARM64::branch8): 28 (JSC::MacroAssemblerARM64::branchTest8): 29 (JSC::MacroAssemblerARM64::compare8): 30 (JSC::MacroAssemblerARM64::test8): 31 * assembler/MacroAssemblerARMv7.h: 32 (JSC::MacroAssemblerARMv7::store8): 33 (JSC::MacroAssemblerARMv7::branch8): 34 (JSC::MacroAssemblerARMv7::branchTest8): 35 (JSC::MacroAssemblerARMv7::compare8): 36 (JSC::MacroAssemblerARMv7::test8): 37 * assembler/MacroAssemblerMIPS.h: 38 (JSC::MacroAssemblerMIPS::store8): 39 (JSC::MacroAssemblerMIPS::branch8): 40 (JSC::MacroAssemblerMIPS::compare8): 41 (JSC::MacroAssemblerMIPS::branchTest8): 42 (JSC::MacroAssemblerMIPS::test8): 43 * assembler/MacroAssemblerSH4.h: 44 (JSC::MacroAssemblerSH4::store8): 45 (JSC::MacroAssemblerSH4::branchTest8): 46 (JSC::MacroAssemblerSH4::branch8): 47 (JSC::MacroAssemblerSH4::compare8): 48 (JSC::MacroAssemblerSH4::test8): 49 * assembler/MacroAssemblerX86.h: 50 (JSC::MacroAssemblerX86::store8): 51 (JSC::MacroAssemblerX86::branch8): 52 (JSC::MacroAssemblerX86::branchTest8): 53 * assembler/MacroAssemblerX86Common.h: 54 (JSC::MacroAssemblerX86Common::add8): 55 (JSC::MacroAssemblerX86Common::store8): 56 (JSC::MacroAssemblerX86Common::branch8): 57 (JSC::MacroAssemblerX86Common::branchTest8): 58 (JSC::MacroAssemblerX86Common::compare8): 59 (JSC::MacroAssemblerX86Common::test8): 60 * assembler/MacroAssemblerX86_64.h: 61 (JSC::MacroAssemblerX86_64::store8): 62 (JSC::MacroAssemblerX86_64::branch8): 63 (JSC::MacroAssemblerX86_64::branchTest8): 64 1 65 2016-07-16 Chris Dumez <cdumez@apple.com> 2 66 -
trunk/Source/JavaScriptCore/assembler/MacroAssembler.h
r200970 r203331 791 791 Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1)) 792 792 { 793 return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask); 793 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 794 return MacroAssemblerBase::branchTest8(cond, Address(address.base, address.offset), mask8); 794 795 } 795 796 -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h
r203293 r203331 502 502 void store8(TrustedImm32 imm, ImplicitAddress address) 503 503 { 504 move(imm, ARMRegisters::S1); 504 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 505 move(imm8, ARMRegisters::S1); 505 506 store8(ARMRegisters::S1, address); 506 507 } … … 508 509 void store8(TrustedImm32 imm, const void* address) 509 510 { 511 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 510 512 move(TrustedImm32(reinterpret_cast<ARMWord>(address)), ARMRegisters::S0); 511 move(imm , ARMRegisters::S1);513 move(imm8, ARMRegisters::S1); 512 514 m_assembler.dtrUp(ARMAssembler::StoreUint8, ARMRegisters::S1, ARMRegisters::S0, 0); 513 515 } … … 624 626 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 625 627 { 628 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 626 629 load8(left, ARMRegisters::S1); 627 return branch32(cond, ARMRegisters::S1, right );630 return branch32(cond, ARMRegisters::S1, right8); 628 631 } 629 632 630 633 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 631 634 { 632 ASSERT(!(right.m_value & 0xFFFFFF00));635 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 633 636 load8(left, ARMRegisters::S1); 634 return branch32(cond, ARMRegisters::S1, right );637 return branch32(cond, ARMRegisters::S1, right8); 635 638 } 636 639 637 640 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 638 641 { 642 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 639 643 move(TrustedImmPtr(left.m_ptr), ARMRegisters::S1); 640 644 load8(Address(ARMRegisters::S1), ARMRegisters::S1); 641 return branch32(cond, ARMRegisters::S1, right );645 return branch32(cond, ARMRegisters::S1, right8); 642 646 } 643 647 … … 686 690 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1)) 687 691 { 692 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 688 693 load8(address, ARMRegisters::S1); 689 return branchTest32(cond, ARMRegisters::S1, mask );694 return branchTest32(cond, ARMRegisters::S1, mask8); 690 695 } 691 696 692 697 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1)) 693 698 { 699 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 694 700 load8(address, ARMRegisters::S1); 695 return branchTest32(cond, ARMRegisters::S1, mask );701 return branchTest32(cond, ARMRegisters::S1, mask8); 696 702 } 697 703 698 704 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 699 705 { 706 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 700 707 move(TrustedImmPtr(address.m_ptr), ARMRegisters::S1); 701 708 load8(Address(ARMRegisters::S1), ARMRegisters::S1); 702 return branchTest32(cond, ARMRegisters::S1, mask );709 return branchTest32(cond, ARMRegisters::S1, mask8); 703 710 } 704 711 … … 966 973 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 967 974 { 975 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 968 976 load8(left, ARMRegisters::S1); 969 compare32(cond, ARMRegisters::S1, right , dest);977 compare32(cond, ARMRegisters::S1, right8, dest); 970 978 } 971 979 … … 988 996 void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest) 989 997 { 998 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 990 999 load8(address, ARMRegisters::S1); 991 test32(cond, ARMRegisters::S1, mask , dest);1000 test32(cond, ARMRegisters::S1, mask8, dest); 992 1001 } 993 1002 -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h
r202214 r203331 1409 1409 void store8(TrustedImm32 imm, void* address) 1410 1410 { 1411 if (!imm.m_value) { 1411 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 1412 if (!imm8.m_value) { 1412 1413 store8(ARM64Registers::zr, address); 1413 1414 return; 1414 1415 } 1415 1416 1416 move(imm , getCachedDataTempRegisterIDAndInvalidate());1417 move(imm8, getCachedDataTempRegisterIDAndInvalidate()); 1417 1418 store8(dataTempRegister, address); 1418 1419 } … … 1420 1421 void store8(TrustedImm32 imm, ImplicitAddress address) 1421 1422 { 1422 if (!imm.m_value) { 1423 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 1424 if (!imm8.m_value) { 1423 1425 store8(ARM64Registers::zr, address); 1424 1426 return; 1425 1427 } 1426 1428 1427 move(imm , getCachedDataTempRegisterIDAndInvalidate());1429 move(imm8, getCachedDataTempRegisterIDAndInvalidate()); 1428 1430 store8(dataTempRegister, address); 1429 1431 } … … 2403 2405 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 2404 2406 { 2405 ASSERT(!(0xffffff00 &right.m_value));2407 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2406 2408 load8(left, getCachedMemoryTempRegisterIDAndInvalidate()); 2407 return branch32(cond, memoryTempRegister, right );2409 return branch32(cond, memoryTempRegister, right8); 2408 2410 } 2409 2411 2410 2412 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 2411 2413 { 2412 ASSERT(!(0xffffff00 &right.m_value));2414 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2413 2415 load8(left, getCachedMemoryTempRegisterIDAndInvalidate()); 2414 return branch32(cond, memoryTempRegister, right );2416 return branch32(cond, memoryTempRegister, right8); 2415 2417 } 2416 2418 2417 2419 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 2418 2420 { 2419 ASSERT(!(0xffffff00 &right.m_value));2421 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2420 2422 load8(left.m_ptr, getCachedMemoryTempRegisterIDAndInvalidate()); 2421 return branch32(cond, memoryTempRegister, right );2423 return branch32(cond, memoryTempRegister, right8); 2422 2424 } 2423 2425 … … 2546 2548 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1)) 2547 2549 { 2550 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2548 2551 load8(address, getCachedDataTempRegisterIDAndInvalidate()); 2549 return branchTest32(cond, dataTempRegister, mask );2552 return branchTest32(cond, dataTempRegister, mask8); 2550 2553 } 2551 2554 2552 2555 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 2553 2556 { 2557 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2554 2558 load8(address.m_ptr, getCachedDataTempRegisterIDAndInvalidate()); 2555 return branchTest32(cond, dataTempRegister, mask );2559 return branchTest32(cond, dataTempRegister, mask8); 2556 2560 } 2557 2561 2558 2562 Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1)) 2559 2563 { 2564 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2560 2565 move(TrustedImmPtr(reinterpret_cast<void*>(address.offset)), getCachedDataTempRegisterIDAndInvalidate()); 2561 2566 m_assembler.ldrb(dataTempRegister, address.base, dataTempRegister); 2562 return branchTest32(cond, dataTempRegister, mask );2567 return branchTest32(cond, dataTempRegister, mask8); 2563 2568 } 2564 2569 2565 2570 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1)) 2566 2571 { 2572 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2567 2573 load8(address, getCachedDataTempRegisterIDAndInvalidate()); 2568 return branchTest32(cond, dataTempRegister, mask );2574 return branchTest32(cond, dataTempRegister, mask8); 2569 2575 } 2570 2576 … … 2976 2982 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 2977 2983 { 2984 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2978 2985 load8(left, getCachedMemoryTempRegisterIDAndInvalidate()); 2979 move(right , getCachedDataTempRegisterIDAndInvalidate());2986 move(right8, getCachedDataTempRegisterIDAndInvalidate()); 2980 2987 compare32(cond, memoryTempRegister, dataTempRegister, dest); 2981 2988 } … … 3001 3008 void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest) 3002 3009 { 3010 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 3003 3011 load8(address, getCachedMemoryTempRegisterIDAndInvalidate()); 3004 test32(cond, memoryTempRegister, mask , dest);3012 test32(cond, memoryTempRegister, mask8, dest); 3005 3013 } 3006 3014 -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h
r202899 r203331 830 830 void store8(TrustedImm32 imm, void* address) 831 831 { 832 move(imm, dataTempRegister); 832 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 833 move(imm8, dataTempRegister); 833 834 store8(dataTempRegister, address); 834 835 } … … 836 837 void store8(TrustedImm32 imm, Address address) 837 838 { 838 move(imm, dataTempRegister); 839 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 840 move(imm8, dataTempRegister); 839 841 store8(dataTempRegister, address); 840 842 } … … 1477 1479 Jump branch8(RelationalCondition cond, RegisterID left, TrustedImm32 right) 1478 1480 { 1479 compare32AndSetFlags(left, right); 1481 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1482 compare32AndSetFlags(left, right8); 1480 1483 return Jump(makeBranch(cond)); 1481 1484 } … … 1483 1486 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 1484 1487 { 1485 ASSERT(!(0xffffff00 & right.m_value));1486 1488 // use addressTempRegister incase the branch8 we call uses dataTempRegister. :-/ 1489 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1487 1490 load8(left, addressTempRegister); 1488 return branch8(cond, addressTempRegister, right );1491 return branch8(cond, addressTempRegister, right8); 1489 1492 } 1490 1493 1491 1494 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 1492 1495 { 1493 ASSERT(!(0xffffff00 & right.m_value));1494 1496 // use addressTempRegister incase the branch32 we call uses dataTempRegister. :-/ 1497 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1495 1498 load8(left, addressTempRegister); 1496 return branch32(cond, addressTempRegister, right );1499 return branch32(cond, addressTempRegister, right8); 1497 1500 } 1498 1501 … … 1500 1503 { 1501 1504 // Use addressTempRegister instead of dataTempRegister, since branch32 uses dataTempRegister. 1505 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1502 1506 move(TrustedImmPtr(address.m_ptr), addressTempRegister); 1503 1507 load8(Address(addressTempRegister), addressTempRegister); 1504 return branch32(cond, addressTempRegister, right );1508 return branch32(cond, addressTempRegister, right8); 1505 1509 } 1506 1510 … … 1536 1540 { 1537 1541 // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/ 1542 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1538 1543 load8(address, addressTempRegister); 1539 return branchTest32(cond, addressTempRegister, mask );1544 return branchTest32(cond, addressTempRegister, mask8); 1540 1545 } 1541 1546 … … 1543 1548 { 1544 1549 // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/ 1550 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1545 1551 load8(address, addressTempRegister); 1546 return branchTest32(cond, addressTempRegister, mask );1552 return branchTest32(cond, addressTempRegister, mask8); 1547 1553 } 1548 1554 … … 1550 1556 { 1551 1557 // use addressTempRegister incase the branchTest8 we call uses dataTempRegister. :-/ 1558 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1552 1559 move(TrustedImmPtr(address.m_ptr), addressTempRegister); 1553 1560 load8(Address(addressTempRegister), addressTempRegister); 1554 return branchTest32(cond, addressTempRegister, mask );1561 return branchTest32(cond, addressTempRegister, mask8); 1555 1562 } 1556 1563 … … 1779 1786 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 1780 1787 { 1788 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1781 1789 load8(left, addressTempRegister); 1782 compare32(cond, addressTempRegister, right , dest);1790 compare32(cond, addressTempRegister, right8, dest); 1783 1791 } 1784 1792 … … 1806 1814 void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest) 1807 1815 { 1816 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1808 1817 load8(address, dataTempRegister); 1809 test32(dataTempRegister, mask );1818 test32(dataTempRegister, mask8); 1810 1819 m_assembler.it(armV7Condition(cond), false); 1811 1820 m_assembler.mov(dest, ARMThumbImmediate::makeUInt16(1)); -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h
r203226 r203331 1092 1092 sb src, 0(addrTemp) 1093 1093 */ 1094 if (!imm.m_value && !m_fixedWidth) { 1094 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 1095 if (!imm8.m_value && !m_fixedWidth) { 1095 1096 move(TrustedImmPtr(address), addrTempRegister); 1096 1097 m_assembler.sb(MIPSRegisters::zero, addrTempRegister, 0); 1097 1098 } else { 1098 move(imm , immTempRegister);1099 move(imm8, immTempRegister); 1099 1100 move(TrustedImmPtr(address), addrTempRegister); 1100 1101 m_assembler.sb(immTempRegister, addrTempRegister, 0); … … 1104 1105 void store8(TrustedImm32 imm, ImplicitAddress address) 1105 1106 { 1107 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 1106 1108 if (address.offset >= -32768 && address.offset <= 32767 1107 1109 && !m_fixedWidth) { 1108 if (!imm .m_value)1110 if (!imm8.m_value) 1109 1111 m_assembler.sb(MIPSRegisters::zero, address.base, address.offset); 1110 1112 else { 1111 move(imm , immTempRegister);1113 move(imm8, immTempRegister); 1112 1114 m_assembler.sb(immTempRegister, address.base, address.offset); 1113 1115 } … … 1120 1122 m_assembler.lui(addrTempRegister, (address.offset + 0x8000) >> 16); 1121 1123 m_assembler.addu(addrTempRegister, addrTempRegister, address.base); 1122 if (!imm .m_value && !m_fixedWidth)1124 if (!imm8.m_value && !m_fixedWidth) 1123 1125 m_assembler.sb(MIPSRegisters::zero, addrTempRegister, address.offset); 1124 1126 else { 1125 move(imm , immTempRegister);1127 move(imm8, immTempRegister); 1126 1128 m_assembler.sb(immTempRegister, addrTempRegister, address.offset); 1127 1129 } … … 1445 1447 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 1446 1448 { 1447 // Make sure the immediate value is unsigned 8 bits. 1448 ASSERT(!(right.m_value & 0xFFFFFF00)); 1449 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1449 1450 load8(left, dataTempRegister); 1450 move(right , immTempRegister);1451 move(right8, immTempRegister); 1451 1452 return branch32(cond, dataTempRegister, immTempRegister); 1452 1453 } … … 1454 1455 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 1455 1456 { 1456 // Make sure the immediate value is unsigned 8 bits. 1457 ASSERT(!(right.m_value & 0xFFFFFF00)); 1457 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1458 1458 load8(left, dataTempRegister); 1459 move(right , immTempRegister);1459 move(right8, immTempRegister); 1460 1460 return branch32(cond, dataTempRegister, immTempRegister); 1461 1461 } … … 1463 1463 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 1464 1464 { 1465 // Make sure the immediate value is unsigned 8 bits. 1466 ASSERT(!(right.m_value & 0xFFFFFF00)); 1465 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1467 1466 load8(left, dataTempRegister); 1468 move(right , immTempRegister);1467 move(right8, immTempRegister); 1469 1468 compare32(cond, dataTempRegister, immTempRegister, dest); 1470 1469 } … … 1472 1471 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 1473 1472 { 1474 ASSERT(!(right.m_value & 0xFFFFFF00));1473 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1475 1474 load8(left, dataTempRegister); 1476 1475 // Be careful that the previous load8() uses immTempRegister. 1477 1476 // So, we need to put move() after load8(). 1478 move(right , immTempRegister);1477 move(right8, immTempRegister); 1479 1478 return branch32(cond, dataTempRegister, immTempRegister); 1480 1479 } … … 1631 1630 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1)) 1632 1631 { 1632 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1633 1633 load8(address, dataTempRegister); 1634 return branchTest32(cond, dataTempRegister, mask );1634 return branchTest32(cond, dataTempRegister, mask8); 1635 1635 } 1636 1636 1637 1637 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1)) 1638 1638 { 1639 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1639 1640 load8(address, dataTempRegister); 1640 return branchTest32(cond, dataTempRegister, mask );1641 return branchTest32(cond, dataTempRegister, mask8); 1641 1642 } 1642 1643 1643 1644 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 1644 1645 { 1646 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1645 1647 move(TrustedImmPtr(address.m_ptr), dataTempRegister); 1646 1648 load8(Address(dataTempRegister), dataTempRegister); 1647 return branchTest32(cond, dataTempRegister, mask );1649 return branchTest32(cond, dataTempRegister, mask8); 1648 1650 } 1649 1651 … … 2218 2220 { 2219 2221 ASSERT((cond == Zero) || (cond == NonZero)); 2222 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2220 2223 load8(address, dataTempRegister); 2221 if (mask .m_value == -1 && !m_fixedWidth) {2224 if (mask8.m_value == -1 && !m_fixedWidth) { 2222 2225 if (cond == Zero) 2223 2226 m_assembler.sltiu(dest, dataTempRegister, 1); … … 2225 2228 m_assembler.sltu(dest, MIPSRegisters::zero, dataTempRegister); 2226 2229 } else { 2227 move(mask , immTempRegister);2230 move(mask8, immTempRegister); 2228 2231 m_assembler.andInsn(cmpTempRegister, dataTempRegister, immTempRegister); 2229 2232 if (cond == Zero) -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h
r198981 r203331 922 922 void store8(TrustedImm32 imm, void* address) 923 923 { 924 ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));924 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 925 925 RegisterID dstptr = claimScratch(); 926 926 move(TrustedImmPtr(address), dstptr); 927 927 RegisterID srcval = claimScratch(); 928 move(imm , srcval);928 move(imm8, srcval); 929 929 m_assembler.movbRegMem(srcval, dstptr); 930 930 releaseScratch(dstptr); … … 934 934 void store8(TrustedImm32 imm, Address address) 935 935 { 936 ASSERT((imm.m_value >= -128) && (imm.m_value <= 127));936 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 937 937 RegisterID dstptr = claimScratch(); 938 938 move(address.base, dstptr); 939 939 add32(TrustedImm32(address.offset), dstptr); 940 940 RegisterID srcval = claimScratch(); 941 move(imm , srcval);941 move(imm8, srcval); 942 942 m_assembler.movbRegMem(srcval, dstptr); 943 943 releaseScratch(dstptr); … … 1596 1596 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1)) 1597 1597 { 1598 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1598 1599 RegisterID addressTempRegister = claimScratch(); 1599 1600 load8(address, addressTempRegister); 1600 Jump jmp = branchTest32(cond, addressTempRegister, mask );1601 Jump jmp = branchTest32(cond, addressTempRegister, mask8); 1601 1602 releaseScratch(addressTempRegister); 1602 1603 return jmp; … … 1605 1606 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1)) 1606 1607 { 1608 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1607 1609 RegisterID addressTempRegister = claimScratch(); 1608 1610 load8(address, addressTempRegister); 1609 Jump jmp = branchTest32(cond, addressTempRegister, mask );1611 Jump jmp = branchTest32(cond, addressTempRegister, mask8); 1610 1612 releaseScratch(addressTempRegister); 1611 1613 return jmp; … … 1614 1616 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 1615 1617 { 1618 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1616 1619 RegisterID addressTempRegister = claimScratch(); 1617 1620 move(TrustedImmPtr(address.m_ptr), addressTempRegister); 1618 1621 load8(Address(addressTempRegister), addressTempRegister); 1619 Jump jmp = branchTest32(cond, addressTempRegister, mask );1622 Jump jmp = branchTest32(cond, addressTempRegister, mask8); 1620 1623 releaseScratch(addressTempRegister); 1621 1624 return jmp; … … 1634 1637 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 1635 1638 { 1639 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1636 1640 RegisterID addressTempRegister = claimScratch(); 1637 1641 load8(left, addressTempRegister); 1638 Jump jmp = branch32(cond, addressTempRegister, right );1642 Jump jmp = branch32(cond, addressTempRegister, right8); 1639 1643 releaseScratch(addressTempRegister); 1640 1644 return jmp; … … 1643 1647 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 1644 1648 { 1649 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1645 1650 RegisterID addressTempRegister = claimScratch(); 1646 1651 load8(left, addressTempRegister); 1647 Jump jmp = branch32(cond, addressTempRegister, right );1652 Jump jmp = branch32(cond, addressTempRegister, right8); 1648 1653 releaseScratch(addressTempRegister); 1649 1654 return jmp; … … 1652 1657 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 1653 1658 { 1659 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1654 1660 RegisterID addressTempRegister = claimScratch(); 1655 1661 load8(left, addressTempRegister); 1656 compare32(cond, addressTempRegister, right , dest);1662 compare32(cond, addressTempRegister, right8, dest); 1657 1663 releaseScratch(addressTempRegister); 1658 1664 } … … 1826 1832 ASSERT((cond == Zero) || (cond == NonZero)); 1827 1833 1834 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1835 1828 1836 load8(address, dest); 1829 if (mask .m_value == -1)1837 if (mask8.m_value == -1) 1830 1838 compare32(0, dest, static_cast<RelationalCondition>(cond)); 1831 1839 else 1832 testlImm(mask .m_value, dest);1840 testlImm(mask8.m_value, dest); 1833 1841 if (cond != NonZero) { 1834 1842 m_assembler.movt(dest); … … 1948 1956 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 1949 1957 { 1950 ASSERT(!(right.m_value & 0xFFFFFF00));1958 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1951 1959 RegisterID lefttmp = claimScratch(); 1952 1960 … … 1955 1963 load8(lefttmp, lefttmp); 1956 1964 RegisterID righttmp = claimScratch(); 1957 m_assembler.loadConstant(right .m_value, righttmp);1965 m_assembler.loadConstant(right8.m_value, righttmp); 1958 1966 1959 1967 Jump result = branch32(cond, lefttmp, righttmp); -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86.h
r196152 r203331 161 161 void store8(TrustedImm32 imm, void* address) 162 162 { 163 ASSERT(-128 <= imm.m_value && imm.m_value < 128);164 m_assembler.movb_i8m(imm .m_value, address);163 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 164 m_assembler.movb_i8m(imm8.m_value, address); 165 165 } 166 166 … … 238 238 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 239 239 { 240 m_assembler.cmpb_im(right.m_value, left.m_ptr); 240 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 241 m_assembler.cmpb_im(right8.m_value, left.m_ptr); 241 242 return Jump(m_assembler.jCC(x86Condition(cond))); 242 243 } … … 244 245 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 245 246 { 246 ASSERT(mask.m_value >= -128 && mask.m_value <= 255);247 if (mask .m_value == -1)247 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 248 if (mask8.m_value == -1) 248 249 m_assembler.cmpb_im(0, address.m_ptr); 249 250 else 250 m_assembler.testb_im(mask .m_value, address.m_ptr);251 m_assembler.testb_im(mask8.m_value, address.m_ptr); 251 252 return Jump(m_assembler.jCC(x86Condition(cond))); 252 253 } -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h
r202797 r203331 136 136 void add8(TrustedImm32 imm, Address address) 137 137 { 138 m_assembler.addb_im(imm.m_value, address.offset, address.base); 138 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 139 m_assembler.addb_im(imm8.m_value, address.offset, address.base); 139 140 } 140 141 141 142 void add8(TrustedImm32 imm, BaseIndex address) 142 143 { 143 m_assembler.addb_im(imm.m_value, address.offset, address.base, address.index, address.scale); 144 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 145 m_assembler.addb_im(imm8.m_value, address.offset, address.base, address.index, address.scale); 144 146 } 145 147 … … 909 911 void store8(TrustedImm32 imm, Address address) 910 912 { 911 m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base); 913 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 914 m_assembler.movb_i8m(imm8.m_value, address.offset, address.base); 912 915 } 913 916 914 917 void store8(TrustedImm32 imm, BaseIndex address) 915 918 { 916 m_assembler.movb_i8m(static_cast<int8_t>(imm.m_value), address.offset, address.base, address.index, address.scale); 919 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 920 m_assembler.movb_i8m(imm8.m_value, address.offset, address.base, address.index, address.scale); 917 921 } 918 922 … … 2122 2126 Jump branch8(RelationalCondition cond, Address left, TrustedImm32 right) 2123 2127 { 2124 m_assembler.cmpb_im(right.m_value, left.offset, left.base); 2128 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2129 m_assembler.cmpb_im(right8.m_value, left.offset, left.base); 2125 2130 return Jump(m_assembler.jCC(x86Condition(cond))); 2126 2131 } … … 2219 2224 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1)) 2220 2225 { 2221 // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values. 2222 ASSERT(mask.m_value >= -128 && mask.m_value <= 255); 2223 if (mask.m_value == -1) 2226 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2227 if (mask8.m_value == -1) 2224 2228 m_assembler.cmpb_im(0, address.offset, address.base); 2225 2229 else 2226 m_assembler.testb_im(mask .m_value, address.offset, address.base);2230 m_assembler.testb_im(mask8.m_value, address.offset, address.base); 2227 2231 return Jump(m_assembler.jCC(x86Condition(cond))); 2228 2232 } … … 2230 2234 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1)) 2231 2235 { 2232 // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values. 2233 ASSERT(mask.m_value >= -128 && mask.m_value <= 255); 2234 if (mask.m_value == -1) 2236 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2237 if (mask8.m_value == -1) 2235 2238 m_assembler.cmpb_im(0, address.offset, address.base, address.index, address.scale); 2236 2239 else 2237 m_assembler.testb_im(mask .m_value, address.offset, address.base, address.index, address.scale);2240 m_assembler.testb_im(mask8.m_value, address.offset, address.base, address.index, address.scale); 2238 2241 return Jump(m_assembler.jCC(x86Condition(cond))); 2239 2242 } … … 2241 2244 Jump branch8(RelationalCondition cond, BaseIndex left, TrustedImm32 right) 2242 2245 { 2243 // Byte in TrustedImm32 is not well defined, so be a little permissive here, but don't accept nonsense values. 2244 ASSERT(right.m_value >= -128 && right.m_value <= 255); 2245 2246 m_assembler.cmpb_im(right.m_value, left.offset, left.base, left.index, left.scale); 2246 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2247 m_assembler.cmpb_im(right8.m_value, left.offset, left.base, left.index, left.scale); 2247 2248 return Jump(m_assembler.jCC(x86Condition(cond))); 2248 2249 } … … 2460 2461 void compare8(RelationalCondition cond, Address left, TrustedImm32 right, RegisterID dest) 2461 2462 { 2462 m_assembler.cmpb_im(right.m_value, left.offset, left.base); 2463 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 2464 m_assembler.cmpb_im(right8.m_value, left.offset, left.base); 2463 2465 set32(x86Condition(cond), dest); 2464 2466 } … … 2490 2492 void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest) 2491 2493 { 2492 if (mask.m_value == -1) 2494 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 2495 if (mask8.m_value == -1) 2493 2496 m_assembler.cmpb_im(0, address.offset, address.base); 2494 2497 else 2495 m_assembler.testb_im(mask .m_value, address.offset, address.base);2498 m_assembler.testb_im(mask8.m_value, address.offset, address.base); 2496 2499 set32(x86Condition(cond), dest); 2497 2500 } -
trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86_64.h
r201208 r203331 138 138 void store8(TrustedImm32 imm, void* address) 139 139 { 140 TrustedImm32 imm8(static_cast<int8_t>(imm.m_value)); 140 141 move(TrustedImmPtr(address), scratchRegister()); 141 store8(imm , Address(scratchRegister()));142 store8(imm8, Address(scratchRegister())); 142 143 } 143 144 … … 1211 1212 Jump branch8(RelationalCondition cond, AbsoluteAddress left, TrustedImm32 right) 1212 1213 { 1214 TrustedImm32 right8(static_cast<int8_t>(right.m_value)); 1213 1215 MacroAssemblerX86Common::move(TrustedImmPtr(left.m_ptr), scratchRegister()); 1214 return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right );1216 return MacroAssemblerX86Common::branch8(cond, Address(scratchRegister()), right8); 1215 1217 } 1216 1218 … … 1218 1220 Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1)) 1219 1221 { 1222 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1220 1223 TrustedImmPtr addr(reinterpret_cast<void*>(address.offset)); 1221 1224 MacroAssemblerX86Common::move(addr, scratchRegister()); 1222 return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask );1225 return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister(), address.base, TimesOne), mask8); 1223 1226 } 1224 1227 1225 1228 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1)) 1226 1229 { 1230 TrustedImm32 mask8(static_cast<int8_t>(mask.m_value)); 1227 1231 MacroAssemblerX86Common::move(TrustedImmPtr(address.m_ptr), scratchRegister()); 1228 return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask );1232 return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister()), mask8); 1229 1233 } 1230 1234
Note: See TracChangeset
for help on using the changeset viewer.