Contribution of PowerPC port (continuation of 422063005) - currency

src/ppc/assembler-ppc-inl.h

 // 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 51 matching lines @@
 Address RelocInfo::target_address() {
   DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
   return Assembler::target_address_at(pc_, host_);
 }
 
 
 Address RelocInfo::target_address_address() {
   DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_) ||
          rmode_ == EMBEDDED_OBJECT || rmode_ == EXTERNAL_REFERENCE);
 
-#if V8_OOL_CONSTANT_POOL
-  if (Assembler::IsConstantPoolLoadStart(pc_)) {
-    // We return the PC for ool constant pool since this function is used by the
-    // serializerer and expects the address to reside within the code object.
-    return reinterpret_cast<Address>(pc_);
-  }
-#endif
-
   // Read the address of the word containing the target_address in an
   // instruction stream.
   // The only architecture-independent user of this function is the serializer.
   // The serializer uses it to find out how many raw bytes of instruction to
   // output before the next target.
   // For an instruction like LIS/ORI where the target bits are mixed into the
   // instruction bits, the size of the target will be zero, indicating that the
   // serializer should not step forward in memory after a target is resolved
   // and written.
   return reinterpret_cast<Address>(pc_);
 }
 
 
 Address RelocInfo::constant_pool_entry_address() {
-#if V8_OOL_CONSTANT_POOL
-  return Assembler::target_constant_pool_address_at(pc_,
-                                                    host_->constant_pool());
-#else
   UNREACHABLE();
   return NULL;
-#endif
 }
 
 
 int RelocInfo::target_address_size() { return Assembler::kSpecialTargetSize; }
 
 
 void RelocInfo::set_target_address(Address target,
                                    WriteBarrierMode write_barrier_mode,
                                    ICacheFlushMode icache_flush_mode) {
   DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
@@ skipping 13 matching lines @@
 
 
 Address Assembler::target_address_from_return_address(Address pc) {
 // Returns the address of the call target from the return address that will
 // be returned to after a call.
 // Call sequence is :
 //  mov   ip, @ call address
 //  mtlr  ip
 //  blrl
 //                      @ return address
-#if V8_OOL_CONSTANT_POOL
-  if (IsConstantPoolLoadEnd(pc - 3 * kInstrSize)) {
-    return pc - (kMovInstructionsConstantPool + 2) * kInstrSize;
-  }
-#endif
-  return pc - (kMovInstructionsNoConstantPool + 2) * kInstrSize;
+  return pc - (kMovInstructions + 2) * kInstrSize;
 }
 
 
 Address Assembler::return_address_from_call_start(Address pc) {
-#if V8_OOL_CONSTANT_POOL
-  Address load_address = pc + (kMovInstructionsConstantPool - 1) * kInstrSize;
-  if (IsConstantPoolLoadEnd(load_address))
-    return pc + (kMovInstructionsConstantPool + 2) * kInstrSize;
-#endif
-  return pc + (kMovInstructionsNoConstantPool + 2) * kInstrSize;
+  return pc + (kMovInstructions + 2) * kInstrSize;
 }
 
 
 Object* RelocInfo::target_object() {
   DCHECK(IsCodeTarget(rmode_) || rmode_ == EMBEDDED_OBJECT);
   return reinterpret_cast<Object*>(Assembler::target_address_at(pc_, host_));
 }
 
 
 Handle<Object> RelocInfo::target_object_handle(Assembler* origin) {
@@ skipping 57 matching lines @@
   Address address = cell->address() + Cell::kValueOffset;
   Memory::Address_at(pc_) = address;
   if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL) {
     // TODO(1550) We are passing NULL as a slot because cell can never be on
     // evacuation candidate.
     host()->GetHeap()->incremental_marking()->RecordWrite(host(), NULL, cell);
   }
 }
 
 
-#if V8_OOL_CONSTANT_POOL
-static const int kNoCodeAgeInstructions = 7;
-#else
 static const int kNoCodeAgeInstructions = 6;
-#endif
-static const int kCodeAgingInstructions =
-    Assembler::kMovInstructionsNoConstantPool + 3;
+static const int kCodeAgingInstructions = Assembler::kMovInstructions + 3;
 static const int kNoCodeAgeSequenceInstructions =
     ((kNoCodeAgeInstructions >= kCodeAgingInstructions)
          ? kNoCodeAgeInstructions
          : kCodeAgingInstructions);
 static const int kNoCodeAgeSequenceNops =
     (kNoCodeAgeSequenceInstructions - kNoCodeAgeInstructions);
 static const int kCodeAgingSequenceNops =
     (kNoCodeAgeSequenceInstructions - kCodeAgingInstructions);
 static const int kCodeAgingTargetDelta = 1 * Assembler::kInstrSize;
 static const int kNoCodeAgeSequenceLength =
@@ skipping 205 matching lines @@
                    static_cast<uint32_t>(instr2 & kImm16Mask));
     uint64_t lo = (static_cast<uint32_t>((instr4 & kImm16Mask) << 16) |
                    static_cast<uint32_t>(instr5 & kImm16Mask));
     return reinterpret_cast<Address>((hi << 32) | lo);
 #else
     // Assemble the 32 bit value.
     return reinterpret_cast<Address>(((instr1 & kImm16Mask) << 16) |
                                      (instr2 & kImm16Mask));
 #endif
   }
-#if V8_OOL_CONSTANT_POOL
-  return Memory::Address_at(target_constant_pool_address_at(pc, constant_pool));
-#else
-  DCHECK(false);
-  return (Address)0;
-#endif
+
+  UNREACHABLE();
+  return NULL;
 }
 
 
-#if V8_OOL_CONSTANT_POOL
-bool Assembler::IsConstantPoolLoadStart(Address pc) {
-#if V8_TARGET_ARCH_PPC64
-  if (!IsLi(instr_at(pc))) return false;
-  pc += kInstrSize;
-#endif
-  return GetRA(instr_at(pc)).is(kConstantPoolRegister);
-}
-
-
-bool Assembler::IsConstantPoolLoadEnd(Address pc) {
-#if V8_TARGET_ARCH_PPC64
-  pc -= kInstrSize;
-#endif
-  return IsConstantPoolLoadStart(pc);
-}
-
-
-int Assembler::GetConstantPoolOffset(Address pc) {
-  DCHECK(IsConstantPoolLoadStart(pc));
-  Instr instr = instr_at(pc);
-  int offset = SIGN_EXT_IMM16((instr & kImm16Mask));
-  return offset;
-}
-
-
-void Assembler::SetConstantPoolOffset(Address pc, int offset) {
-  DCHECK(IsConstantPoolLoadStart(pc));
-  DCHECK(is_int16(offset));
-  Instr instr = instr_at(pc);
-  instr &= ~kImm16Mask;
-  instr |= (offset & kImm16Mask);
-  instr_at_put(pc, instr);
-}
-
-
-Address Assembler::target_constant_pool_address_at(
-    Address pc, ConstantPoolArray* constant_pool) {
-  Address addr = reinterpret_cast<Address>(constant_pool);
-  DCHECK(addr);
-  addr += GetConstantPoolOffset(pc);
-  return addr;
-}
-#endif
-
-
 // This sets the branch destination (which gets loaded at the call address).
 // This is for calls and branches within generated code.  The serializer
 // has already deserialized the mov instructions etc.
 // There is a FIXED_SEQUENCE assumption here
 void Assembler::deserialization_set_special_target_at(
     Address instruction_payload, Code* code, Address target) {
   set_target_address_at(instruction_payload, code, target);
 }
 
 // This code assumes the FIXED_SEQUENCE of lis/ori
@@ skipping 44 matching lines @@
     instr1 |= hi_word;
     instr2 &= ~kImm16Mask;
     instr2 |= lo_word;
 
     *p = instr1;
     *(p + 1) = instr2;
     if (icache_flush_mode != SKIP_ICACHE_FLUSH) {
       CpuFeatures::FlushICache(p, 2 * kInstrSize);
     }
 #endif
-  } else {
-#if V8_OOL_CONSTANT_POOL
-    Memory::Address_at(target_constant_pool_address_at(pc, constant_pool)) =
-        target;
-#else
-    UNREACHABLE();
-#endif
+    return;
   }
+  UNREACHABLE();
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_PPC_ASSEMBLER_PPC_INL_H_