Add support for extended constant pool arrays.

src/objects.cc

 // Copyright 2013 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 "v8.h"
 
 #include "accessors.h"
 #include "allocation-site-scopes.h"
 #include "api.h"
 #include "arguments.h"
@@ skipping 9945 matching lines @@
 
 bool Map::EquivalentToForNormalization(Map* other,
                                        PropertyNormalizationMode mode) {
   int properties = mode == CLEAR_INOBJECT_PROPERTIES
       ? 0 : other->inobject_properties();
   return CheckEquivalent(this, other) && inobject_properties() == properties;
 }
 
 
 void ConstantPoolArray::ConstantPoolIterateBody(ObjectVisitor* v) {
-  for (int i = 0; i < count_of_code_ptr_entries(); i++) {
-    int index = first_code_ptr_index() + i;
-    v->VisitCodeEntry(reinterpret_cast<Address>(RawFieldOfElementAt(index)));
+  ConstantPoolArray::Iterator code_iter(this, ConstantPoolArray::CODE_PTR);
+  while (!code_iter.is_finished()) {
+    v->VisitCodeEntry(reinterpret_cast<Address>(
+        RawFieldOfElementAt(code_iter.next_index())));
   }
-  for (int i = 0; i < count_of_heap_ptr_entries(); i++) {
-    int index = first_heap_ptr_index() + i;
-    v->VisitPointer(RawFieldOfElementAt(index));
+
+  ConstantPoolArray::Iterator heap_iter(this, ConstantPoolArray::HEAP_PTR);
+  while (!heap_iter.is_finished()) {
+    v->VisitPointer(RawFieldOfElementAt(heap_iter.next_index()));
   }
 }
 
+
+void ConstantPoolArray::ClearPtrEntries(Isolate* isolate) {
+  if (number_of_entries(CODE_PTR, SMALL_SECTION) > 0) {

[ulan, 2014/06/02 12:32:58]

Type type[] = {CODE_PTR, HEAP_PTR};
Address value[] = {<illegal builtin entry>, <undefined>};

for (int section = 0; section <= final_section(); ++section) {
  for (int i = 0; i < 2; ++i) {
    if (number_of_entries(type[i], section) > 0) {
      int offset = OffsetOfElementAt(first_index(type[i], section));
      MemsetPointer(
        HeapObject::RawField(this, offset),
        value[i],
        number_of_entries(type[i], section));
    }
  }
}

[rmcilroy, 2014/06/03 12:32:28]

Done.  I'm not convinced this is clearer though.

+    int offset = OffsetOfElementAt(first_index(CODE_PTR, SMALL_SECTION));
+    MemsetPointer(
+        reinterpret_cast<Address*>(HeapObject::RawField(this, offset)),
+        isolate->builtins()->builtin(Builtins::kIllegal)->entry(),
+        number_of_entries(CODE_PTR, SMALL_SECTION));
+  }
+  if (number_of_entries(HEAP_PTR, SMALL_SECTION) > 0) {
+    int offset = OffsetOfElementAt(first_index(HEAP_PTR, SMALL_SECTION));
+    MemsetPointer(
+        HeapObject::RawField(this, offset),
+        isolate->heap()->undefined_value(),
+        number_of_entries(HEAP_PTR, SMALL_SECTION));
+  }
+  if (is_extended_layout()) {
+    if (number_of_entries(CODE_PTR, EXTENDED_SECTION) > 0) {
+      int offset = OffsetOfElementAt(first_index(CODE_PTR, EXTENDED_SECTION));
+      MemsetPointer(
+          reinterpret_cast<Address*>(HeapObject::RawField(this, offset)),
+          isolate->builtins()->builtin(Builtins::kIllegal)->entry(),
+          number_of_entries(CODE_PTR, EXTENDED_SECTION));
+    }
+    if (number_of_entries(HEAP_PTR, EXTENDED_SECTION) > 0) {
+      int offset = OffsetOfElementAt(first_index(HEAP_PTR, EXTENDED_SECTION));
+      MemsetPointer(
+          HeapObject::RawField(this, offset),
+          isolate->heap()->undefined_value(),
+          number_of_entries(HEAP_PTR, EXTENDED_SECTION));
+    }
+  }
+}
+
 
 void JSFunction::JSFunctionIterateBody(int object_size, ObjectVisitor* v) {
   // Iterate over all fields in the body but take care in dealing with
   // the code entry.
   IteratePointers(v, kPropertiesOffset, kCodeEntryOffset);
   v->VisitCodeEntry(this->address() + kCodeEntryOffset);
   IteratePointers(v, kCodeEntryOffset + kPointerSize, object_size);
 }
 
 
@@ skipping 7283 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal