[Arm]: Enable use of extended out-of-line constant pool for Arm.

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 "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 9656 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) {
-  ConstantPoolArray::Iterator code_iter(this, ConstantPoolArray::CODE_PTR);
-  while (!code_iter.is_finished()) {
-    v->VisitCodeEntry(reinterpret_cast<Address>(
-        RawFieldOfElementAt(code_iter.next_index())));
-  }
+  // Unfortunately the serializer relies on pointers being visited in-order,

[ulan, 2014/07/01 13:29:48]

Since we iterating first code pointers and the heap pointers, aren't we already
out-of-order? What does 'in-order' mean?

[rmcilroy, 2014/07/02 16:35:55]

In-order means that we visit the entries of the constant pool in order (e.g.,
from top to bottom in terms of the description in object.h:L3065-L3089), not the
actual locations pointed to by these entries.  Since the code entries come
first, we are doing this in-order here.

I've updated the comment to hopefully clarify this a bit.

[ulan, 2014/07/03 09:19:55]

Yes, the new comment makes it clear.

+  // so we have to iterate both the code and heap pointers in the small section
+  // before doing so in the extended section.
+  for (int s = 0; s <= final_section(); ++s) {
+    LayoutSection section = static_cast<LayoutSection>(s);
+    ConstantPoolArray::Iterator code_iter(
+        this, ConstantPoolArray::CODE_PTR, section);
+    while (!code_iter.is_finished()) {
+      v->VisitCodeEntry(reinterpret_cast<Address>(
+          RawFieldOfElementAt(code_iter.next_index())));
+    }
 
-  ConstantPoolArray::Iterator heap_iter(this, ConstantPoolArray::HEAP_PTR);
-  while (!heap_iter.is_finished()) {
-    v->VisitPointer(RawFieldOfElementAt(heap_iter.next_index()));
+    ConstantPoolArray::Iterator heap_iter(
+        this, ConstantPoolArray::HEAP_PTR, section);
+    while (!heap_iter.is_finished()) {
+      v->VisitPointer(RawFieldOfElementAt(heap_iter.next_index()));
+    }
   }
 }
 
 
 void ConstantPoolArray::ClearPtrEntries(Isolate* isolate) {
   Type type[] = { CODE_PTR, HEAP_PTR };
   Address default_value[] = {
         isolate->builtins()->builtin(Builtins::kIllegal)->entry(),
         reinterpret_cast<Address>(isolate->heap()->undefined_value()) };
 
@@ skipping 7244 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