Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-18 15:55:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1229057 - Part 1: Move MacroAssembler::addPtr into generic macro assembler. r=nbp

Browse Source 
--HG--
extra : rebase_source : 86431533671a51b43a74d43de3b9264ec6a25210
This commit is contained in:
Tooru Fujisawa 2015-12-01 17:02:09 +09:00
parent 52931434b2
commit 86a64683a6
23 changed files with 324 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
js/src/jit/MacroAssembler-inl.h
View File

@ -313,6 +313,15 @@ MacroAssembler::hasSelfReference() const
return selfReferencePatch_.bound();
}
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(ImmPtr imm, Register dest)
{
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
//}}} check_macroassembler_style
// ===============================================================

10
js/src/jit/MacroAssembler.h
View File

@ -731,6 +731,16 @@ class MacroAssembler : public MacroAssemblerSpecific
// ===============================================================
// Arithmetic functions
inline void addPtr(Register src, Register dest) PER_ARCH;
inline void addPtr(Register src1, Register src2, Register dest) DEFINED_ON(arm64);
inline void addPtr(Imm32 imm, Register dest) PER_ARCH;
inline void addPtr(Imm32 imm, Register src, Register dest) DEFINED_ON(arm64);
inline void addPtr(ImmWord imm, Register dest) PER_ARCH;
inline void addPtr(ImmPtr imm, Register dest);
inline void addPtr(Imm32 imm, const Address& dest) DEFINED_ON(mips_shared, arm, arm64, x86, x64);
inline void addPtr(Imm32 imm, const AbsoluteAddress& dest) DEFINED_ON(x86, x64);
inline void addPtr(const Address& src, Register dest) DEFINED_ON(mips_shared, arm, arm64, x86, x64);
inline void sub32(const Address& src, Register dest) PER_SHARED_ARCH;
inline void sub32(Register src, Register dest) PER_SHARED_ARCH;
inline void sub32(Imm32 imm, Register dest) PER_SHARED_ARCH;

35
js/src/jit/arm/MacroAssembler-arm-inl.h
View File

@ -138,6 +138,41 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
ma_add(src, dest);
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
ma_add(imm, dest);
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
addPtr(Imm32(imm.value), dest);
}
void
MacroAssembler::addPtr(Imm32 imm, const Address& dest)
{
ScratchRegisterScope scratch(*this);
loadPtr(dest, scratch);
addPtr(imm, scratch);
storePtr(scratch, dest);
}
void
MacroAssembler::addPtr(const Address& src, Register dest)
{
ScratchRegisterScope scratch(*this);
load32(src, scratch);
ma_add(scratch, dest, SetCC);
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{

29
js/src/jit/arm/MacroAssembler-arm.cpp
View File

@ -1968,20 +1968,6 @@ MacroAssemblerARMCompat::add32(Imm32 imm, const Address& dest)
store32(scratch, dest);
}
void
MacroAssemblerARMCompat::addPtr(Register src, Register dest)
{
ma_add(src, dest);
}
void
MacroAssemblerARMCompat::addPtr(const Address& src, Register dest)
{
ScratchRegisterScope scratch(asMasm());
load32(src, scratch);
ma_add(scratch, dest, SetCC);
}
void
MacroAssemblerARMCompat::move32(Imm32 imm, Register dest)
{
@ -2655,21 +2641,6 @@ MacroAssemblerARMCompat::subPtr(Register src, const Address& dest)
storePtr(scratch, dest);
}
void
MacroAssemblerARMCompat::addPtr(Imm32 imm, const Register dest)
{
ma_add(imm, dest);
}
void
MacroAssemblerARMCompat::addPtr(Imm32 imm, const Address& dest)
{
ScratchRegisterScope scratch(asMasm());
loadPtr(dest, scratch);
addPtr(imm, scratch);
storePtr(scratch, dest);
}
void
MacroAssemblerARMCompat::compareDouble(FloatRegister lhs, FloatRegister rhs)
{

10
js/src/jit/arm/MacroAssembler-arm.h
View File

@ -1199,8 +1199,6 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
j(cond, label);
}
void addPtr(Register src, Register dest);
void addPtr(const Address& src, Register dest);
void add64(Imm32 imm, Register64 dest) {
ma_add(imm, dest.low, SetCC);
ma_adc(Imm32(0), dest.high, LeaveCC);
@ -1655,14 +1653,6 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
void subPtr(const Address& addr, const Register dest);
void subPtr(Register src, Register dest);
void subPtr(Register src, const Address& dest);
void addPtr(Imm32 imm, const Register dest);
void addPtr(Imm32 imm, const Address& dest);
void addPtr(ImmWord imm, const Register dest) {
addPtr(Imm32(imm.value), dest);
}
void addPtr(ImmPtr imm, const Register dest) {
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
void mulBy3(const Register& src, const Register& dest) {
as_add(dest, src, lsl(src, 1));
}

67
js/src/jit/arm64/MacroAssembler-arm64-inl.h
View File

@ -150,6 +150,59 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
addPtr(src, dest, dest);
}
void
MacroAssembler::addPtr(Register src1, Register src2, Register dest)
{
Add(ARMRegister(dest, 64), ARMRegister(src1, 64), Operand(ARMRegister(src2, 64)));
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
addPtr(imm, dest, dest);
}
void
MacroAssembler::addPtr(Imm32 imm, Register src, Register dest)
{
Add(ARMRegister(dest, 64), ARMRegister(src, 64), Operand(imm.value));
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(imm.value));
}
void
MacroAssembler::addPtr(Imm32 imm, const Address& dest)
{
vixl::UseScratchRegisterScope temps(this);
const ARMRegister scratch64 = temps.AcquireX();
MOZ_ASSERT(scratch64.asUnsized() != dest.base);
Ldr(scratch64, MemOperand(ARMRegister(dest.base, 64), dest.offset));
Add(scratch64, scratch64, Operand(imm.value));
Str(scratch64, MemOperand(ARMRegister(dest.base, 64), dest.offset));
}
void
MacroAssembler::addPtr(const Address& src, Register dest)
{
vixl::UseScratchRegisterScope temps(this);
const ARMRegister scratch64 = temps.AcquireX();
MOZ_ASSERT(scratch64.asUnsized() != src.base);
Ldr(scratch64, MemOperand(ARMRegister(src.base, 64), src.offset));
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(scratch64));
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{
@ -220,6 +273,20 @@ MacroAssembler::rshift64(Imm32 imm, Register64 dest)
//}}} check_macroassembler_style
// ===============================================================
template <typename T>
void
MacroAssemblerCompat::addToStackPtr(T t)
{
asMasm().addPtr(t, getStackPointer());
}
template <typename T>
void
MacroAssemblerCompat::addStackPtrTo(T t)
{
asMasm().addPtr(getStackPointer(), t);
}
template <typename T>
void
MacroAssemblerCompat::andToStackPtr(T t)

4
js/src/jit/arm64/MacroAssembler-arm64.cpp
View File

@ -226,7 +226,7 @@ MacroAssemblerCompat::branchPtrInNurseryRange(Condition cond, Register ptr, Regi
const Nursery& nursery = GetJitContext()->runtime->gcNursery();
movePtr(ImmWord(-ptrdiff_t(nursery.start())), temp);
addPtr(ptr, temp);
asMasm().addPtr(ptr, temp);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
temp, ImmWord(nursery.nurserySize()), label);
}
@ -248,7 +248,7 @@ MacroAssemblerCompat::branchValueIsNurseryObject(Condition cond, ValueOperand va
Value start = ObjectValue(*reinterpret_cast<JSObject*>(nursery.start()));
movePtr(ImmWord(-ptrdiff_t(start.asRawBits())), temp);
addPtr(value.valueReg(), temp);
asMasm().addPtr(value.valueReg(), temp);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
temp, ImmWord(nursery.nurserySize()), label);
}

43
js/src/jit/arm64/MacroAssembler-arm64.h
View File

@ -1029,10 +1029,8 @@ class MacroAssemblerCompat : public vixl::MacroAssembler
void storeUnalignedFloat32x4(FloatRegister dest, const BaseIndex& addr) { MOZ_CRASH("NYI"); }
// StackPointer manipulation.
template <typename T>
void addToStackPtr(T t) { addPtr(t, getStackPointer()); }
template <typename T>
void addStackPtrTo(T t) { addPtr(getStackPointer(), t); }
template <typename T> void addToStackPtr(T t);
template <typename T> void addStackPtrTo(T t);
template <typename T>
void subFromStackPtr(T t) { subPtr(t, getStackPointer()); syncStackPtr(); }
@ -1370,43 +1368,6 @@ class MacroAssemblerCompat : public vixl::MacroAssembler
Subs(ARMRegister(dest, 32), ARMRegister(dest, 32), Operand(ARMRegister(src, 32)));
}
void addPtr(Register src, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(ARMRegister(src, 64)));
}
void addPtr(Register src1, Register src2, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(src1, 64), Operand(ARMRegister(src2, 64)));
}
void addPtr(Imm32 imm, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(imm.value));
}
void addPtr(Imm32 imm, Register src, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(src, 64), Operand(imm.value));
}
void addPtr(Imm32 imm, const Address& dest) {
vixl::UseScratchRegisterScope temps(this);
const ARMRegister scratch64 = temps.AcquireX();
MOZ_ASSERT(scratch64.asUnsized() != dest.base);
Ldr(scratch64, MemOperand(ARMRegister(dest.base, 64), dest.offset));
Add(scratch64, scratch64, Operand(imm.value));
Str(scratch64, MemOperand(ARMRegister(dest.base, 64), dest.offset));
}
void addPtr(ImmWord imm, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(imm.value));
}
void addPtr(ImmPtr imm, Register dest) {
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(uint64_t(imm.value)));
}
void addPtr(const Address& src, Register dest) {
vixl::UseScratchRegisterScope temps(this);
const ARMRegister scratch64 = temps.AcquireX();
MOZ_ASSERT(scratch64.asUnsized() != src.base);
Ldr(scratch64, MemOperand(ARMRegister(src.base, 64), src.offset));
Add(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(scratch64));
}
void subPtr(Imm32 imm, Register dest) {
Sub(ARMRegister(dest, 64), ARMRegister(dest, 64), Operand(imm.value));
}

15
js/src/jit/mips-shared/MacroAssembler-mips-shared-inl.h
View File

@ -78,6 +78,21 @@ MacroAssembler::xor32(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic instructions
void
MacroAssembler::addPtr(Imm32 imm, const Address& dest)
{
loadPtr(dest, ScratchRegister);
addPtr(imm, ScratchRegister);
storePtr(ScratchRegister, dest);
}
void
MacroAssembler::addPtr(const Address& src, Register dest)
{
loadPtr(src, ScratchRegister);
addPtr(ScratchRegister, dest);
}
void
MacroAssembler::sub32(Register src, Register dest)
{

35
js/src/jit/mips32/MacroAssembler-mips32-inl.h
View File

@ -78,6 +78,24 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
ma_addu(dest, src);
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
ma_addu(dest, imm);
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
addPtr(Imm32(imm.value), dest);
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{
@ -131,6 +149,23 @@ MacroAssembler::rshift64(Imm32 imm, Register64 dest)
//}}} check_macroassembler_style
// ===============================================================
void
MacroAssemblerMIPSCompat::computeEffectiveAddress(const BaseIndex& address, Register dest)
{
computeScaledAddress(address, dest);
if (address.offset)
asMasm().addPtr(Imm32(address.offset), dest);
}
void
MacroAssemblerMIPSCompat::retn(Imm32 n) {
// pc <- [sp]; sp += n
loadPtr(Address(StackPointer, 0), ra);
asMasm().addPtr(n, StackPointer);
as_jr(ra);
as_nop();
}
} // namespace jit
} // namespace js

29
js/src/jit/mips32/MacroAssembler-mips32.cpp
View File

@ -833,19 +833,6 @@ MacroAssemblerMIPSCompat::add32(Imm32 imm, const Address& dest)
store32(SecondScratchReg, dest);
}
void
MacroAssemblerMIPSCompat::addPtr(Register src, Register dest)
{
ma_addu(dest, src);
}
void
MacroAssemblerMIPSCompat::addPtr(const Address& src, Register dest)
{
loadPtr(src, ScratchRegister);
ma_addu(dest, ScratchRegister);
}
void
MacroAssemblerMIPSCompat::subPtr(Register src, Register dest)
{
@ -1262,20 +1249,6 @@ MacroAssemblerMIPSCompat::subPtr(Register src, const Address& dest)
storePtr(SecondScratchReg, dest);
}
void
MacroAssemblerMIPSCompat::addPtr(Imm32 imm, const Register dest)
{
ma_addu(dest, imm);
}
void
MacroAssemblerMIPSCompat::addPtr(Imm32 imm, const Address& dest)
{
loadPtr(dest, ScratchRegister);
addPtr(imm, ScratchRegister);
storePtr(ScratchRegister, dest);
}
void
MacroAssemblerMIPSCompat::branchDouble(DoubleCondition cond, FloatRegister lhs,
FloatRegister rhs, Label* label)
@ -2548,7 +2521,7 @@ MacroAssemblerMIPSCompat::branchPtrInNurseryRange(Condition cond, Register ptr,
const Nursery& nursery = GetJitContext()->runtime->gcNursery();
movePtr(ImmWord(-ptrdiff_t(nursery.start())), SecondScratchReg);
addPtr(ptr, SecondScratchReg);
asMasm().addPtr(ptr, SecondScratchReg);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
SecondScratchReg, Imm32(nursery.nurserySize()), label);
}

25
js/src/jit/mips32/MacroAssembler-mips32.h
View File

@ -189,12 +189,7 @@ class MacroAssemblerMIPSCompat : public MacroAssemblerMIPS
ma_addu(dest, address.base, Imm32(address.offset));
}
void computeEffectiveAddress(const BaseIndex& address, Register dest) {
computeScaledAddress(address, dest);
if (address.offset) {
addPtr(Imm32(address.offset), dest);
}
}
inline void computeEffectiveAddress(const BaseIndex& address, Register dest);
void j(Label* dest) {
ma_b(dest);
@ -235,13 +230,7 @@ class MacroAssemblerMIPSCompat : public MacroAssemblerMIPS
as_jr(ra);
as_nop();
}
void retn(Imm32 n) {
// pc <- [sp]; sp += n
loadPtr(Address(StackPointer, 0), ra);
addPtr(n, StackPointer);
as_jr(ra);
as_nop();
}
inline void retn(Imm32 n);
void push(Imm32 imm) {
ma_li(ScratchRegister, imm);
ma_push(ScratchRegister);
@ -1111,9 +1100,7 @@ class MacroAssemblerMIPSCompat : public MacroAssemblerMIPS
}
}
void addPtr(Register src, Register dest);
void subPtr(Register src, Register dest);
void addPtr(const Address& src, Register dest);
void move32(Imm32 imm, Register dest);
void move32(Register src, Register dest);
@ -1258,14 +1245,6 @@ class MacroAssemblerMIPSCompat : public MacroAssemblerMIPS
void subPtr(Imm32 imm, const Register dest);
void subPtr(const Address& addr, const Register dest);
void subPtr(Register src, const Address& dest);
void addPtr(Imm32 imm, const Register dest);
void addPtr(Imm32 imm, const Address& dest);
void addPtr(ImmWord imm, const Register dest) {
addPtr(Imm32(imm.value), dest);
}
void addPtr(ImmPtr imm, const Register dest) {
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
void mulBy3(const Register& src, const Register& dest) {
as_addu(dest, src, src);
as_addu(dest, dest, src);

37
js/src/jit/mips64/MacroAssembler-mips64-inl.h
View File

@ -76,6 +76,25 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
ma_daddu(dest, src);
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
ma_daddu(dest, imm);
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
movePtr(imm, ScratchRegister);
addPtr(ScratchRegister, dest);
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{
@ -118,6 +137,24 @@ MacroAssembler::rshift64(Imm32 imm, Register64 dest)
//}}} check_macroassembler_style
// ===============================================================
void
MacroAssemblerMIPS64Compat::computeEffectiveAddress(const BaseIndex& address, Register dest)
{
computeScaledAddress(address, dest);
if (address.offset)
asMasm().addPtr(Imm32(address.offset), dest);
}
void
MacroAssemblerMIPS64Compat::retn(Imm32 n)
{
// pc <- [sp]; sp += n
loadPtr(Address(StackPointer, 0), ra);
asMasm().addPtr(n, StackPointer);
as_jr(ra);
as_nop();
}
} // namespace jit
} // namespace js

31
js/src/jit/mips64/MacroAssembler-mips64.cpp
View File

@ -918,19 +918,6 @@ MacroAssemblerMIPS64Compat::add32(Imm32 imm, const Address& dest)
store32(SecondScratchReg, dest);
}
void
MacroAssemblerMIPS64Compat::addPtr(Register src, Register dest)
{
ma_daddu(dest, src);
}
void
MacroAssemblerMIPS64Compat::addPtr(const Address& src, Register dest)
{
loadPtr(src, ScratchRegister);
ma_daddu(dest, ScratchRegister);
}
void
MacroAssemblerMIPS64Compat::subPtr(Register src, Register dest)
{
@ -1348,20 +1335,6 @@ MacroAssemblerMIPS64Compat::subPtr(Register src, const Address& dest)
storePtr(SecondScratchReg, dest);
}
void
MacroAssemblerMIPS64Compat::addPtr(Imm32 imm, const Register dest)
{
ma_daddu(dest, imm);
}
void
MacroAssemblerMIPS64Compat::addPtr(Imm32 imm, const Address& dest)
{
loadPtr(dest, ScratchRegister);
addPtr(imm, ScratchRegister);
storePtr(ScratchRegister, dest);
}
void
MacroAssemblerMIPS64Compat::branchDouble(DoubleCondition cond, FloatRegister lhs,
FloatRegister rhs, Label* label)
@ -2651,7 +2624,7 @@ MacroAssemblerMIPS64Compat::branchPtrInNurseryRange(Condition cond, Register ptr
const Nursery& nursery = GetJitContext()->runtime->gcNursery();
movePtr(ImmWord(-ptrdiff_t(nursery.start())), SecondScratchReg);
addPtr(ptr, SecondScratchReg);
asMasm().addPtr(ptr, SecondScratchReg);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
SecondScratchReg, Imm32(nursery.nurserySize()), label);
}
@ -2667,7 +2640,7 @@ MacroAssemblerMIPS64Compat::branchValueIsNurseryObject(Condition cond, ValueOper
Value start = ObjectValue(*reinterpret_cast<JSObject *>(nursery.start()));
movePtr(ImmWord(-ptrdiff_t(start.asRawBits())), SecondScratchReg);
addPtr(value.valueReg(), SecondScratchReg);
asMasm().addPtr(value.valueReg(), SecondScratchReg);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
SecondScratchReg, Imm32(nursery.nurserySize()), label);
}

26
js/src/jit/mips64/MacroAssembler-mips64.h
View File

@ -201,12 +201,7 @@ class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64
ma_daddu(dest, address.base, Imm32(address.offset));
}
void computeEffectiveAddress(const BaseIndex& address, Register dest) {
computeScaledAddress(address, dest);
if (address.offset) {
addPtr(Imm32(address.offset), dest);
}
}
inline void computeEffectiveAddress(const BaseIndex& address, Register dest);
void j(Label* dest) {
ma_b(dest);
@ -256,13 +251,7 @@ class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64
as_jr(ra);
as_nop();
}
void retn(Imm32 n) {
// pc <- [sp]; sp += n
loadPtr(Address(StackPointer, 0), ra);
addPtr(n, StackPointer);
as_jr(ra);
as_nop();
}
inline void retn(Imm32 n);
void push(Imm32 imm) {
ma_li(ScratchRegister, imm);
ma_push(ScratchRegister);
@ -1126,9 +1115,7 @@ class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64
}
}
void addPtr(Register src, Register dest);
void subPtr(Register src, Register dest);
void addPtr(const Address& src, Register dest);
void move32(Imm32 imm, Register dest);
void move32(Register src, Register dest);
@ -1269,15 +1256,6 @@ class MacroAssemblerMIPS64Compat : public MacroAssemblerMIPS64
void subPtr(Imm32 imm, const Register dest);
void subPtr(const Address& addr, const Register dest);
void subPtr(Register src, const Address& dest);
void addPtr(Imm32 imm, const Register dest);
void addPtr(Imm32 imm, const Address& dest);
void addPtr(ImmWord imm, const Register dest) {
movePtr(imm, ScratchRegister);
addPtr(ScratchRegister, dest);
}
void addPtr(ImmPtr imm, const Register dest) {
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
void mulBy3(const Register& src, const Register& dest) {
as_daddu(dest, src, src);
as_daddu(dest, dest, src);

1
js/src/jit/none/MacroAssembler-none.h
View File

@ -235,7 +235,6 @@ class MacroAssemblerNone : public Assembler
template <typename T, typename S> void cmp32Set(Condition, T, S, Register) { MOZ_CRASH(); }
template <typename T, typename S> void add32(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void addPtr(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void add64(T, S) { MOZ_CRASH(); }
template <typename T, typename S> void subPtr(T, S) { MOZ_CRASH(); }
void neg32(Register) { MOZ_CRASH(); }

61
js/src/jit/x64/MacroAssembler-x64-inl.h
View File

@ -75,6 +75,49 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
addq(src, dest);
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
addq(imm, dest);
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
ScratchRegisterScope scratch(*this);
MOZ_ASSERT(dest != scratch);
if ((intptr_t)imm.value <= INT32_MAX && (intptr_t)imm.value >= INT32_MIN) {
addq(Imm32((int32_t)imm.value), dest);
} else {
mov(imm, scratch);
addq(scratch, dest);
}
}
void
MacroAssembler::addPtr(Imm32 imm, const Address& dest)
{
addq(imm, Operand(dest));
}
void
MacroAssembler::addPtr(Imm32 imm, const AbsoluteAddress& dest)
{
addq(imm, Operand(dest));
}
void
MacroAssembler::addPtr(const Address& src, Register dest)
{
addq(Operand(src), dest);
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{
@ -117,6 +160,24 @@ MacroAssembler::rshift64(Imm32 imm, Register64 dest)
//}}} check_macroassembler_style
// ===============================================================
void
MacroAssemblerX64::inc64(AbsoluteAddress dest)
{
if (X86Encoding::IsAddressImmediate(dest.addr)) {
asMasm().addPtr(Imm32(1), dest);
} else {
ScratchRegisterScope scratch(asMasm());
mov(ImmPtr(dest.addr), scratch);
asMasm().addPtr(Imm32(1), Address(scratch, 0));
}
}
void
MacroAssemblerX64::incrementInt32Value(const Address& addr)
{
asMasm().addPtr(Imm32(1), addr);
}
} // namespace jit
} // namespace js

4
js/src/jit/x64/MacroAssembler-x64.cpp
View File

@ -265,7 +265,7 @@ MacroAssemblerX64::branchPtrInNurseryRange(Condition cond, Register ptr, Registe
const Nursery& nursery = GetJitContext()->runtime->gcNursery();
movePtr(ImmWord(-ptrdiff_t(nursery.start())), scratch);
addPtr(ptr, scratch);
asMasm().addPtr(ptr, scratch);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
scratch, Imm32(nursery.nurserySize()), label);
}
@ -287,7 +287,7 @@ MacroAssemblerX64::branchValueIsNurseryObject(Condition cond, ValueOperand value
ScratchRegisterScope scratch(asMasm());
movePtr(ImmWord(-ptrdiff_t(start.asRawBits())), scratch);
addPtr(value.valueReg(), scratch);
asMasm().addPtr(value.valueReg(), scratch);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
scratch, Imm32(nursery.nurserySize()), label);
}

42
js/src/jit/x64/MacroAssembler-x64.h
View File

@ -543,34 +543,6 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
// Common interface.
/////////////////////////////////////////////////////////////////
void addPtr(Register src, Register dest) {
addq(src, dest);
}
void addPtr(Imm32 imm, Register dest) {
addq(imm, dest);
}
void addPtr(Imm32 imm, const Address& dest) {
addq(imm, Operand(dest));
}
void addPtr(Imm32 imm, const Operand& dest) {
addq(imm, dest);
}
void addPtr(ImmWord imm, Register dest) {
ScratchRegisterScope scratch(asMasm());
MOZ_ASSERT(dest != scratch);
if ((intptr_t)imm.value <= INT32_MAX && (intptr_t)imm.value >= INT32_MIN) {
addq(Imm32((int32_t)imm.value), dest);
} else {
mov(imm, scratch);
addq(scratch, dest);
}
}
void addPtr(ImmPtr imm, Register dest) {
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
void addPtr(const Address& src, Register dest) {
addq(Operand(src), dest);
}
void add64(Imm32 imm, Register64 dest) {
addq(imm, dest.reg);
}
@ -1351,19 +1323,9 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
vmulsd(Operand(ScratchReg, 0), dest, dest);
}
void inc64(AbsoluteAddress dest) {
if (X86Encoding::IsAddressImmediate(dest.addr)) {
addPtr(Imm32(1), Operand(dest));
} else {
ScratchRegisterScope scratch(asMasm());
mov(ImmPtr(dest.addr), scratch);
addPtr(Imm32(1), Address(scratch, 0));
}
}
inline void inc64(AbsoluteAddress dest);
void incrementInt32Value(const Address& addr) {
addPtr(Imm32(1), addr);
}
inline void incrementInt32Value(const Address& addr);
// If source is a double, load it into dest. If source is int32,
// convert it to double. Else, branch to failure.

3
js/src/jit/x86-shared/MoveEmitter-x86-shared.cpp
View File

@ -440,7 +440,8 @@ MoveEmitterX86::emitGeneralMove(const MoveOperand& from, const MoveOperand& to,
// this clobbers FLAGS!
masm.Push(from.base());
masm.Pop(toPopOperand(to));
masm.addPtr(Imm32(from.disp()), toOperand(to));
MOZ_ASSERT(to.isMemoryOrEffectiveAddress());
masm.addPtr(Imm32(from.disp()), toAddress(to));
}
}
}

37
js/src/jit/x86/MacroAssembler-x86-inl.h
View File

@ -16,6 +16,7 @@ namespace jit {
//{{{ check_macroassembler_style
// ===============================================================
// Logical functions
void
MacroAssembler::andPtr(Register src, Register dest)
@ -77,6 +78,42 @@ MacroAssembler::xorPtr(Imm32 imm, Register dest)
// ===============================================================
// Arithmetic functions
void
MacroAssembler::addPtr(Register src, Register dest)
{
addl(src, dest);
}
void
MacroAssembler::addPtr(Imm32 imm, Register dest)
{
addl(imm, dest);
}
void
MacroAssembler::addPtr(ImmWord imm, Register dest)
{
addl(Imm32(imm.value), dest);
}
void
MacroAssembler::addPtr(Imm32 imm, const Address& dest)
{
addl(imm, Operand(dest));
}
void
MacroAssembler::addPtr(Imm32 imm, const AbsoluteAddress& dest)
{
addl(imm, Operand(dest));
}
void
MacroAssembler::addPtr(const Address& src, Register dest)
{
addl(Operand(src), dest);
}
void
MacroAssembler::add64(Register64 src, Register64 dest)
{

2
js/src/jit/x86/MacroAssembler-x86.cpp
View File

@ -355,7 +355,7 @@ MacroAssemblerX86::branchPtrInNurseryRange(Condition cond, Register ptr, Registe
const Nursery& nursery = GetJitContext()->runtime->gcNursery();
movePtr(ImmWord(-ptrdiff_t(nursery.start())), temp);
addPtr(ptr, temp);
asMasm().addPtr(ptr, temp);
branchPtr(cond == Assembler::Equal ? Assembler::Below : Assembler::AboveOrEqual,
temp, Imm32(nursery.nurserySize()), label);
}

21
js/src/jit/x86/MacroAssembler-x86.h
View File

@ -566,27 +566,6 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
// Common interface.
/////////////////////////////////////////////////////////////////
void addPtr(Register src, Register dest) {
add32(src, dest);
}
void addPtr(Imm32 imm, Register dest) {
add32(imm, dest);
}
void addPtr(ImmWord imm, Register dest) {
add32(Imm32(imm.value), dest);
}
void addPtr(ImmPtr imm, Register dest) {
addPtr(ImmWord(uintptr_t(imm.value)), dest);
}
void addPtr(Imm32 imm, const Address& dest) {
add32(imm, Operand(dest));
}
void addPtr(Imm32 imm, const Operand& dest) {
add32(imm, dest);
}
void addPtr(const Address& src, Register dest) {
addl(Operand(src), dest);
}
void add64(Imm32 imm, Register64 dest) {
addl(imm, dest.low);
adcl(Imm32(0), dest.high);