Enable constant pool support.

src/ppc/assembler-ppc.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 //
 // - Redistributions of source code must retain the above copyright notice,
 // this list of conditions and the following disclaimer.
 //
@@ skipping 131 matching lines @@
 // -----------------------------------------------------------------------------
 // Implementation of RelocInfo
 
 const int RelocInfo::kApplyMask = 1 << RelocInfo::INTERNAL_REFERENCE |
                                   1 << RelocInfo::INTERNAL_REFERENCE_ENCODED;
 
 
 bool RelocInfo::IsCodedSpecially() {
   // The deserializer needs to know whether a pointer is specially
   // coded.  Being specially coded on PPC means that it is a lis/ori
-  // instruction sequence, and these are always the case inside code
-  // objects.
+  // instruction sequence or is an out of line constant pool entry,
+  // and these are always the case inside code objects.
   return true;
 }
 
 
 bool RelocInfo::IsInConstantPool() {
+  if (FLAG_enable_embedded_constant_pool) {
+    Address constant_pool = host_->constant_pool();
+    return (constant_pool &&
+            (pc_ >= constant_pool || Assembler::IsConstantPoolLoadStart(pc_)));
+  }
   return false;
 }
 
 
 // -----------------------------------------------------------------------------
 // Implementation of Operand and MemOperand
 // See assembler-ppc-inl.h for inlined constructors
 
 Operand::Operand(Handle<Object> handle) {
   AllowDeferredHandleDereference using_raw_address;
@@ skipping 26 matching lines @@
 }
 
 
 // -----------------------------------------------------------------------------
 // Specific instructions, constants, and masks.
 
 
 Assembler::Assembler(Isolate* isolate, void* buffer, int buffer_size)
     : AssemblerBase(isolate, buffer, buffer_size),
       recorded_ast_id_(TypeFeedbackId::None()),
+      constant_pool_builder_(),
       positions_recorder_(this) {
   reloc_info_writer.Reposition(buffer_ + buffer_size_, pc_);
 
   no_trampoline_pool_before_ = 0;
   trampoline_pool_blocked_nesting_ = 0;
+  constant_pool_entry_sharing_blocked_nesting_ = 0;
   // We leave space (kMaxBlockTrampolineSectionSize)
   // for BlockTrampolinePoolScope buffer.
   next_buffer_check_ =
       FLAG_force_long_branches ? kMaxInt : kMaxCondBranchReach -
                                                kMaxBlockTrampolineSectionSize;
   internal_trampoline_exception_ = false;
   last_bound_pos_ = 0;
   trampoline_emitted_ = FLAG_force_long_branches;
   unbound_labels_count_ = 0;
   ClearRecordedAstId();
   relocations_.reserve(128);
 }
 
 
 void Assembler::GetCode(CodeDesc* desc) {
+  // Emit constant pool if necessary.
+  int offset = EmitConstantPool();
+
   EmitRelocations();
 
   // Set up code descriptor.
   desc->buffer = buffer_;
   desc->buffer_size = buffer_size_;
   desc->instr_size = pc_offset();
   desc->reloc_size = (buffer_ + buffer_size_) - reloc_info_writer.pos();
+  desc->constant_pool_size = (offset ? desc->instr_size - offset : 0);
   desc->origin = this;
 }
 
 
 void Assembler::Align(int m) {
 #if V8_TARGET_ARCH_PPC64
   DCHECK(m >= 4 && base::bits::IsPowerOfTwo64(m));
 #else
   DCHECK(m >= 4 && base::bits::IsPowerOfTwo32(m));
 #endif
@@ skipping 223 matching lines @@
       int32_t offset = target_pos + SIGN_EXT_IMM16(operands & kImm16Mask);
       CodePatcher patcher(reinterpret_cast<byte*>(buffer_ + pos), 2,
                           CodePatcher::DONT_FLUSH);
       patcher.masm()->bitwise_add32(dst, base, offset);
       break;
     }
     case kUnboundMovLabelAddrOpcode: {
       // Load the address of the label in a register.
       Register dst = Register::from_code(instr_at(pos + kInstrSize));
       CodePatcher patcher(reinterpret_cast<byte*>(buffer_ + pos),
-                          kMovInstructions, CodePatcher::DONT_FLUSH);
+                          kMovInstructionsNoConstantPool,
+                          CodePatcher::DONT_FLUSH);
       // Keep internal references relative until EmitRelocations.
       patcher.masm()->bitwise_mov(dst, target_pos);
       break;
     }
     case kUnboundJumpTableEntryOpcode: {
       CodePatcher patcher(reinterpret_cast<byte*>(buffer_ + pos),
                           kPointerSize / kInstrSize, CodePatcher::DONT_FLUSH);
       // Keep internal references relative until EmitRelocations.
       patcher.masm()->emit_ptr(target_pos);
       break;
@@ skipping 1007 matching lines @@
   Label instructions;
   DCHECK(pc_offset() == 0);
   emit_label_addr(&instructions);
   emit_ptr(0);
   emit_ptr(0);
   bind(&instructions);
 #endif
 }
 
 
+int Assembler::instructions_required_for_mov(const Operand& x) const {
+  bool canOptimize =
+      !(x.must_output_reloc_info(this) || is_trampoline_pool_blocked());
+  if (use_constant_pool_for_mov(x, canOptimize)) {
+    // Current usage guarantees that all constant pool references can
+    // use the same sequence.
+    return kMovInstructionsConstantPool;
+  }
+  DCHECK(!canOptimize);
+  return kMovInstructionsNoConstantPool;
+}
+
+
+bool Assembler::use_constant_pool_for_mov(const Operand& x,
+                                          bool canOptimize) const {
+  if (!FLAG_enable_embedded_constant_pool || !is_constant_pool_available() ||
+      is_constant_pool_full()) {
+    // If there is no constant pool available, we must use a mov
+    // immediate sequence.
+    return false;
+  }
+
+  intptr_t value = x.immediate();
+  if (canOptimize && is_int16(value)) {
+    // Prefer a single-instruction load-immediate.
+    return false;
+  }
+
+  return true;
+}
+
+
 void Assembler::EnsureSpaceFor(int space_needed) {
   if (buffer_space() <= (kGap + space_needed)) {
     GrowBuffer(space_needed);
   }
 }
 
 
 bool Operand::must_output_reloc_info(const Assembler* assembler) const {
   if (rmode_ == RelocInfo::EXTERNAL_REFERENCE) {
     if (assembler != NULL && assembler->predictable_code_size()) return true;
@@ skipping 12 matching lines @@
 // Todo - break this dependency so we can optimize mov() in general
 // and only use the generic version when we require a fixed sequence
 void Assembler::mov(Register dst, const Operand& src) {
   intptr_t value = src.immediate();
   bool relocatable = src.must_output_reloc_info(this);
   bool canOptimize;
 
   canOptimize =
       !(relocatable || (is_trampoline_pool_blocked() && !is_int16(value)));
 
+  if (use_constant_pool_for_mov(src, canOptimize)) {
+    DCHECK(is_constant_pool_available());
+    if (relocatable) {
+      RecordRelocInfo(src.rmode_);
+    }
+    ConstantPoolAddEntry(src.rmode_, value);
+#if V8_TARGET_ARCH_PPC64
+    ld(dst, MemOperand(kConstantPoolRegister, 0));
+#else
+    lwz(dst, MemOperand(kConstantPoolRegister, 0));
+#endif
+    return;
+  }
+
   if (canOptimize) {
     if (is_int16(value)) {
       li(dst, Operand(value));
     } else {
       uint16_t u16;
 #if V8_TARGET_ARCH_PPC64
       if (is_int32(value)) {
 #endif
         lis(dst, Operand(value >> 16));
 #if V8_TARGET_ARCH_PPC64
@@ skipping 121 matching lines @@
     DCHECK(is_int26(link));
     DCHECK(is_int16(delta));
 
     BlockTrampolinePoolScope block_trampoline_pool(this);
     emit(kUnboundAddLabelOffsetOpcode | (link & kImm26Mask));
     emit(dst.code() * B21 | base.code() * B16 | (delta & kImm16Mask));
   }
 }
 
 
+// TODO(mbrandy): allow loading internal reference from constant pool
 void Assembler::mov_label_addr(Register dst, Label* label) {
   CheckBuffer();
   RecordRelocInfo(RelocInfo::INTERNAL_REFERENCE_ENCODED);
   int position = link(label);
   if (label->is_bound()) {
     // Keep internal references relative until EmitRelocations.
     bitwise_mov(dst, position);
   } else {
     // Encode internal reference to unbound label. We use a dummy opcode
     // such that it won't collide with any opcode that might appear in the
     // label's chain.  Encode the destination register in the 2nd instruction.
     int link = position - pc_offset();
     DCHECK_EQ(0, link & 3);
     link >>= 2;
     DCHECK(is_int26(link));
 
     // When the label is bound, these instructions will be patched
     // with a multi-instruction mov sequence that will load the
     // destination register with the address of the label.
     //
     // target_at extracts the link and target_at_put patches the instructions.
     BlockTrampolinePoolScope block_trampoline_pool(this);
     emit(kUnboundMovLabelAddrOpcode | (link & kImm26Mask));
     emit(dst.code());
-    DCHECK(kMovInstructions >= 2);
-    for (int i = 0; i < kMovInstructions - 2; i++) nop();
+    DCHECK(kMovInstructionsNoConstantPool >= 2);
+    for (int i = 0; i < kMovInstructionsNoConstantPool - 2; i++) nop();
   }
 }
 
 
 void Assembler::emit_label_addr(Label* label) {
   CheckBuffer();
   RecordRelocInfo(RelocInfo::INTERNAL_REFERENCE);
   int position = link(label);
   if (label->is_bound()) {
     // Keep internal references relative until EmitRelocations.
@@ skipping 661 matching lines @@
     // Number of branches to unbound label at this point is zero, so we can
     // move next buffer check to maximum.
     next_buffer_check_ =
         pc_offset() + kMaxCondBranchReach - kMaxBlockTrampolineSectionSize;
   }
   return;
 }
 
 
 Handle<ConstantPoolArray> Assembler::NewConstantPool(Isolate* isolate) {
-  DCHECK(!FLAG_enable_ool_constant_pool);
+  UNREACHABLE();
   return isolate->factory()->empty_constant_pool_array();
 }
 
 
 void Assembler::PopulateConstantPool(ConstantPoolArray* constant_pool) {
-  DCHECK(!FLAG_enable_ool_constant_pool);
+  UNREACHABLE();
+}
+
+
+ConstantPoolBuilder::ConstantPoolBuilder() : size_(0) { entries_.reserve(64); }
+
+
+void ConstantPoolBuilder::AddEntry(ConstantPoolEntry& entry, bool sharing_ok) {
+  DCHECK(!IsEmitted());
+
+  if (sharing_ok) {
+    // Try to merge entries
+    size_t i;
+    std::vector<ConstantPoolEntry>::const_iterator it;
+    for (it = entries_.begin(), i = 0; it != entries_.end(); it++, i++) {
+      if (it->merged_index_ != -2 && entry.IsEqual(*it)) {
+        // Merge with found entry.
+        entry.merged_index_ = i;
+        break;
+      }
+    }
+  } else {
+    // Ensure this entry remains unique
+    entry.merged_index_ = -2;
+  }
+
+  entries_.push_back(entry);
+
+  if (entry.merged_index_ < 0) {
+    // Not merged, so update the appropriate count and size.
+    number_of_entries_.increment(entry.type());
+    size_ = number_of_entries_.size();
+  }
+}
+
+
+void ConstantPoolBuilder::EmitGroup(Assembler* assm, int entrySize) {
+  int base = label_.pos();
+  for (std::vector<ConstantPoolEntry>::iterator entry = entries_.begin();
+       entry != entries_.end(); entry++) {
+#if !V8_TARGET_ARCH_PPC64
+    // Skip entries not in the requested group based on size.
+    if (entry->size() != entrySize) continue;
+#endif
+
+    // Update constant pool if necessary and get the entry's offset.
+    int offset;
+    if (entry->merged_index_ < 0) {
+      offset = assm->pc_offset() - base;
+      entry->merged_index_ = offset;  // Stash offset for merged entries.
+#if V8_TARGET_ARCH_PPC64
+      assm->emit_ptr(entry->value_);
+#else
+      if (entrySize == kDoubleSize) {
+        assm->emit_double(entry->value64_);
+      } else {
+        assm->emit_ptr(entry->value_);
+      }
+#endif
+    } else {
+      DCHECK(entry->merged_index_ < (entry - entries_.begin()));
+      offset = entries_[entry->merged_index_].merged_index_;
+    }
+
+    // Patch load instruction with correct offset.
+    assm->SetConstantPoolOffset(entry->position_, offset);
+  }
+}
+
+
+// Emit and return position of pool.  Zero implies no constant pool.
+int ConstantPoolBuilder::Emit(Assembler* assm) {
+  bool empty = IsEmpty();
+  bool emitted = IsEmitted();
+
+  if (!emitted) {
+    // Mark start of constant pool.  Align if necessary.
+    if (!empty) assm->CodeTargetAlign();
+    assm->bind(&label_);
+  }
+
+  int position = empty ? 0 : label_.pos();
+
+  if (!(emitted || empty)) {
+// Emit in groups based on size.  We don't support 32-bit
+// constants in 64-bit mode so the only non-pointer-sized entries
+// are doubles in 32-bit mode.
+#if !V8_TARGET_ARCH_PPC64
+    // Emit any doubles first for alignment purposes.
+    if (number_of_entries_.count_of(INT64)) {
+      EmitGroup(assm, kDoubleSize);
+    }
+#endif
+    EmitGroup(assm, kPointerSize);
+    DCHECK(position > 0);
+    DCHECK(assm->pc_offset() - position == size_);
+  }
+
+  return position;
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_PPC