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

src/objects.h

 // Copyright 2012 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.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include "src/allocation.h"
 #include "src/assert-scope.h"
 #include "src/builtins.h"
@@ skipping 3117 matching lines @@
     LAST_TYPE = INT32
   };
 
   enum LayoutSection {
     SMALL_SECTION = 0,
     EXTENDED_SECTION
   };
 
   class NumberOfEntries BASE_EMBEDDED {
    public:
+    inline NumberOfEntries() {
+      for (int i = 0; i < NUMBER_OF_TYPES; i++) {
+        element_counts_[i] = 0;
+      }
+    }
+
     inline NumberOfEntries(int int64_count, int code_ptr_count,
                            int heap_ptr_count, int int32_count) {
       element_counts_[INT64] = int64_count;
       element_counts_[CODE_PTR] = code_ptr_count;
       element_counts_[HEAP_PTR] = heap_ptr_count;
       element_counts_[INT32] = int32_count;
     }
 
     inline NumberOfEntries(ConstantPoolArray* array, LayoutSection section) {
       element_counts_[INT64] = array->number_of_entries(INT64, section);
       element_counts_[CODE_PTR] = array->number_of_entries(CODE_PTR, section);
       element_counts_[HEAP_PTR] = array->number_of_entries(HEAP_PTR, section);
       element_counts_[INT32] = array->number_of_entries(INT32, section);
     }
 
-    inline int count_of(Type type) const {
-      ASSERT(type < NUMBER_OF_TYPES);
-      return element_counts_[type];
-    }
-
-    inline int total_count() const {
-      int count = 0;
-      for (int i = 0; i < NUMBER_OF_TYPES; i++) {
-        count += element_counts_[i];
-      }
-      return count;
-    }
-
-    inline int are_in_range(int min, int max) const {
-      for (int i = FIRST_TYPE; i < NUMBER_OF_TYPES; i++) {
-        if (element_counts_[i] < min || element_counts_[i] > max) {
-          return false;
-        }
-      }
-      return true;
-    }
+    inline void increment(Type type);
+    inline int equals(const NumberOfEntries& other) const;
+    inline bool is_empty() const;
+    inline int count_of(Type type) const;
+    inline int base_of(Type type) const;
+    inline int total_count() const;
+    inline int are_in_range(int min, int max) const;
 
    private:
     int element_counts_[NUMBER_OF_TYPES];
   };
 
   class Iterator BASE_EMBEDDED {
    public:
     inline Iterator(ConstantPoolArray* array, Type type)
-        : array_(array), type_(type), final_section_(array->final_section()) {
-      current_section_ = SMALL_SECTION;
-      next_index_ = array->first_index(type, SMALL_SECTION);
+        : array_(array),
+          type_(type),
+          final_section_(array->final_section()),
+          current_section_(SMALL_SECTION),
+          next_index_(array->first_index(type, SMALL_SECTION)) {
+      update_section();
+    }
+
+    inline Iterator(ConstantPoolArray* array, Type type, LayoutSection section)
+        : array_(array),
+          type_(type),
+          final_section_(section),
+          current_section_(section),
+          next_index_(array->first_index(type, section)) {
       update_section();
     }
 
     inline int next_index();
     inline bool is_finished();
+
    private:
     inline void update_section();
     ConstantPoolArray* array_;
     const Type type_;
     const LayoutSection final_section_;
 
     LayoutSection current_section_;
     int next_index_;
   };
 
@@ skipping 39 matching lines @@
 
   // Clears the pointer entries with GC safe values.
   void ClearPtrEntries(Isolate* isolate);
 
   // returns the total number of entries in the constant pool array.
   inline int length();
 
   // Garbage collection support.
   inline int size();
 
+
+  inline static int MaxInt64Offset(int number_of_int64) {
+    return kFirstEntryOffset + (number_of_int64 * kInt64Size);
+  }
+
   inline static int SizeFor(const NumberOfEntries& small) {
     int size = kFirstEntryOffset +
         (small.count_of(INT64)  * kInt64Size) +
         (small.count_of(CODE_PTR) * kPointerSize) +
         (small.count_of(HEAP_PTR) * kPointerSize) +
         (small.count_of(INT32) * kInt32Size);
     return RoundUp(size, kPointerSize);
   }
 
   inline static int SizeForExtended(const NumberOfEntries& small,
@@ skipping 7940 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_