Revision: 16061
Author: [email protected]
Date: Mon Aug 5 17:09:01 2013
Log: Make some constants' meaning clear for X64
[email protected]
Review URL: https://codereview.chromium.org/21721002
http://code.google.com/p/v8/source/detail?r=16061
Modified:
/branches/bleeding_edge/src/x64/assembler-x64-inl.h
/branches/bleeding_edge/src/x64/assembler-x64.cc
/branches/bleeding_edge/src/x64/assembler-x64.h
/branches/bleeding_edge/src/x64/debug-x64.cc
/branches/bleeding_edge/src/x64/deoptimizer-x64.cc
/branches/bleeding_edge/src/x64/macro-assembler-x64.cc
/branches/bleeding_edge/src/x64/macro-assembler-x64.h
=======================================
--- /branches/bleeding_edge/src/x64/assembler-x64-inl.h Wed Jul 24 06:50:45
2013
+++ /branches/bleeding_edge/src/x64/assembler-x64-inl.h Mon Aug 5 17:09:01
2013
@@ -373,13 +373,14 @@
bool RelocInfo::IsPatchedReturnSequence() {
// The recognized call sequence is:
- // movq(kScratchRegister, immediate64); call(kScratchRegister);
+ // movq(kScratchRegister, address); call(kScratchRegister);
// It only needs to be distinguished from a return sequence
// movq(rsp, rbp); pop(rbp); ret(n); int3 *6
// The 11th byte is int3 (0xCC) in the return sequence and
// REX.WB (0x48+register bit) for the call sequence.
#ifdef ENABLE_DEBUGGER_SUPPORT
- return pc_[2 + kPointerSize] != 0xCC;
+ return
pc_[Assembler::kMoveAddressIntoScratchRegisterInstructionLength] !=
+ 0xCC;
#else
return false;
#endif
=======================================
--- /branches/bleeding_edge/src/x64/assembler-x64.cc Wed Jul 24 06:50:45
2013
+++ /branches/bleeding_edge/src/x64/assembler-x64.cc Mon Aug 5 17:09:01
2013
@@ -164,10 +164,7 @@
// Patch the code at the current PC with a call to the target address.
// Additional guard int3 instructions can be added if required.
void RelocInfo::PatchCodeWithCall(Address target, int guard_bytes) {
- // Load register with immediate 64 and call through a register
instructions
- // takes up 13 bytes and int3 takes up one byte.
- static const int kCallCodeSize = 13;
- int code_size = kCallCodeSize + guard_bytes;
+ int code_size = Assembler::kCallSequenceLength + guard_bytes;
// Create a code patcher.
CodePatcher patcher(pc_, code_size);
@@ -183,7 +180,7 @@
patcher.masm()->call(r10);
// Check that the size of the code generated is as expected.
- ASSERT_EQ(kCallCodeSize,
+ ASSERT_EQ(Assembler::kCallSequenceLength,
patcher.masm()->SizeOfCodeGeneratedSince(&check_codesize));
// Add the requested number of int3 instructions after the call.
=======================================
--- /branches/bleeding_edge/src/x64/assembler-x64.h Wed Jul 24 06:50:45 2013
+++ /branches/bleeding_edge/src/x64/assembler-x64.h Mon Aug 5 17:09:01 2013
@@ -579,29 +579,36 @@
// Distance between the address of the code target in the call
instruction
// and the return address pushed on the stack.
static const int kCallTargetAddressOffset = 4; // Use 32-bit
displacement.
- // Distance between the start of the JS return sequence and where the
- // 32-bit displacement of a near call would be, relative to the pushed
- // return address. TODO: Use return sequence length instead.
- // Should equal Debug::kX64JSReturnSequenceLength -
kCallTargetAddressOffset;
- static const int kPatchReturnSequenceAddressOffset = 13 - 4;
- // Distance between start of patched debug break slot and where the
- // 32-bit displacement of a near call would be, relative to the pushed
- // return address. TODO: Use return sequence length instead.
- // Should equal Debug::kX64JSReturnSequenceLength -
kCallTargetAddressOffset;
- static const int kPatchDebugBreakSlotAddressOffset = 13 - 4;
- // TODO(X64): Rename this, removing the "Real", after changing the above.
- static const int kRealPatchReturnSequenceAddressOffset = 2;
+ // The length of call(kScratchRegister).
+ static const int kCallScratchRegisterInstructionLength = 3;
+ // The length of call(Immediate32).
+ static const int kShortCallInstructionLength = 5;
+ // The length of movq(kScratchRegister, address).
+ static const int kMoveAddressIntoScratchRegisterInstructionLength =
+ 2 + kPointerSize;
+ // The length of movq(kScratchRegister, address) and
call(kScratchRegister).
+ static const int kCallSequenceLength =
+ kMoveAddressIntoScratchRegisterInstructionLength +
+ kCallScratchRegisterInstructionLength;
- // Some x64 JS code is padded with int3 to make it large
+ // The js return and debug break slot must be able to contain an indirect
+ // call sequence, some x64 JS code is padded with int3 to make it large
// enough to hold an instruction when the debugger patches it.
- static const int kJumpInstructionLength = 13;
- static const int kCallInstructionLength = 13;
- static const int kJSReturnSequenceLength = 13;
- static const int kShortCallInstructionLength = 5;
- static const int kPatchDebugBreakSlotReturnOffset = 4;
-
- // The debug break slot must be able to contain a call instruction.
- static const int kDebugBreakSlotLength = kCallInstructionLength;
+ static const int kJSReturnSequenceLength = kCallSequenceLength;
+ static const int kDebugBreakSlotLength = kCallSequenceLength;
+ static const int kPatchDebugBreakSlotReturnOffset =
kCallTargetAddressOffset;
+ // Distance between the start of the JS return sequence and where the
+ // 32-bit displacement of a short call would be. The short call is from
+ // SetDebugBreakAtIC from debug-x64.cc.
+ static const int kPatchReturnSequenceAddressOffset =
+ kJSReturnSequenceLength - kPatchDebugBreakSlotReturnOffset;
+ // Distance between the start of the JS return sequence and where the
+ // 32-bit displacement of a short call would be. The short call is from
+ // SetDebugBreakAtIC from debug-x64.cc.
+ static const int kPatchDebugBreakSlotAddressOffset =
+ kDebugBreakSlotLength - kPatchDebugBreakSlotReturnOffset;
+ static const int kRealPatchReturnSequenceAddressOffset =
+ kMoveAddressIntoScratchRegisterInstructionLength - kPointerSize;
// One byte opcode for test eax,0xXXXXXXXX.
static const byte kTestEaxByte = 0xA9;
=======================================
--- /branches/bleeding_edge/src/x64/debug-x64.cc Fri Jun 28 08:34:48 2013
+++ /branches/bleeding_edge/src/x64/debug-x64.cc Mon Aug 5 17:09:01 2013
@@ -48,11 +48,10 @@
// CodeGenerator::VisitReturnStatement and VirtualFrame::Exit in
codegen-x64.cc
// for the precise return instructions sequence.
void BreakLocationIterator::SetDebugBreakAtReturn() {
- ASSERT(Assembler::kJSReturnSequenceLength >=
- Assembler::kCallInstructionLength);
+ ASSERT(Assembler::kJSReturnSequenceLength >=
Assembler::kCallSequenceLength);
rinfo()->PatchCodeWithCall(
Isolate::Current()->debug()->debug_break_return()->entry(),
- Assembler::kJSReturnSequenceLength -
Assembler::kCallInstructionLength);
+ Assembler::kJSReturnSequenceLength - Assembler::kCallSequenceLength);
}
@@ -82,7 +81,7 @@
ASSERT(IsDebugBreakSlot());
rinfo()->PatchCodeWithCall(
Isolate::Current()->debug()->debug_break_slot()->entry(),
- Assembler::kDebugBreakSlotLength -
Assembler::kCallInstructionLength);
+ Assembler::kDebugBreakSlotLength - Assembler::kCallSequenceLength);
}
=======================================
--- /branches/bleeding_edge/src/x64/deoptimizer-x64.cc Wed Jul 24 04:12:17
2013
+++ /branches/bleeding_edge/src/x64/deoptimizer-x64.cc Mon Aug 5 17:09:01
2013
@@ -42,7 +42,7 @@
int Deoptimizer::patch_size() {
- return Assembler::kCallInstructionLength;
+ return Assembler::kCallSequenceLength;
}
@@ -69,7 +69,7 @@
Address call_address = instruction_start + deopt_data->Pc(i)->value();
// There is room enough to write a long call instruction because we pad
// LLazyBailout instructions with nops if necessary.
- CodePatcher patcher(call_address, Assembler::kCallInstructionLength);
+ CodePatcher patcher(call_address, Assembler::kCallSequenceLength);
patcher.masm()->Call(GetDeoptimizationEntry(isolate, i, LAZY),
RelocInfo::NONE64);
ASSERT(prev_call_address == NULL ||
=======================================
--- /branches/bleeding_edge/src/x64/macro-assembler-x64.cc Fri Aug 2
06:42:02 2013
+++ /branches/bleeding_edge/src/x64/macro-assembler-x64.cc Mon Aug 5
17:09:01 2013
@@ -155,7 +155,7 @@
}
}
// Size of movq(destination, src);
- return 10;
+ return Assembler::kMoveAddressIntoScratchRegisterInstructionLength;
}
@@ -2511,8 +2511,8 @@
int MacroAssembler::CallSize(ExternalReference ext) {
// Opcode for call kScratchRegister is: Rex.B FF D4 (three bytes).
- const int kCallInstructionSize = 3;
- return LoadAddressSize(ext) + kCallInstructionSize;
+ return LoadAddressSize(ext) +
+ Assembler::kCallScratchRegisterInstructionLength;
}
=======================================
--- /branches/bleeding_edge/src/x64/macro-assembler-x64.h Mon Aug 5
05:43:04 2013
+++ /branches/bleeding_edge/src/x64/macro-assembler-x64.h Mon Aug 5
17:09:01 2013
@@ -841,7 +841,7 @@
// The size of the code generated for different call instructions.
int CallSize(Address destination, RelocInfo::Mode rmode) {
- return kCallInstructionLength;
+ return kCallSequenceLength;
}
int CallSize(ExternalReference ext);
int CallSize(Handle<Code> code_object) {
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/groups/opt_out.
