Add support for Embedded Constant Pools for PPC and Arm

src/ppc/full-codegen-ppc.cc

 // Copyright 2014 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_PPC
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"
@@ skipping 382 matching lines @@
     }
   }
 
   // Always emit a 'return undefined' in case control fell off the end of
   // the body.
   {
     Comment cmnt(masm_, "[ return <undefined>;");
     __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
   }
   EmitReturnSequence();
+
+  if (HasStackOverflow()) {
+    masm_->AbortConstantPoolBuilding();
+  }
 }
 
 
 void FullCodeGenerator::ClearAccumulator() {
   __ LoadSmiLiteral(r3, Smi::FromInt(0));
 }
 
 
 void FullCodeGenerator::EmitProfilingCounterDecrement(int delta) {
   __ mov(r5, Operand(profiling_counter_));
@@ skipping 20 matching lines @@
   Comment cmnt(masm_, "[ Back edge bookkeeping");
   Label ok;
 
   DCHECK(back_edge_target->is_bound());
   int distance = masm_->SizeOfCodeGeneratedSince(back_edge_target) +
                  kCodeSizeMultiplier / 2;
   int weight = Min(kMaxBackEdgeWeight, Max(1, distance / kCodeSizeMultiplier));
   EmitProfilingCounterDecrement(weight);
   {
     Assembler::BlockTrampolinePoolScope block_trampoline_pool(masm_);
+    Assembler::BlockConstantPoolEntrySharingScope prevent_entry_sharing(masm_);
     // BackEdgeTable::PatchAt manipulates this sequence.
     __ cmpi(r6, Operand::Zero());
     __ bc_short(ge, &ok);
     __ Call(isolate()->builtins()->InterruptCheck(), RelocInfo::CODE_TARGET);
 
     // Record a mapping of this PC offset to the OSR id.  This is used to find
     // the AST id from the unoptimized code in order to use it as a key into
     // the deoptimization input data found in the optimized code.
     RecordBackEdge(stmt->OsrEntryId());
   }
@@ skipping 52 matching lines @@
         arg_count++;
       }
       int32_t sp_delta = arg_count * kPointerSize;
       CodeGenerator::RecordPositions(masm_, function()->end_position() - 1);
       __ RecordJSReturn();
       int no_frame_start = __ LeaveFrame(StackFrame::JAVA_SCRIPT, sp_delta);
 #if V8_TARGET_ARCH_PPC64
       // With 64bit we may need nop() instructions to ensure we have
       // enough space to SetDebugBreakAtReturn()
       if (is_int16(sp_delta)) {
-        masm_->nop();
+        if (!FLAG_enable_embedded_constant_pool) masm_->nop();
         masm_->nop();
       }
 #endif
       __ blr();
       info_->AddNoFrameRange(no_frame_start, masm_->pc_offset());
     }
 
 #ifdef DEBUG
     // Check that the size of the code used for returning is large enough
     // for the debugger's requirements.
@@ skipping 1784 matching lines @@
   __ SmiUntag(r6, SetRC);
 
   // If we are sending a value and there is no operand stack, we can jump back
   // in directly.
   Label call_resume;
   if (resume_mode == JSGeneratorObject::NEXT) {
     Label slow_resume;
     __ bne(&slow_resume, cr0);
     __ LoadP(ip, FieldMemOperand(r7, JSFunction::kCodeEntryOffset));
     {
+      ConstantPoolUnavailableScope constant_pool_unavailable(masm_);
+      if (FLAG_enable_embedded_constant_pool) {
+        __ LoadConstantPoolPointerRegisterFromCodeTargetAddress(ip);
+      }
       __ LoadP(r5, FieldMemOperand(r4, JSGeneratorObject::kContinuationOffset));
       __ SmiUntag(r5);
       __ add(ip, ip, r5);
       __ LoadSmiLiteral(r5,
                         Smi::FromInt(JSGeneratorObject::kGeneratorExecuting));
       __ StoreP(r5, FieldMemOperand(r4, JSGeneratorObject::kContinuationOffset),
                 r0);
       __ Jump(ip);
       __ bind(&slow_resume);
     }
@@ skipping 3225 matching lines @@
     return ON_STACK_REPLACEMENT;
   }
 
   DCHECK(interrupt_address ==
          isolate->builtins()->OsrAfterStackCheck()->entry());
   return OSR_AFTER_STACK_CHECK;
 }
 }  // namespace internal
 }  // namespace v8
 #endif  // V8_TARGET_ARCH_PPC