Lines Matching refs:address
188 void add32(TrustedImm32 imm, Address address)
190 load32(address, dataTempRegister);
202 store32(dataTempRegister, address);
211 void add32(TrustedImm32 imm, AbsoluteAddress address)
213 load32(address.m_ptr, dataTempRegister);
225 store32(dataTempRegister, address.m_ptr);
233 void add64(TrustedImm32 imm, AbsoluteAddress address)
235 move(TrustedImmPtr(address.m_ptr), addressTempRegister);
244 move(TrustedImmPtr(address.m_ptr), addressTempRegister);
344 void or32(TrustedImm32 imm, Address address)
346 load32(address, dataTempRegister);
348 store32(dataTempRegister, address);
438 void sub32(TrustedImm32 imm, Address address)
440 load32(address, dataTempRegister);
452 store32(dataTempRegister, address);
461 void sub32(TrustedImm32 imm, AbsoluteAddress address)
463 load32(address.m_ptr, dataTempRegister);
475 store32(dataTempRegister, address.m_ptr);
515 // Loads are of the form load(address, destination) and stores of the form
516 // store(source, address). The source for a store may be an TrustedImm32. Address
521 void load32(ArmAddress address, RegisterID dest)
523 if (address.type == ArmAddress::HasIndex)
524 m_assembler.ldr(dest, address.base, address.u.index, address.u.scale);
525 else if (address.u.offset >= 0) {
526 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
528 m_assembler.ldr(dest, address.base, armImm);
530 ASSERT(address.u.offset >= -255);
531 m_assembler.ldr(dest, address.base, address.u.offset, true, false);
535 void load16(ArmAddress address, RegisterID dest)
537 if (address.type == ArmAddress::HasIndex)
538 m_assembler.ldrh(dest, address.base, address.u.index, address.u.scale);
539 else if (address.u.offset >= 0) {
540 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
542 m_assembler.ldrh(dest, address.base, armImm);
544 ASSERT(address.u.offset >= -255);
545 m_assembler.ldrh(dest, address.base, address.u.offset, true, false);
549 void load16Signed(ArmAddress address, RegisterID dest)
551 ASSERT(address.type == ArmAddress::HasIndex);
552 m_assembler.ldrsh(dest, address.base, address.u.index, address.u.scale);
555 void load8(ArmAddress address, RegisterID dest)
557 if (address.type == ArmAddress::HasIndex)
558 m_assembler.ldrb(dest, address.base, address.u.index, address.u.scale);
559 else if (address.u.offset >= 0) {
560 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
562 m_assembler.ldrb(dest, address.base, armImm);
564 ASSERT(address.u.offset >= -255);
565 m_assembler.ldrb(dest, address.base, address.u.offset, true, false);
569 void load8Signed(ArmAddress address, RegisterID dest)
571 ASSERT(address.type == ArmAddress::HasIndex);
572 m_assembler.ldrsb(dest, address.base, address.u.index, address.u.scale);
576 void store32(RegisterID src, ArmAddress address)
578 if (address.type == ArmAddress::HasIndex)
579 m_assembler.str(src, address.base, address.u.index, address.u.scale);
580 else if (address.u.offset >= 0) {
581 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
583 m_assembler.str(src, address.base, armImm);
585 ASSERT(address.u.offset >= -255);
586 m_assembler.str(src, address.base, address.u.offset, true, false);
591 void store8(RegisterID src, ArmAddress address)
593 if (address.type == ArmAddress::HasIndex)
594 m_assembler.strb(src, address.base, address.u.index, address.u.scale);
595 else if (address.u.offset >= 0) {
596 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
598 m_assembler.strb(src, address.base, armImm);
600 ASSERT(address.u.offset >= -255);
601 m_assembler.strb(src, address.base, address.u.offset, true, false);
605 void store16(RegisterID src, ArmAddress address)
607 if (address.type == ArmAddress::HasIndex)
608 m_assembler.strh(src, address.base, address.u.index, address.u.scale);
609 else if (address.u.offset >= 0) {
610 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.u.offset);
612 m_assembler.strh(src, address.base, armImm);
614 ASSERT(address.u.offset >= -255);
615 m_assembler.strh(src, address.base, address.u.offset, true, false);
620 void load32(ImplicitAddress address, RegisterID dest)
622 load32(setupArmAddress(address), dest);
625 void load32(BaseIndex address, RegisterID dest)
627 load32(setupArmAddress(address), dest);
630 void load32WithUnalignedHalfWords(BaseIndex address, RegisterID dest)
632 load32(setupArmAddress(address), dest);
635 void load16Unaligned(BaseIndex address, RegisterID dest)
637 load16(setupArmAddress(address), dest);
640 void load32(const void* address, RegisterID dest)
642 move(TrustedImmPtr(address), addressTempRegister);
658 ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
661 ASSERT(address.offset >= 0 && address.offset <= 255);
662 m_assembler.ldrWide8BitImmediate(dest, address.base, address.offset);
666 void load8(ImplicitAddress address, RegisterID dest)
668 load8(setupArmAddress(address), dest);
676 void load8(BaseIndex address, RegisterID dest)
678 load8(setupArmAddress(address), dest);
681 void load8Signed(BaseIndex address, RegisterID dest)
683 load8Signed(setupArmAddress(address), dest);
686 void load8(const void* address, RegisterID dest)
688 move(TrustedImmPtr(address), dest);
692 DataLabel32 load32WithAddressOffsetPatch(Address address, RegisterID dest)
694 DataLabel32 label = moveWithPatch(TrustedImm32(address.offset), dataTempRegister);
695 load32(ArmAddress(address.base, dataTempRegister), dest);
699 DataLabelCompact load32WithCompactAddressOffsetPatch(Address address, RegisterID dest)
703 RegisterID base = address.base;
706 ASSERT(isCompactPtrAlignedAddressOffset(address.offset));
708 m_assembler.ldr(dest, base, address.offset, true, false);
712 void load16(BaseIndex address, RegisterID dest)
714 m_assembler.ldrh(dest, makeBaseIndexBase(address), address.index, address.scale);
717 void load16Signed(BaseIndex address, RegisterID dest)
719 load16Signed(setupArmAddress(address), dest);
722 void load16(ImplicitAddress address, RegisterID dest)
724 ARMThumbImmediate armImm = ARMThumbImmediate::makeUInt12(address.offset);
726 m_assembler.ldrh(dest, address.base, armImm);
728 move(TrustedImm32(address.offset), dataTempRegister);
729 m_assembler.ldrh(dest, address.base, dataTempRegister);
738 DataLabel32 store32WithAddressOffsetPatch(RegisterID src, Address address)
740 DataLabel32 label = moveWithPatch(TrustedImm32(address.offset), dataTempRegister);
741 store32(src, ArmAddress(address.base, dataTempRegister));
745 void store32(RegisterID src, ImplicitAddress address)
747 store32(src, setupArmAddress(address));
750 void store32(RegisterID src, BaseIndex address)
752 store32(src, setupArmAddress(address));
755 void store32(TrustedImm32 imm, ImplicitAddress address)
758 store32(dataTempRegister, setupArmAddress(address));
761 void store32(TrustedImm32 imm, BaseIndex address)
764 store32(dataTempRegister, setupArmAddress(address));
767 void store32(RegisterID src, const void* address)
769 move(TrustedImmPtr(address), addressTempRegister);
773 void store32(TrustedImm32 imm, const void* address)
776 store32(dataTempRegister, address);
779 void store8(RegisterID src, Address address)
781 store8(src, setupArmAddress(address));
784 void store8(RegisterID src, BaseIndex address)
786 store8(src, setupArmAddress(address));
789 void store8(RegisterID src, void* address)
791 move(TrustedImmPtr(address), addressTempRegister);
795 void store8(TrustedImm32 imm, void* address)
798 store8(dataTempRegister, address);
801 void store8(TrustedImm32 imm, Address address)
804 store8(dataTempRegister, address);
807 void store16(RegisterID src, BaseIndex address)
809 store16(src, setupArmAddress(address));
849 void loadDouble(ImplicitAddress address, FPRegisterID dest)
851 RegisterID base = address.base;
852 int32_t offset = address.offset;
864 void loadFloat(ImplicitAddress address, FPRegisterID dest)
866 RegisterID base = address.base;
867 int32_t offset = address.offset;
879 void loadDouble(BaseIndex address, FPRegisterID dest)
881 move(address.index, addressTempRegister);
882 lshift32(TrustedImm32(address.scale), addressTempRegister);
883 add32(address.base, addressTempRegister);
884 loadDouble(Address(addressTempRegister, address.offset), dest);
887 void loadFloat(BaseIndex address, FPRegisterID dest)
889 move(address.index, addressTempRegister);
890 lshift32(TrustedImm32(address.scale), addressTempRegister);
891 add32(address.base, addressTempRegister);
892 loadFloat(Address(addressTempRegister, address.offset), dest);
901 void loadDouble(TrustedImmPtr address, FPRegisterID dest)
903 move(address, addressTempRegister);
907 void storeDouble(FPRegisterID src, ImplicitAddress address)
909 RegisterID base = address.base;
910 int32_t offset = address.offset;
922 void storeFloat(FPRegisterID src, ImplicitAddress address)
924 RegisterID base = address.base;
925 int32_t offset = address.offset;
937 void storeDouble(FPRegisterID src, TrustedImmPtr address)
939 move(address, addressTempRegister);
943 void storeDouble(FPRegisterID src, BaseIndex address)
945 move(address.index, addressTempRegister);
946 lshift32(TrustedImm32(address.scale), addressTempRegister);
947 add32(address.base, addressTempRegister);
948 storeDouble(src, Address(addressTempRegister, address.offset));
951 void storeFloat(FPRegisterID src, BaseIndex address)
953 move(address.index, addressTempRegister);
954 lshift32(TrustedImm32(address.scale), addressTempRegister);
955 add32(address.base, addressTempRegister);
956 storeFloat(src, Address(addressTempRegister, address.offset));
975 void addDouble(AbsoluteAddress address, FPRegisterID dest)
977 loadDouble(TrustedImmPtr(address.m_ptr), fpTempRegister);
1044 void convertInt32ToDouble(Address address, FPRegisterID dest)
1047 load32(address, dataTempRegister);
1052 void convertInt32ToDouble(AbsoluteAddress address, FPRegisterID dest)
1055 load32(address.m_ptr, dataTempRegister);
1191 void push(Address address)
1193 load32(address, dataTempRegister);
1444 Jump branch8(RelationalCondition cond, AbsoluteAddress address, TrustedImm32 right)
1447 move(TrustedImmPtr(address.m_ptr), addressTempRegister);
1464 Jump branchTest32(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
1467 load32(address, addressTempRegister);
1471 Jump branchTest32(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
1474 load32(address, addressTempRegister);
1478 Jump branchTest8(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
1481 load8(address, addressTempRegister);
1485 Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
1488 load8(address, addressTempRegister);
1492 Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
1495 move(TrustedImmPtr(address.m_ptr), addressTempRegister);
1505 // Address is a memory location containing the address to jump to
1506 void jump(Address address)
1508 load32(address, dataTempRegister);
1512 void jump(AbsoluteAddress address)
1514 move(TrustedImmPtr(address.m_ptr), dataTempRegister);
1566 // Move the high bits of the address into addressTempRegister,
1578 // we'll need to reload it with the high bits of the address afterwards.
1691 ALWAYS_INLINE Call call(Address address)
1693 load32(address, dataTempRegister);
1734 void test32(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
1736 load32(address, dataTempRegister);
1743 void test8(ResultCondition cond, Address address, TrustedImm32 mask, RegisterID dest)
1745 load8(address, dataTempRegister);
1835 ALWAYS_INLINE DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
1838 store32(dataTempRegister, address);
1841 ALWAYS_INLINE DataLabelPtr storePtrWithPatch(ImplicitAddress address) { return storePtrWithPatch(TrustedImmPtr(0), address); }
1949 ArmAddress setupArmAddress(BaseIndex address)
1951 if (address.offset) {
1952 ARMThumbImmediate imm = ARMThumbImmediate::makeUInt12OrEncodedImm(address.offset);
1954 m_assembler.add(addressTempRegister, address.base, imm);
1956 move(TrustedImm32(address.offset), addressTempRegister);
1957 m_assembler.add(addressTempRegister, addressTempRegister, address.base);
1960 return ArmAddress(addressTempRegister, address.index, address.scale);
1962 return ArmAddress(address.base, address.index, address.scale);
1965 ArmAddress setupArmAddress(Address address)
1967 if ((address.offset >= -0xff) && (address.offset <= 0xfff))
1968 return ArmAddress(address.base, address.offset);
1970 move(TrustedImm32(address.offset), addressTempRegister);
1971 return ArmAddress(address.base, addressTempRegister);
1974 ArmAddress setupArmAddress(ImplicitAddress address)
1976 if ((address.offset >= -0xff) && (address.offset <= 0xfff))
1977 return ArmAddress(address.base, address.offset);
1979 move(TrustedImm32(address.offset), addressTempRegister);
1980 return ArmAddress(address.base, addressTempRegister);
1983 RegisterID makeBaseIndexBase(BaseIndex address)
1985 if (!address.offset)
1986 return address.base;
1988 ARMThumbImmediate imm = ARMThumbImmediate::makeUInt12OrEncodedImm(address.offset);
1990 m_assembler.add(addressTempRegister, address.base, imm);
1992 move(TrustedImm32(address.offset), addressTempRegister);
1993 m_assembler.add(addressTempRegister, addressTempRegister, address.base);