wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1010775 part 6 - Pass AbsoluteAddress and PatchedAbsoluteAddress by value instead of const-ref. r=sunfish

Browse Source
This commit is contained in:
Jan de Mooij 2014-05-15 17:42:38 +02:00
parent 042e72a91d
commit b3c3e4ed2a
9 changed files with 52 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2159,7 +2159,7 @@ MacroAssemblerARMCompat::load32(const BaseIndex &address, Register dest)
}
void
MacroAssemblerARMCompat::load32(const AbsoluteAddress &address, Register dest)
MacroAssemblerARMCompat::load32(AbsoluteAddress address, Register dest)
{
loadPtr(address, dest);
}
@ -2183,7 +2183,7 @@ MacroAssemblerARMCompat::loadPtr(const BaseIndex &src, Register dest)
ma_ldr(DTRAddr(base, DtrRegImmShift(src.index, LSL, scale)), dest);
}
void
MacroAssemblerARMCompat::loadPtr(const AbsoluteAddress &address, Register dest)
MacroAssemblerARMCompat::loadPtr(AbsoluteAddress address, Register dest)
{
movePtr(ImmWord(uintptr_t(address.addr)), ScratchRegister);
loadPtr(Address(ScratchRegister, 0x0), dest);
@ -2342,7 +2342,7 @@ MacroAssemblerARMCompat::store16(Register src, const BaseIndex &address)
ma_strh(src, EDtrAddr(address.base, EDtrOffReg(index)));
}
void
MacroAssemblerARMCompat::store32(Register src, const AbsoluteAddress &address)
MacroAssemblerARMCompat::store32(Register src, AbsoluteAddress address)
{
storePtr(src, address);
}
@ -2407,7 +2407,7 @@ MacroAssemblerARMCompat::storePtr(Register src, const Address &address)
}
void
MacroAssemblerARMCompat::storePtr(Register src, const AbsoluteAddress &dest)
MacroAssemblerARMCompat::storePtr(Register src, AbsoluteAddress dest)
{
movePtr(ImmWord(uintptr_t(dest.addr)), ScratchRegister);
storePtr(src, Address(ScratchRegister, 0x0));

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

@ -1057,7 +1057,7 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
void branchPtr(Condition cond, Address addr, ImmPtr ptr, Label *label) {
branchPtr(cond, addr, ImmWord(uintptr_t(ptr.value)), label);
}
void branchPtr(Condition cond, const AbsoluteAddress &addr, Register ptr, Label *label) {
void branchPtr(Condition cond, AbsoluteAddress addr, Register ptr, Label *label) {
loadPtr(addr, ScratchRegister);
ma_cmp(ScratchRegister, ptr);
ma_b(label, cond);
@ -1067,12 +1067,12 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
ma_cmp(ScratchRegister, ptr);
ma_b(label, cond);
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Imm32 rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Imm32 rhs, Label *label) {
loadPtr(lhs, secondScratchReg_); // ma_cmp will use the scratch register.
ma_cmp(secondScratchReg_, rhs);
ma_b(label, cond);
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Register rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
loadPtr(lhs, secondScratchReg_); // ma_cmp will use the scratch register.
ma_cmp(secondScratchReg_, rhs);
ma_b(label, cond);
@ -1331,11 +1331,11 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
void load32(const Address &address, Register dest);
void load32(const BaseIndex &address, Register dest);
void load32(const AbsoluteAddress &address, Register dest);
void load32(AbsoluteAddress address, Register dest);
void loadPtr(const Address &address, Register dest);
void loadPtr(const BaseIndex &src, Register dest);
void loadPtr(const AbsoluteAddress &address, Register dest);
void loadPtr(AbsoluteAddress address, Register dest);
void loadPtr(const AsmJSAbsoluteAddress &address, Register dest);
void loadPrivate(const Address &address, Register dest);
@ -1360,7 +1360,7 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
void store16(Register src, const BaseIndex &address);
void store16(Imm32 imm, const BaseIndex &address);
void store32(Register src, const AbsoluteAddress &address);
void store32(Register src, AbsoluteAddress address);
void store32(Register src, const Address &address);
void store32(Register src, const BaseIndex &address);
void store32(Imm32 src, const Address &address);
@ -1370,7 +1370,7 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
void storePtr(ImmPtr imm, const Address &address);
void storePtr(ImmGCPtr imm, const Address &address);
void storePtr(Register src, const Address &address);
void storePtr(Register src, const AbsoluteAddress &dest);
void storePtr(Register src, AbsoluteAddress dest);
void storeDouble(FloatRegister src, Address addr) {
ma_vstr(src, Operand(addr));
}

8
js/src/jit/mips/MacroAssembler-mips.cpp
View File

@ -1838,7 +1838,7 @@ MacroAssemblerMIPSCompat::load32(const BaseIndex &address, Register dest)
}
void
MacroAssemblerMIPSCompat::load32(const AbsoluteAddress &address, Register dest)
MacroAssemblerMIPSCompat::load32(AbsoluteAddress address, Register dest)
{
ma_li(ScratchRegister, Imm32((uint32_t)address.addr));
as_lw(dest, ScratchRegister, 0);
@ -1857,7 +1857,7 @@ MacroAssemblerMIPSCompat::loadPtr(const BaseIndex &src, Register dest)
}
void
MacroAssemblerMIPSCompat::loadPtr(const AbsoluteAddress &address, Register dest)
MacroAssemblerMIPSCompat::loadPtr(AbsoluteAddress address, Register dest)
{
ma_li(ScratchRegister, Imm32((uint32_t)address.addr));
as_lw(dest, ScratchRegister, 0);
@ -1966,7 +1966,7 @@ MacroAssemblerMIPSCompat::store16(Register src, const BaseIndex &address)
}
void
MacroAssemblerMIPSCompat::store32(Register src, const AbsoluteAddress &address)
MacroAssemblerMIPSCompat::store32(Register src, AbsoluteAddress address)
{
storePtr(src, address);
}
@ -2023,7 +2023,7 @@ MacroAssemblerMIPSCompat::storePtr(Register src, const Address &address)
}
void
MacroAssemblerMIPSCompat::storePtr(Register src, const AbsoluteAddress &dest)
MacroAssemblerMIPSCompat::storePtr(Register src, AbsoluteAddress dest)
{
ma_li(ScratchRegister, Imm32((uint32_t)dest.addr));
as_sw(src, ScratchRegister, 0);

14
js/src/jit/mips/MacroAssembler-mips.h
View File

@ -783,7 +783,7 @@ public:
void branchPtr(Condition cond, Address addr, ImmPtr ptr, Label *label) {
branchPtr(cond, addr, ImmWord(uintptr_t(ptr.value)), label);
}
void branchPtr(Condition cond, const AbsoluteAddress &addr, Register ptr, Label *label) {
void branchPtr(Condition cond, AbsoluteAddress addr, Register ptr, Label *label) {
loadPtr(addr, ScratchRegister);
ma_b(ScratchRegister, ptr, label, cond);
}
@ -792,11 +792,11 @@ public:
loadPtr(addr, ScratchRegister);
ma_b(ScratchRegister, ptr, label, cond);
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Imm32 rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Imm32 rhs, Label *label) {
loadPtr(lhs, SecondScratchReg); // ma_b might use scratch
ma_b(SecondScratchReg, rhs, label, cond);
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Register rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
loadPtr(lhs, ScratchRegister);
ma_b(ScratchRegister, rhs, label, cond);
}
@ -1043,11 +1043,11 @@ public:
void load32(const Address &address, Register dest);
void load32(const BaseIndex &address, Register dest);
void load32(const AbsoluteAddress &address, Register dest);
void load32(AbsoluteAddress address, Register dest);
void loadPtr(const Address &address, Register dest);
void loadPtr(const BaseIndex &src, Register dest);
void loadPtr(const AbsoluteAddress &address, Register dest);
void loadPtr(AbsoluteAddress address, Register dest);
void loadPtr(const AsmJSAbsoluteAddress &address, Register dest);
void loadPrivate(const Address &address, Register dest);
@ -1072,7 +1072,7 @@ public:
void store16(Register src, const BaseIndex &address);
void store16(Imm32 imm, const BaseIndex &address);
void store32(Register src, const AbsoluteAddress &address);
void store32(Register src, AbsoluteAddress address);
void store32(Register src, const Address &address);
void store32(Register src, const BaseIndex &address);
void store32(Imm32 src, const Address &address);
@ -1082,7 +1082,7 @@ public:
void storePtr(ImmPtr imm, const Address &address);
void storePtr(ImmGCPtr imm, const Address &address);
void storePtr(Register src, const Address &address);
void storePtr(Register src, const AbsoluteAddress &dest);
void storePtr(Register src, AbsoluteAddress dest);
void storeDouble(FloatRegister src, Address addr) {
ma_sd(src, addr);
}

6
js/src/jit/shared/Assembler-shared.h
View File

@ -210,7 +210,8 @@ struct ImmMaybeNurseryPtr : public ImmGCPtr
// Pointer to be embedded as an immediate that is loaded/stored from by an
// instruction.
struct AbsoluteAddress {
struct AbsoluteAddress
{
void *addr;
explicit AbsoluteAddress(const void *addr)
@ -228,7 +229,8 @@ struct AbsoluteAddress {
// The same as AbsoluteAddress except that the intention is to patch this
// instruction. The initial value of the immediate is 'addr' and this value is
// either clobbered or used in the patching process.
struct PatchedAbsoluteAddress {
struct PatchedAbsoluteAddress
{
void *addr;
explicit PatchedAbsoluteAddress()

2
js/src/jit/shared/Assembler-x86-shared.h
View File

@ -66,7 +66,7 @@ class Operand
base_(reg.code()),
disp_(disp)
{ }
explicit Operand(const AbsoluteAddress &address)
explicit Operand(AbsoluteAddress address)
: kind_(MEM_ADDRESS32),
disp_(JSC::X86Assembler::addressImmediate(address.addr))
{ }

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

@ -573,7 +573,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
subq(src, Operand(dest));
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Imm32 rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Imm32 rhs, Label *label) {
if (JSC::X86Assembler::isAddressImmediate(lhs.addr)) {
branch32(cond, Operand(lhs), rhs, label);
} else {
@ -581,7 +581,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
branch32(cond, Address(ScratchReg, 0), rhs, label);
}
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Register rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
if (JSC::X86Assembler::isAddressImmediate(lhs.addr)) {
branch32(cond, Operand(lhs), rhs, label);
} else {
@ -591,7 +591,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
}
// Specialization for AbsoluteAddress.
void branchPtr(Condition cond, const AbsoluteAddress &addr, Register ptr, Label *label) {
void branchPtr(Condition cond, AbsoluteAddress addr, Register ptr, Label *label) {
JS_ASSERT(ptr != ScratchReg);
if (JSC::X86Assembler::isAddressImmediate(addr.addr)) {
branchPtr(cond, Operand(addr), ptr, label);
@ -677,7 +677,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
void movePtr(ImmGCPtr imm, Register dest) {
movq(imm, dest);
}
void loadPtr(const AbsoluteAddress &address, Register dest) {
void loadPtr(AbsoluteAddress address, Register dest) {
if (JSC::X86Assembler::isAddressImmediate(address.addr)) {
movq(Operand(address), dest);
} else {
@ -698,7 +698,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
loadPtr(src, dest);
shlq(Imm32(1), dest);
}
void load32(const AbsoluteAddress &address, Register dest) {
void load32(AbsoluteAddress address, Register dest) {
if (JSC::X86Assembler::isAddressImmediate(address.addr)) {
movl(Operand(address), dest);
} else {
@ -727,7 +727,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
void storePtr(Register src, const Operand &dest) {
movq(src, dest);
}
void storePtr(Register src, const AbsoluteAddress &address) {
void storePtr(Register src, AbsoluteAddress address) {
if (JSC::X86Assembler::isAddressImmediate(address.addr)) {
movq(src, Operand(address));
} else {
@ -735,7 +735,7 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
storePtr(src, Address(ScratchReg, 0x0));
}
}
void store32(Register src, const AbsoluteAddress &address) {
void store32(Register src, AbsoluteAddress address) {
if (JSC::X86Assembler::isAddressImmediate(address.addr)) {
movl(src, Operand(address));
} else {

24
js/src/jit/x86/Assembler-x86.h
View File

@ -487,56 +487,56 @@ class Assembler : public AssemblerX86Shared
}
// Load from *src where src can be patched.
CodeOffsetLabel movsblWithPatch(const PatchedAbsoluteAddress &src, Register dest) {
CodeOffsetLabel movsblWithPatch(PatchedAbsoluteAddress src, Register dest) {
masm.movsbl_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movzblWithPatch(const PatchedAbsoluteAddress &src, Register dest) {
CodeOffsetLabel movzblWithPatch(PatchedAbsoluteAddress src, Register dest) {
masm.movzbl_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movswlWithPatch(const PatchedAbsoluteAddress &src, Register dest) {
CodeOffsetLabel movswlWithPatch(PatchedAbsoluteAddress src, Register dest) {
masm.movswl_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movzwlWithPatch(const PatchedAbsoluteAddress &src, Register dest) {
CodeOffsetLabel movzwlWithPatch(PatchedAbsoluteAddress src, Register dest) {
masm.movzwl_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movlWithPatch(const PatchedAbsoluteAddress &src, Register dest) {
CodeOffsetLabel movlWithPatch(PatchedAbsoluteAddress src, Register dest) {
masm.movl_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movssWithPatch(const PatchedAbsoluteAddress &src, FloatRegister dest) {
CodeOffsetLabel movssWithPatch(PatchedAbsoluteAddress src, FloatRegister dest) {
JS_ASSERT(HasSSE2());
masm.movss_mr(src.addr, dest.code());
return masm.currentOffset();
}
CodeOffsetLabel movsdWithPatch(const PatchedAbsoluteAddress &src, FloatRegister dest) {
CodeOffsetLabel movsdWithPatch(PatchedAbsoluteAddress src, FloatRegister dest) {
JS_ASSERT(HasSSE2());
masm.movsd_mr(src.addr, dest.code());
return masm.currentOffset();
}
// Store to *dest where dest can be patched.
CodeOffsetLabel movbWithPatch(Register src, const PatchedAbsoluteAddress &dest) {
CodeOffsetLabel movbWithPatch(Register src, PatchedAbsoluteAddress dest) {
masm.movb_rm(src.code(), dest.addr);
return masm.currentOffset();
}
CodeOffsetLabel movwWithPatch(Register src, const PatchedAbsoluteAddress &dest) {
CodeOffsetLabel movwWithPatch(Register src, PatchedAbsoluteAddress dest) {
masm.movw_rm(src.code(), dest.addr);
return masm.currentOffset();
}
CodeOffsetLabel movlWithPatch(Register src, const PatchedAbsoluteAddress &dest) {
CodeOffsetLabel movlWithPatch(Register src, PatchedAbsoluteAddress dest) {
masm.movl_rm(src.code(), dest.addr);
return masm.currentOffset();
}
CodeOffsetLabel movssWithPatch(FloatRegister src, const PatchedAbsoluteAddress &dest) {
CodeOffsetLabel movssWithPatch(FloatRegister src, PatchedAbsoluteAddress dest) {
JS_ASSERT(HasSSE2());
masm.movss_rm(src.code(), dest.addr);
return masm.currentOffset();
}
CodeOffsetLabel movsdWithPatch(FloatRegister src, const PatchedAbsoluteAddress &dest) {
CodeOffsetLabel movsdWithPatch(FloatRegister src, PatchedAbsoluteAddress dest) {
JS_ASSERT(HasSSE2());
masm.movsd_rm(src.code(), dest.addr);
return masm.currentOffset();

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

@ -582,11 +582,11 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
subl(src, Operand(dest));
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Imm32 rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Imm32 rhs, Label *label) {
cmpl(Operand(lhs), rhs);
j(cond, label);
}
void branch32(Condition cond, const AbsoluteAddress &lhs, Register rhs, Label *label) {
void branch32(Condition cond, AbsoluteAddress lhs, Register rhs, Label *label) {
cmpl(Operand(lhs), rhs);
j(cond, label);
}
@ -678,13 +678,13 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
void loadPtr(const BaseIndex &src, Register dest) {
movl(Operand(src), dest);
}
void loadPtr(const AbsoluteAddress &address, Register dest) {
void loadPtr(AbsoluteAddress address, Register dest) {
movl(Operand(address), dest);
}
void loadPrivate(const Address &src, Register dest) {
movl(payloadOf(src), dest);
}
void load32(const AbsoluteAddress &address, Register dest) {
void load32(AbsoluteAddress address, Register dest) {
movl(Operand(address), dest);
}
void storePtr(ImmWord imm, const Address &address) {
@ -702,10 +702,10 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
void storePtr(Register src, const Operand &dest) {
movl(src, dest);
}
void storePtr(Register src, const AbsoluteAddress &address) {
void storePtr(Register src, AbsoluteAddress address) {
movl(src, Operand(address));
}
void store32(Register src, const AbsoluteAddress &address) {
void store32(Register src, AbsoluteAddress address) {
movl(src, Operand(address));
}