Support weak heap references in the ConstantPool to support IsWeakObjectInOptimizedCode objects.

src/arm/assembler-arm.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 326 matching lines @@
 
 Operand::Operand(Handle<Object> handle) {
   AllowDeferredHandleDereference using_raw_address;
   rm_ = no_reg;
   // Verify all Objects referred by code are NOT in new space.
   Object* obj = *handle;
   if (obj->IsHeapObject()) {
     ASSERT(!HeapObject::cast(obj)->GetHeap()->InNewSpace(obj));
     imm32_ = reinterpret_cast<intptr_t>(handle.location());
     rmode_ = RelocInfo::EMBEDDED_OBJECT;
+    weak_in_optimized_code_ = Code::IsWeakObjectInOptimizedCode(obj);
   } else {
     // no relocation needed
     imm32_ = reinterpret_cast<intptr_t>(obj);
     rmode_ = RelocInfo::NONE32;
   }
 }
 
 
 Operand::Operand(Register rm, ShiftOp shift_op, int shift_imm) {
   ASSERT(is_uint5(shift_imm));
@@ skipping 774 matching lines @@
     // No use of constant pool and the immediate operand can be encoded as a
     // shifter operand.
     return true;
   }
 }
 
 
 void Assembler::move_32_bit_immediate(Register rd,
                                       const Operand& x,
                                       Condition cond) {
-  RelocInfo rinfo(pc_, x.rmode_, x.imm32_, NULL);
+  RelocInfo::WeakMode weak_mode = x.weak_in_optimized_code_ ?
+      RelocInfo::WEAK_IN_OPTIMIZED_CODE : RelocInfo::NOT_WEAK;
+  RelocInfo rinfo(pc_, x.rmode_, weak_mode, x.imm32_);
   if (x.must_output_reloc_info(this)) {
     RecordRelocInfo(rinfo);
   }
 
   if (use_mov_immediate_load(x, this)) {
     Register target = rd.code() == pc.code() ? ip : rd;
     // TODO(rmcilroy): add ARMv6 support for immediate loads.
     ASSERT(CpuFeatures::IsSupported(ARMv7));
     if (!FLAG_enable_ool_constant_pool && x.must_output_reloc_info(this)) {
       // Make sure the movw/movt doesn't get separated.
@@ skipping 2377 matching lines @@
       bind(&after_pool);
     }
   }
 
   // Since a constant pool was just emitted, move the check offset forward by
   // the standard interval.
   next_buffer_check_ = pc_offset() + kCheckPoolInterval;
 }
 
 
-MaybeObject* Assembler::AllocateConstantPool(Heap* heap) {
+MaybeObject* Assembler::AllocateConstantPool(Heap* heap,
+                                             bool has_weak_pointers) {
   ASSERT(FLAG_enable_ool_constant_pool);
-  return constant_pool_builder_.Allocate(heap);
+  return constant_pool_builder_.Allocate(heap, has_weak_pointers);
 }
 
 
 void Assembler::PopulateConstantPool(ConstantPoolArray* constant_pool) {
   ASSERT(FLAG_enable_ool_constant_pool);
   constant_pool_builder_.Populate(this, constant_pool);
 }
 
 
 ConstantPoolBuilder::ConstantPoolBuilder()
     : entries_(),
       merged_indexes_(),
       count_of_64bit_(0),
       count_of_code_ptr_(0),
       count_of_heap_ptr_(0),
+      count_of_weak_ptr_(0),
       count_of_32bit_(0) { }
 
 
 bool ConstantPoolBuilder::IsEmpty() {
   return entries_.size() == 0;
 }
 
 
 bool ConstantPoolBuilder::Is64BitEntry(RelocInfo::Mode rmode) {
   return rmode == RelocInfo::NONE64;
@@ skipping 44 matching lines @@
   if (merged_index == -1) {
     // Not merged, so update the appropriate count.
     if (Is64BitEntry(rmode)) {
       count_of_64bit_++;
     } else if (Is32BitEntry(rmode)) {
       count_of_32bit_++;
     } else if (IsCodePtrEntry(rmode)) {
       count_of_code_ptr_++;
     } else {
       ASSERT(IsHeapPtrEntry(rmode));
-      count_of_heap_ptr_++;
+      if (rinfo.weak_mode() == RelocInfo::WEAK_IN_OPTIMIZED_CODE) {
+        count_of_weak_ptr_++;
+      } else {
+        count_of_heap_ptr_++;
+      }
     }
   }
 
   // Check if we still have room for another entry given Arm's ldr and vldr
   // immediate offset range.
-  if (!(is_uint12(ConstantPoolArray::SizeFor(count_of_64bit_,
-                                             count_of_code_ptr_,
-                                             count_of_heap_ptr_,
-                                             count_of_32bit_))) &&
-        is_uint10(ConstantPoolArray::SizeFor(count_of_64bit_, 0, 0, 0))) {
+  if (!(is_uint12(ConstantPoolArray::SizeFor(
+          count_of_64bit_,
+          count_of_code_ptr_ + count_of_heap_ptr_ + count_of_weak_ptr_,
+          count_of_32bit_))) &&
+        is_uint10(ConstantPoolArray::SizeFor(count_of_64bit_, 0, 0))) {
     assm->set_constant_pool_full();
   }
 }
 
 
 void ConstantPoolBuilder::Relocate(int pc_delta) {
   for (std::vector<RelocInfo>::iterator rinfo = entries_.begin();
        rinfo != entries_.end(); rinfo++) {
     ASSERT(rinfo->rmode() != RelocInfo::JS_RETURN);
     rinfo->set_pc(rinfo->pc() + pc_delta);
   }
 }
 
 
-MaybeObject* ConstantPoolBuilder::Allocate(Heap* heap) {
+MaybeObject* ConstantPoolBuilder::Allocate(Heap* heap, bool has_weak_pointers) {
   if (IsEmpty()) {
     return heap->empty_constant_pool_array();
   } else {
+    if (!has_weak_pointers) {
+      // Move potential weak pointers to normal heap pointers.
+      count_of_heap_ptr_ += count_of_weak_ptr_;
+      count_of_weak_ptr_ = 0;
+    }
     return heap->AllocateConstantPoolArray(count_of_64bit_, count_of_code_ptr_,
-                                           count_of_heap_ptr_, count_of_32bit_);
+        count_of_heap_ptr_, count_of_weak_ptr_, count_of_32bit_);
   }
 }
 
 
 void ConstantPoolBuilder::Populate(Assembler* assm,
                                    ConstantPoolArray* constant_pool) {
   ASSERT(constant_pool->count_of_int64_entries() == count_of_64bit_);
   ASSERT(constant_pool->count_of_code_ptr_entries() == count_of_code_ptr_);
   ASSERT(constant_pool->count_of_heap_ptr_entries() == count_of_heap_ptr_);
+  ASSERT(constant_pool->count_of_weak_ptr_entries() == count_of_weak_ptr_);
   ASSERT(constant_pool->count_of_int32_entries() == count_of_32bit_);
   ASSERT(entries_.size() == merged_indexes_.size());
 
   int index_64bit = 0;
   int index_code_ptr = count_of_64bit_;
   int index_heap_ptr = count_of_64bit_ + count_of_code_ptr_;
-  int index_32bit = count_of_64bit_ + count_of_code_ptr_ + count_of_heap_ptr_;
+  int index_weak_ptr = count_of_64bit_ + count_of_code_ptr_ +
+      count_of_heap_ptr_;
+  int index_32bit = count_of_64bit_ + count_of_code_ptr_ + count_of_heap_ptr_ +
+      count_of_weak_ptr_;
 
   size_t i;
   std::vector<RelocInfo>::const_iterator rinfo;
   for (rinfo = entries_.begin(), i = 0; rinfo != entries_.end(); rinfo++, i++) {
     RelocInfo::Mode rmode = rinfo->rmode();
 
     // Update constant pool if necessary and get the entry's offset.
     int offset;
     if (merged_indexes_[i] == -1) {
       if (Is64BitEntry(rmode)) {
         offset = constant_pool->OffsetOfElementAt(index_64bit) - kHeapObjectTag;
         constant_pool->set(index_64bit++, rinfo->data64());
       } else if (Is32BitEntry(rmode)) {
         offset = constant_pool->OffsetOfElementAt(index_32bit) - kHeapObjectTag;
         constant_pool->set(index_32bit++, static_cast<int32_t>(rinfo->data()));
       } else if (IsCodePtrEntry(rmode)) {
         offset = constant_pool->OffsetOfElementAt(index_code_ptr) -
             kHeapObjectTag;
         constant_pool->set(index_code_ptr++,
                            reinterpret_cast<Object *>(rinfo->data()));
       } else {
         ASSERT(IsHeapPtrEntry(rmode));
-        offset = constant_pool->OffsetOfElementAt(index_heap_ptr) -
-            kHeapObjectTag;
-        constant_pool->set(index_heap_ptr++,
-                           reinterpret_cast<Object *>(rinfo->data()));
+        if (count_of_weak_ptr_ > 0 &&
+            rinfo->weak_mode() == RelocInfo::WEAK_IN_OPTIMIZED_CODE) {
+          offset = constant_pool->OffsetOfElementAt(index_weak_ptr) -
+              kHeapObjectTag;
+          constant_pool->set(index_weak_ptr++,
+                             reinterpret_cast<Object *>(rinfo->data()));
+        } else {
+          offset = constant_pool->OffsetOfElementAt(index_heap_ptr) -
+              kHeapObjectTag;
+          constant_pool->set(index_heap_ptr++,
+                             reinterpret_cast<Object *>(rinfo->data()));
+        }
       }
       merged_indexes_[i] = offset;  // Stash offset for merged entries.
     } else {
       size_t merged_index = static_cast<size_t>(merged_indexes_[i]);
       ASSERT(merged_index < merged_indexes_.size() && merged_index < i);
       offset = merged_indexes_[merged_index];
     }
 
     // Patch vldr/ldr instruction with correct offset.
     Instr instr = assm->instr_at(rinfo->pc());
@@ skipping 10 matching lines @@
               Assembler::GetLdrRegisterImmediateOffset(instr) == 0));
       ASSERT(is_uint12(offset));
       assm->instr_at_put(rinfo->pc(),
           Assembler::SetLdrRegisterImmediateOffset(instr, offset));
     }
   }
 
   ASSERT((index_64bit == count_of_64bit_) &&
          (index_code_ptr == (index_64bit + count_of_code_ptr_)) &&
          (index_heap_ptr == (index_code_ptr + count_of_heap_ptr_)) &&
-         (index_32bit == (index_heap_ptr + count_of_32bit_)));
+         (index_weak_ptr == (index_heap_ptr + count_of_weak_ptr_)) &&
+         (index_32bit == (index_weak_ptr + count_of_32bit_)));
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM