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

src/heap.cc

Index: src/heap.cc
diff --git a/src/heap.cc b/src/heap.cc
index 7c4f66e2ac63e88c80f8c6ef3b7f49ad8267589c..5a4b3387746c13db0d5d018bdc03a6dcf7d51ea8 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -4055,7 +4055,8 @@ MaybeObject* Heap::CreateCode(const CodeDesc& desc,
 
   ConstantPoolArray* constant_pool;
   if (FLAG_enable_ool_constant_pool) {
-    MaybeObject* maybe_constant_pool = desc.origin->AllocateConstantPool(this);
+    MaybeObject* maybe_constant_pool =
+        desc.origin->AllocateConstantPool(this, crankshafted);
     if (!maybe_constant_pool->To(&constant_pool)) return maybe_constant_pool;
   } else {
     constant_pool = empty_constant_pool_array();
@@ -5164,17 +5165,17 @@ MaybeObject* Heap::CopyConstantPoolArrayWithMap(ConstantPoolArray* src,
   int int64_entries = src->count_of_int64_entries();
   int code_ptr_entries = src->count_of_code_ptr_entries();
   int heap_ptr_entries = src->count_of_heap_ptr_entries();
+  int weak_ptr_entries = src->count_of_weak_ptr_entries();
   int int32_entries = src->count_of_int32_entries();
   Object* obj;
-  { MaybeObject* maybe_obj =
-        AllocateConstantPoolArray(int64_entries, code_ptr_entries,
-                                  heap_ptr_entries, int32_entries);
+  { MaybeObject* maybe_obj = AllocateConstantPoolArray(int64_entries,
+        code_ptr_entries, heap_ptr_entries, weak_ptr_entries, int32_entries);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
   HeapObject* dst = HeapObject::cast(obj);
   dst->set_map_no_write_barrier(map);
-  int size = ConstantPoolArray::SizeFor(
-        int64_entries, code_ptr_entries, heap_ptr_entries, int32_entries);
+  int size = ConstantPoolArray::SizeFor(int64_entries,
+      code_ptr_entries + heap_ptr_entries + weak_ptr_entries, int32_entries);
   CopyBlock(
       dst->address() + ConstantPoolArray::kLengthOffset,
       src->address() + ConstantPoolArray::kLengthOffset,
@@ -5317,12 +5318,15 @@ MaybeObject* Heap::AllocateRawFixedDoubleArray(int length,
 MaybeObject* Heap::AllocateConstantPoolArray(int number_of_int64_entries,
                                              int number_of_code_ptr_entries,
                                              int number_of_heap_ptr_entries,
+                                             int number_of_weak_ptr_entries,
                                              int number_of_int32_entries) {
   ASSERT(number_of_int64_entries > 0 || number_of_code_ptr_entries > 0 ||
-         number_of_heap_ptr_entries > 0 || number_of_int32_entries > 0);
+         number_of_heap_ptr_entries > 0 || number_of_weak_ptr_entries > 0 ||
+         number_of_int32_entries > 0);
+  int number_of_ptr_entries = number_of_code_ptr_entries +
+      number_of_heap_ptr_entries + number_of_weak_ptr_entries;
   int size = ConstantPoolArray::SizeFor(number_of_int64_entries,
-                                        number_of_code_ptr_entries,
-                                        number_of_heap_ptr_entries,
+                                        number_of_ptr_entries,
                                         number_of_int32_entries);
 #ifndef V8_HOST_ARCH_64_BIT
   size += kPointerSize;
@@ -5341,6 +5345,7 @@ MaybeObject* Heap::AllocateConstantPoolArray(int number_of_int64_entries,
   constant_pool->SetEntryCounts(number_of_int64_entries,
                                 number_of_code_ptr_entries,
                                 number_of_heap_ptr_entries,
+                                number_of_weak_ptr_entries,
                                 number_of_int32_entries);
   if (number_of_code_ptr_entries > 0) {
     int offset =
@@ -5350,27 +5355,27 @@ MaybeObject* Heap::AllocateConstantPoolArray(int number_of_int64_entries,
         isolate()->builtins()->builtin(Builtins::kIllegal)->entry(),
         number_of_code_ptr_entries);
   }
-  if (number_of_heap_ptr_entries > 0) {
+  if (number_of_heap_ptr_entries > 0 || number_of_weak_ptr_entries > 0) {
     int offset =
         constant_pool->OffsetOfElementAt(constant_pool->first_heap_ptr_index());
     MemsetPointer(
         HeapObject::RawField(constant_pool, offset),
         undefined_value(),
-        number_of_heap_ptr_entries);
+        number_of_heap_ptr_entries + number_of_weak_ptr_entries);
   }
   return constant_pool;
 }
 
 
 MaybeObject* Heap::AllocateEmptyConstantPoolArray() {
-  int size = ConstantPoolArray::SizeFor(0, 0, 0, 0);
+  int size = ConstantPoolArray::SizeFor(0, 0, 0);
   Object* result;
   { MaybeObject* maybe_result =
         AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
   HeapObject::cast(result)->set_map_no_write_barrier(constant_pool_array_map());
-  ConstantPoolArray::cast(result)->SetEntryCounts(0, 0, 0, 0);
+  ConstantPoolArray::cast(result)->SetEntryCounts(0, 0, 0, 0, 0);
   return result;
 }