Embedded constant pools.

src/arm/full-codegen-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #if V8_TARGET_ARCH_ARM
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 78 matching lines @@
 
 
 // Generate code for a JS function.  On entry to the function the receiver
 // and arguments have been pushed on the stack left to right.  The actual
 // argument count matches the formal parameter count expected by the
 // function.
 //
 // The live registers are:
 //   o r1: the JS function object being called (i.e., ourselves)
 //   o cp: our context
-//   o pp: our caller's constant pool pointer (if FLAG_enable_ool_constant_pool)
+//   o pp: our caller's constant pool pointer (if enabled)
 //   o fp: our caller's frame pointer
 //   o sp: stack pointer
 //   o lr: return address
 //
 // The function builds a JS frame.  Please see JavaScriptFrameConstants in
 // frames-arm.h for its layout.
 void FullCodeGenerator::Generate() {
   CompilationInfo* info = info_;
   handler_table_ =
       Handle<HandlerTable>::cast(isolate()->factory()->NewFixedArray(
@@ skipping 241 matching lines @@
     }
   }
 
   // Always emit a 'return undefined' in case control fell off the end of
   // the body.
   { Comment cmnt(masm_, "[ return <undefined>;");
     __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
   }
   EmitReturnSequence();
 
-  // Force emit the constant pool, so it doesn't get emitted in the middle
-  // of the back edge table.
-  masm()->CheckConstPool(true, false);
+  if (FLAG_enable_embedded_constant_pool) {
+    masm()->EmitConstantPool();

[rmcilroy, 2015/05/20 14:32:10]

Should we be emitting this here if we are also emitting it in
Assembler::GetCode?

[MTBrandyberry, 2015/05/20 22:28:21]

Currently, the embedded constant pool is emitted immediately following the
instructions but prior to any other tables (e.g. safepoint, back-edge).  The
intent was to keep the constant pool related logic together and have the
constant pool area immediately follow code in the disassembly.  I'll concede
that there is no strict reason for this ordering.  (Note, however, that the
constant pool builder is smart enough to emit the table only on the first
invocation).

Let me know if this is a significant issue and I will modify it to emit at the
end.

[rmcilroy, 2015/05/22 12:21:21]

I think this would be better right at the end just before the relocinfo (which
is what describes the constant pool anyway). I don't think this should make the
disassembly any more complex, but if it does let me know and I'll re-evaluate.

[MTBrandyberry, 2015/05/26 19:19:05]

Acknowledged.

+  } else {
+    // Force emit the constant pool, so it doesn't get emitted in the middle
+    // of the back edge table.
+    masm()->CheckConstPool(true, false);
+  }
 }
 
 
 void FullCodeGenerator::ClearAccumulator() {
   __ mov(r0, Operand(Smi::FromInt(0)));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
   __ mov(r2, Operand(profiling_counter_));
@@ skipping 1903 matching lines @@
 
   // Enter a new JavaScript frame, and initialize its slots as they were when
   // the generator was suspended.
   Label resume_frame, done;
   __ bind(&push_frame);
   __ bl(&resume_frame);
   __ jmp(&done);
   __ bind(&resume_frame);
   // lr = return address.
   // fp = caller's frame pointer.
-  // pp = caller's constant pool (if FLAG_enable_ool_constant_pool),
+  // pp = caller's constant pool (if FLAG_enable_embedded_constant_pool),
   // cp = callee's context,
   // r4 = callee's JS function.
   __ PushFixedFrame(r4);
   // Adjust FP to point to saved FP.
   __ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
 
   // Load the operand stack size.
   __ ldr(r3, FieldMemOperand(r1, JSGeneratorObject::kOperandStackOffset));
   __ ldr(r3, FieldMemOperand(r3, FixedArray::kLengthOffset));
   __ SmiUntag(r3);
 
   // If we are sending a value and there is no operand stack, we can jump back
   // in directly.
   if (resume_mode == JSGeneratorObject::NEXT) {
     Label slow_resume;
     __ cmp(r3, Operand(0));
     __ b(ne, &slow_resume);
     __ ldr(r3, FieldMemOperand(r4, JSFunction::kCodeEntryOffset));
 
     { ConstantPoolUnavailableScope constant_pool_unavailable(masm_);
-      if (FLAG_enable_ool_constant_pool) {
+      if (FLAG_enable_embedded_constant_pool) {
         // Load the new code object's constant pool pointer.
-        __ ldr(pp,
-               MemOperand(r3, Code::kConstantPoolOffset - Code::kHeaderSize));
+        __ LoadTargetConstantPoolPointerRegister(r3);
       }
 
       __ ldr(r2, FieldMemOperand(r1, JSGeneratorObject::kContinuationOffset));
       __ SmiUntag(r2);
       __ add(r3, r3, r2);
       __ mov(r2, Operand(Smi::FromInt(JSGeneratorObject::kGeneratorExecuting)));
       __ str(r2, FieldMemOperand(r1, JSGeneratorObject::kContinuationOffset));
       __ Jump(r3);
     }
     __ bind(&slow_resume);
@@ skipping 3046 matching lines @@
   __ SmiUntag(r1);
   __ add(pc, r1, Operand(masm_->CodeObject()));
 }
 
 
 #undef __
 
 
 static Address GetInterruptImmediateLoadAddress(Address pc) {
   Address load_address = pc - 2 * Assembler::kInstrSize;
-  if (!FLAG_enable_ool_constant_pool) {
+  if (!FLAG_enable_embedded_constant_pool) {
     DCHECK(Assembler::IsLdrPcImmediateOffset(Memory::int32_at(load_address)));
   } else if (Assembler::IsLdrPpRegOffset(Memory::int32_at(load_address))) {
     // This is an extended constant pool lookup.
     if (CpuFeatures::IsSupported(ARMv7)) {
       load_address -= 2 * Assembler::kInstrSize;
       DCHECK(Assembler::IsMovW(Memory::int32_at(load_address)));
       DCHECK(Assembler::IsMovT(
           Memory::int32_at(load_address + Assembler::kInstrSize)));
     } else {
       load_address -= 4 * Assembler::kInstrSize;
@@ skipping 119 matching lines @@
 
   DCHECK(interrupt_address ==
          isolate->builtins()->OsrAfterStackCheck()->entry());
   return OSR_AFTER_STACK_CHECK;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM