Reviewers: michael_dawson, rmcilroy,
Description:
Fix issues with Arm's use of embedded constant pools
- Handle non-instruction-aligned pc in Assembler::Align
- Fix several misuses of r8 (alias of the pool pointer register, pp)
- Fix calculation of pp in OSR/handler entry invocation
- Enable missing cases in deserializer
- Fix references to ool constant pools in comments.
[email protected], [email protected]
BUG=chromium:497180
LOG=N
Please review this at https://codereview.chromium.org/1155673005/
Base URL: https://chromium.googlesource.com/v8/v8.git@master
Affected files (+50, -23 lines):
M src/arm/assembler-arm.cc
M src/arm/assembler-arm-inl.h
M src/arm/builtins-arm.cc
M src/arm/code-stubs-arm.cc
M src/arm/frames-arm.h
M src/arm/macro-assembler-arm.cc
M src/ppc/assembler-ppc-inl.h
M src/snapshot/serialize.cc
Index: src/arm/assembler-arm-inl.h
diff --git a/src/arm/assembler-arm-inl.h b/src/arm/assembler-arm-inl.h
index
5e590a7d030d446e2bead4178b035eaf2b468ad8..28a323ab519b3d03b14719505fd6262da5e07915
100644
--- a/src/arm/assembler-arm-inl.h
+++ b/src/arm/assembler-arm-inl.h
@@ -120,8 +120,9 @@ Address RelocInfo::target_address_address() {
|| rmode_ == EXTERNAL_REFERENCE);
if (FLAG_enable_embedded_constant_pool ||
Assembler::IsMovW(Memory::int32_at(pc_))) {
- // We return the PC for ool constant pool since this function is used
by the
- // serializer and expects the address to reside within the code object.
+ // We return the PC for embedded constant pool since this function is
used
+ // by the serializer and expects the address to reside within the code
+ // object.
return reinterpret_cast<Address>(pc_);
} else {
DCHECK(Assembler::IsLdrPcImmediateOffset(Memory::int32_at(pc_)));
Index: src/arm/assembler-arm.cc
diff --git a/src/arm/assembler-arm.cc b/src/arm/assembler-arm.cc
index
ed8664a9c5f32f10ddc131ad8973e2b79cc37347..75d5699785df7aecff52269d4ec34ccd42ded24b
100644
--- a/src/arm/assembler-arm.cc
+++ b/src/arm/assembler-arm.cc
@@ -494,6 +494,11 @@ void Assembler::GetCode(CodeDesc* desc) {
void Assembler::Align(int m) {
DCHECK(m >= 4 && base::bits::IsPowerOfTwo32(m));
+ // First ensure instruction alignment
+ while (pc_offset() & (kInstrSize - 1)) {
+ db(0);
+ }
+ // Then pad to requested alignedment with nops
while ((pc_offset() & (m - 1)) != 0) {
nop();
}
Index: src/arm/builtins-arm.cc
diff --git a/src/arm/builtins-arm.cc b/src/arm/builtins-arm.cc
index
7ebef530f3ef787d8724d9d1fcfe05607e5d0345..2638033cdee6ca9477f63e528394fe17eec6e1ca
100644
--- a/src/arm/builtins-arm.cc
+++ b/src/arm/builtins-arm.cc
@@ -1166,6 +1166,8 @@ void
Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
__ ldr(r1, FieldMemOperand(r0, Code::kDeoptimizationDataOffset));
{ ConstantPoolUnavailableScope constant_pool_unavailable(masm);
+ __ add(r0, r0, Operand(Code::kHeaderSize - kHeapObjectTag)); // Code
start
+
if (FLAG_enable_embedded_constant_pool) {
__ LoadConstantPoolPointerRegisterFromCodeTargetAddress(r0);
}
@@ -1175,10 +1177,8 @@ void
Builtins::Generate_OnStackReplacement(MacroAssembler* masm) {
__ ldr(r1, FieldMemOperand(r1, FixedArray::OffsetOfElementAt(
DeoptimizationInputData::kOsrPcOffsetIndex)));
- // Compute the target address = code_obj + header_size + osr_offset
- // <entry_addr> = <code_obj> + #header_size + <osr_offset>
- __ add(r0, r0, Operand::SmiUntag(r1));
- __ add(lr, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
+ // Compute the target address = code start + osr_offset
+ __ add(lr, r0, Operand::SmiUntag(r1));
// And "return" to the OSR entry point of the function.
__ Ret();
Index: src/arm/code-stubs-arm.cc
diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc
index
ecd2082cd02cba0796870e78c90864d9e9563c12..b99ad61e5822eb46b67f1764dd34438ec64fa9f1
100644
--- a/src/arm/code-stubs-arm.cc
+++ b/src/arm/code-stubs-arm.cc
@@ -1100,10 +1100,10 @@ void CEntryStub::Generate(MacroAssembler* masm) {
__ ldr(r1, MemOperand(r1));
__ mov(r2, Operand(pending_handler_offset_address));
__ ldr(r2, MemOperand(r2));
+ __ add(r1, r1, Operand(Code::kHeaderSize - kHeapObjectTag)); // Code
start
if (FLAG_enable_embedded_constant_pool) {
__ LoadConstantPoolPointerRegisterFromCodeTargetAddress(r1);
}
- __ add(r1, r1, Operand(Code::kHeaderSize - kHeapObjectTag));
__ add(pc, r1, r2);
}
@@ -1347,13 +1347,21 @@ void InstanceofStub::Generate(MacroAssembler* masm)
{
__ ldr(map_load_offset, MemOperand(map_load_offset));
__ str(map, FieldMemOperand(map_load_offset, Cell::kValueOffset));
- __ mov(r8, map);
+ Register value_scratch = (FLAG_enable_embedded_constant_pool ? r6 :
r8);
+ if (FLAG_enable_embedded_constant_pool) {
+ __ push(value_scratch);
+ }
+
+ __ mov(value_scratch, map);
// |map_load_offset| points at the beginning of the cell. Calculate the
// field containing the map.
__ add(function, map_load_offset, Operand(Cell::kValueOffset - 1));
- __ RecordWriteField(map_load_offset, Cell::kValueOffset, r8, function,
- kLRHasNotBeenSaved, kDontSaveFPRegs,
+ __ RecordWriteField(map_load_offset, Cell::kValueOffset, value_scratch,
+ function, kLRHasNotBeenSaved, kDontSaveFPRegs,
OMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
+ if (FLAG_enable_embedded_constant_pool) {
+ __ pop(value_scratch);
+ }
}
// Register mapping: r3 is object map and r4 is function prototype.
@@ -2433,7 +2441,7 @@ static void GenerateRecordCallTarget(MacroAssembler*
masm) {
// this position in a symbol (see static asserts in
type-feedback-vector.h).
Label check_allocation_site;
Register feedback_map = r5;
- Register weak_value = r8;
+ Register weak_value = r6;
__ ldr(weak_value, FieldMemOperand(r4, WeakCell::kValueOffset));
__ cmp(r1, weak_value);
__ b(eq, &done);
@@ -4494,7 +4502,7 @@ void LoadICStub::GenerateImpl(MacroAssembler* masm,
bool in_frame) {
Register slot = LoadWithVectorDescriptor::SlotRegister(); // r0
Register feedback = r4;
Register receiver_map = r5;
- Register scratch1 = r8;
+ Register scratch1 = r6;
__ add(feedback, vector, Operand::PointerOffsetFromSmiKey(slot));
__ ldr(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize));
@@ -4551,7 +4559,7 @@ void KeyedLoadICStub::GenerateImpl(MacroAssembler*
masm, bool in_frame) {
Register slot = LoadWithVectorDescriptor::SlotRegister(); // r0
Register feedback = r4;
Register receiver_map = r5;
- Register scratch1 = r8;
+ Register scratch1 = r6;
__ add(feedback, vector, Operand::PointerOffsetFromSmiKey(slot));
__ ldr(feedback, FieldMemOperand(feedback, FixedArray::kHeaderSize));
Index: src/arm/frames-arm.h
diff --git a/src/arm/frames-arm.h b/src/arm/frames-arm.h
index
ea621c965b47e9322b7f6d0ddcb0eefb10db9c20..73d1ce1f7841c5ed8d1cf6f6ab4ded98e620a0bc
100644
--- a/src/arm/frames-arm.h
+++ b/src/arm/frames-arm.h
@@ -69,8 +69,14 @@ const int kNumSafepointRegisters = 16;
// Define the list of registers actually saved at safepoints.
// Note that the number of saved registers may be smaller than the reserved
// space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters.
-const RegList kSafepointSavedRegisters = kJSCallerSaved | kCalleeSaved;
-const int kNumSafepointSavedRegisters = kNumJSCallerSaved +
kNumCalleeSaved;
+const RegList kSafepointSavedRegisters =
+ kJSCallerSaved |
+ (FLAG_enable_embedded_constant_pool ? kCalleeSaved & ~(1 << 8)
+ : kCalleeSaved);
+const int kNumSafepointSavedRegisters =
+ kNumJSCallerSaved + (FLAG_enable_embedded_constant_pool
+ ? kNumCalleeSaved - 1
+ : kNumCalleeSaved);
// ----------------------------------------------------
Index: src/arm/macro-assembler-arm.cc
diff --git a/src/arm/macro-assembler-arm.cc b/src/arm/macro-assembler-arm.cc
index
61b59edf868c08b11cd80ef246550d679f2df753..ec964280072cfcd3e32b80449670e450536506b0
100644
--- a/src/arm/macro-assembler-arm.cc
+++ b/src/arm/macro-assembler-arm.cc
@@ -707,8 +707,10 @@ void MacroAssembler::PopFixedFrame(Register
marker_reg) {
// Push and pop all registers that can hold pointers.
void MacroAssembler::PushSafepointRegisters() {
- // Safepoints expect a block of contiguous register values starting with
r0:
- DCHECK(((1 << kNumSafepointSavedRegisters) - 1) ==
kSafepointSavedRegisters);
+ // Safepoints expect a block of contiguous register values starting with
r0.
+ // except when FLAG_enable_embedded_constant_pool, which omits pp.
+ DCHECK(FLAG_enable_embedded_constant_pool ||
+ ((1 << kNumSafepointSavedRegisters) - 1) ==
kSafepointSavedRegisters);
// Safepoints expect a block of kNumSafepointRegisters values on the
// stack, so adjust the stack for unsaved registers.
const int num_unsaved = kNumSafepointRegisters -
kNumSafepointSavedRegisters;
@@ -738,6 +740,10 @@ void
MacroAssembler::LoadFromSafepointRegisterSlot(Register dst, Register src) {
int MacroAssembler::SafepointRegisterStackIndex(int reg_code) {
// The registers are pushed starting with the highest encoding,
// which means that lowest encodings are closest to the stack pointer.
+ if (FLAG_enable_embedded_constant_pool && reg_code > pp.code()) {
+ // RegList omits pp.
+ reg_code -= 1;
+ }
DCHECK(reg_code >= 0 && reg_code < kNumSafepointRegisters);
return reg_code;
}
Index: src/ppc/assembler-ppc-inl.h
diff --git a/src/ppc/assembler-ppc-inl.h b/src/ppc/assembler-ppc-inl.h
index
14b5503a17349a7cde1d9efd9e74525121b8df4e..0e759efec16b475538a4ce7dffe409bbe8914bfe
100644
--- a/src/ppc/assembler-ppc-inl.h
+++ b/src/ppc/assembler-ppc-inl.h
@@ -96,8 +96,9 @@ Address RelocInfo::target_address_address() {
if (FLAG_enable_embedded_constant_pool &&
Assembler::IsConstantPoolLoadStart(pc_)) {
- // We return the PC for ool constant pool since this function is used
by the
- // serializer and expects the address to reside within the code object.
+ // We return the PC for embedded constant pool since this function is
used
+ // by the serializer and expects the address to reside within the code
+ // object.
return reinterpret_cast<Address>(pc_);
}
Index: src/snapshot/serialize.cc
diff --git a/src/snapshot/serialize.cc b/src/snapshot/serialize.cc
index
4be1da2c9a346f6f6f8d5acbb64837e227efe055..09c646781f5c82526ec46d4a39fc2536d73735fa
100644
--- a/src/snapshot/serialize.cc
+++ b/src/snapshot/serialize.cc
@@ -1006,15 +1006,15 @@ bool Deserializer::ReadData(Object** current,
Object** limit, int source_space,
ALL_SPACES(kBackref, kPlain, kStartOfObject)
ALL_SPACES(kBackrefWithSkip, kPlain, kStartOfObject)
#if defined(V8_TARGET_ARCH_MIPS) || defined(V8_TARGET_ARCH_MIPS64) || \
- defined(V8_TARGET_ARCH_PPC)
+ defined(V8_TARGET_ARCH_PPC) || V8_EMBEDDED_CONSTANT_POOL
// Deserialize a new object from pointer found in code and write
// a pointer to it to the current object. Required only for MIPS,
PPC or
- // ARM with ool constant pool, and omitted on the other architectures
+ // ARM with embedded constant pool, and omitted on the other
architectures
// because it is fully unrolled and would cause bloat.
ALL_SPACES(kNewObject, kFromCode, kStartOfObject)
// Find a recently deserialized code object using its offset from the
// current allocation point and write a pointer to it to the current
- // object. Required only for MIPS, PPC or ARM with ool constant pool.
+ // object. Required only for MIPS, PPC or ARM with embedded constant
pool.
ALL_SPACES(kBackref, kFromCode, kStartOfObject)
ALL_SPACES(kBackrefWithSkip, kFromCode, kStartOfObject)
#endif
@@ -1031,7 +1031,7 @@ bool Deserializer::ReadData(Object** current,
Object** limit, int source_space,
CASE_STATEMENT(kRootArray, kPlain, kStartOfObject, 0)
CASE_BODY(kRootArray, kPlain, kStartOfObject, 0)
#if defined(V8_TARGET_ARCH_MIPS) || defined(V8_TARGET_ARCH_MIPS64) || \
- defined(V8_TARGET_ARCH_PPC)
+ defined(V8_TARGET_ARCH_PPC) || V8_EMBEDDED_CONSTANT_POOL
// Find an object in the roots array and write a pointer to it to in
code.
CASE_STATEMENT(kRootArray, kFromCode, kStartOfObject, 0)
CASE_BODY(kRootArray, kFromCode, kStartOfObject, 0)
--
--
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/d/optout.
