// Fill in the input registers.
for (int i = kNumberOfRegisters -1; i >= 0; i--) {
int offset = (i * kPointerSize) + FrameDescription::registers_offset();
- __ Pop(Operand(rbx, offset));
+ __ PopQuad(Operand(rbx, offset));
}
// Fill in the double input registers.
// Push state, pc, and continuation from the last output frame.
__ Push(Operand(rbx, FrameDescription::state_offset()));
- __ Push(Operand(rbx, FrameDescription::pc_offset()));
- __ Push(Operand(rbx, FrameDescription::continuation_offset()));
+ __ PushQuad(Operand(rbx, FrameDescription::pc_offset()));
+ __ PushQuad(Operand(rbx, FrameDescription::continuation_offset()));
// Push the registers from the last output frame.
for (int i = 0; i < kNumberOfRegisters; i++) {
int offset = (i * kPointerSize) + FrameDescription::registers_offset();
- __ Push(Operand(rbx, offset));
+ __ PushQuad(Operand(rbx, offset));
}
// Restore the registers from the stack.
void FrameDescription::SetCallerPc(unsigned offset, intptr_t value) {
+ if (kPCOnStackSize == 2 * kPointerSize) {
+ // Zero out the high-32 bit of PC for x32 port.
+ SetFrameSlot(offset + kPointerSize, 0);
+ }
SetFrameSlot(offset, value);
}
void FrameDescription::SetCallerFp(unsigned offset, intptr_t value) {
+ if (kFPOnStackSize == 2 * kPointerSize) {
+ // Zero out the high-32 bit of FP for x32 port.
+ SetFrameSlot(offset + kPointerSize, 0);
+ }
SetFrameSlot(offset, value);
}
movp(dst, kScratchRegister);
}
} else {
- ASSERT(kPointerSize == kInt32Size);
movp(dst, Immediate(static_cast<int32_t>(x)));
}
}
if (kPointerSize == kInt64Size) {
pushq(src);
} else {
- ASSERT(kPointerSize == kInt32Size);
// x32 uses 64-bit push for rbp in the prologue.
ASSERT(src.code() != rbp.code());
leal(rsp, Operand(rsp, -4));
if (kPointerSize == kInt64Size) {
pushq(src);
} else {
- ASSERT(kPointerSize == kInt32Size);
movp(kScratchRegister, src);
leal(rsp, Operand(rsp, -4));
movp(Operand(rsp, 0), kScratchRegister);
}
+void MacroAssembler::PushQuad(const Operand& src) {
+ if (kPointerSize == kInt64Size) {
+ pushq(src);
+ } else {
+ movp(kScratchRegister, src);
+ pushq(kScratchRegister);
+ }
+}
+
+
void MacroAssembler::Push(Immediate value) {
if (kPointerSize == kInt64Size) {
pushq(value);
} else {
- ASSERT(kPointerSize == kInt32Size);
leal(rsp, Operand(rsp, -4));
movp(Operand(rsp, 0), value);
}
if (kPointerSize == kInt64Size) {
pushq_imm32(imm32);
} else {
- ASSERT(kPointerSize == kInt32Size);
leal(rsp, Operand(rsp, -4));
movp(Operand(rsp, 0), Immediate(imm32));
}
if (kPointerSize == kInt64Size) {
popq(dst);
} else {
- ASSERT(kPointerSize == kInt32Size);
// x32 uses 64-bit pop for rbp in the epilogue.
ASSERT(dst.code() != rbp.code());
movp(dst, Operand(rsp, 0));
if (kPointerSize == kInt64Size) {
popq(dst);
} else {
- ASSERT(kPointerSize == kInt32Size);
Register scratch = dst.AddressUsesRegister(kScratchRegister)
? kSmiConstantRegister : kScratchRegister;
movp(scratch, Operand(rsp, 0));
}
+void MacroAssembler::PopQuad(const Operand& dst) {
+ if (kPointerSize == kInt64Size) {
+ popq(dst);
+ } else {
+ popq(kScratchRegister);
+ movp(dst, kScratchRegister);
+ }
+}
+
+
void MacroAssembler::LoadSharedFunctionInfoSpecialField(Register dst,
Register base,
int offset) {
if (kPointerSize == kInt64Size) {
jmp(op);
} else {
- ASSERT(kPointerSize == kInt32Size);
movp(kScratchRegister, op);
jmp(kScratchRegister);
}
if (kPointerSize == kInt64Size) {
call(op);
} else {
- ASSERT(kPointerSize == kInt32Size);
movp(kScratchRegister, op);
call(kScratchRegister);
}