Contribution of PowerPC port.

src/objects-inl.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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 2349 matching lines @@
 }
 
 
 ConstantPoolArray::LayoutSection ConstantPoolArray::final_section() {
   return is_extended_layout() ? EXTENDED_SECTION : SMALL_SECTION;
 }
 
 
 int ConstantPoolArray::first_extended_section_index() {
   ASSERT(is_extended_layout());
-  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
-  return TotalCountField::decode(small_layout_2);
+  uint32_t small_layout_3 = READ_UINT32_FIELD(this, kSmallLayout3Offset);
+  return TotalCountField::decode(small_layout_3);
 }
 
 
 int ConstantPoolArray::get_extended_section_header_offset() {
   return RoundUp(SizeFor(NumberOfEntries(this, SMALL_SECTION)), kInt64Size);
 }
 
 
 ConstantPoolArray::WeakObjectState ConstantPoolArray::get_weak_object_state() {
-  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
-  return WeakObjectStateField::decode(small_layout_2);
+  uint32_t small_layout_3 = READ_UINT32_FIELD(this, kSmallLayout3Offset);
+  return WeakObjectStateField::decode(small_layout_3);
 }
 
 
 void ConstantPoolArray::set_weak_object_state(
       ConstantPoolArray::WeakObjectState state) {
-  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
-  small_layout_2 = WeakObjectStateField::update(small_layout_2, state);
-  WRITE_INT32_FIELD(this, kSmallLayout2Offset, small_layout_2);
+  uint32_t small_layout_3 = READ_UINT32_FIELD(this, kSmallLayout3Offset);
+  small_layout_3 = WeakObjectStateField::update(small_layout_3, state);
+  WRITE_INT32_FIELD(this, kSmallLayout3Offset, small_layout_3);
 }
 
 
 int ConstantPoolArray::first_index(Type type, LayoutSection section) {
   int index = 0;
   if (section == EXTENDED_SECTION) {
     ASSERT(is_extended_layout());
     index += first_extended_section_index();
   }
 
@@ skipping 14 matching lines @@
 int ConstantPoolArray::number_of_entries(Type type, LayoutSection section) {
   if (section == SMALL_SECTION) {
     uint32_t small_layout_1 = READ_UINT32_FIELD(this, kSmallLayout1Offset);
     uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
     switch (type) {
       case INT64:
         return Int64CountField::decode(small_layout_1);
       case CODE_PTR:
         return CodePtrCountField::decode(small_layout_1);
       case HEAP_PTR:
-        return HeapPtrCountField::decode(small_layout_1);
+        return HeapPtrCountField::decode(small_layout_2);
       case INT32:
         return Int32CountField::decode(small_layout_2);
       default:
         UNREACHABLE();
         return 0;
     }
   } else {
     ASSERT(section == EXTENDED_SECTION && is_extended_layout());
     int offset = get_extended_section_header_offset();
     switch (type) {
@@ skipping 150 matching lines @@
   ASSERT(offset_is_type(offset, HEAP_PTR));
   WRITE_FIELD(this, offset, value);
   WRITE_BARRIER(GetHeap(), this, offset, value);
 }
 
 
 void ConstantPoolArray::Init(const NumberOfEntries& small) {
   uint32_t small_layout_1 =
       Int64CountField::encode(small.count_of(INT64)) |
       CodePtrCountField::encode(small.count_of(CODE_PTR)) |
-      HeapPtrCountField::encode(small.count_of(HEAP_PTR)) |
       IsExtendedField::encode(false);
   uint32_t small_layout_2 =
-      Int32CountField::encode(small.count_of(INT32)) |
+      HeapPtrCountField::encode(small.count_of(HEAP_PTR)) |
+      Int32CountField::encode(small.count_of(INT32));
+  uint32_t small_layout_3 =
       TotalCountField::encode(small.total_count()) |
       WeakObjectStateField::encode(NO_WEAK_OBJECTS);
   WRITE_UINT32_FIELD(this, kSmallLayout1Offset, small_layout_1);
   WRITE_UINT32_FIELD(this, kSmallLayout2Offset, small_layout_2);
+  WRITE_UINT32_FIELD(this, kSmallLayout3Offset, small_layout_3);

[rmcilroy, 2014/07/29 17:11:45]

Why did you have to add another layout field?  I tried really hard to avoid this
as it adds another word to every constant pool which ends up costing a lot of
memory unnecessarily.  If you need a larger number of entries you can use the
EXTENDED_SECTION which provides unlimited entries in a constant pool.

   if (kHeaderSize != kFirstEntryOffset) {
     ASSERT(kFirstEntryOffset - kHeaderSize == kInt32Size);
     WRITE_UINT32_FIELD(this, kHeaderSize, 0);  // Zero out header padding.
   }
 }
 
 
 void ConstantPoolArray::InitExtended(const NumberOfEntries& small,
                                      const NumberOfEntries& extended) {
   // Initialize small layout fields first.
@@ skipping 22 matching lines @@
   if (!is_extended_layout()) {
     return SizeFor(small);
   } else {
     NumberOfEntries extended(this, EXTENDED_SECTION);
     return SizeForExtended(small, extended);
   }
 }
 
 
 int ConstantPoolArray::length() {
-  uint32_t small_layout_2 = READ_UINT32_FIELD(this, kSmallLayout2Offset);
-  int length = TotalCountField::decode(small_layout_2);
+  uint32_t small_layout_3 = READ_UINT32_FIELD(this, kSmallLayout3Offset);
+  int length = TotalCountField::decode(small_layout_3);
   if (is_extended_layout()) {
     length += number_of_entries(INT64, EXTENDED_SECTION) +
               number_of_entries(CODE_PTR, EXTENDED_SECTION) +
               number_of_entries(HEAP_PTR, EXTENDED_SECTION) +
               number_of_entries(INT32, EXTENDED_SECTION);
   }
   return length;
 }
 
 
@@ skipping 651 matching lines @@
 SMI_ACCESSORS(String, length, kLengthOffset)
 SYNCHRONIZED_SMI_ACCESSORS(String, length, kLengthOffset)
 
 
 uint32_t Name::hash_field() {
   return READ_UINT32_FIELD(this, kHashFieldOffset);
 }
 
 
 void Name::set_hash_field(uint32_t value) {
-  WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
-#if V8_HOST_ARCH_64_BIT
-  WRITE_UINT32_FIELD(this, kHashFieldOffset + kIntSize, 0);
-#endif
+  WRITE_INTPTR_FIELD(this, kHashFieldSlot, value);
 }
 
 
 bool Name::Equals(Name* other) {
   if (other == this) return true;
   if ((this->IsInternalizedString() && other->IsInternalizedString()) ||
       this->IsSymbol() || other->IsSymbol()) {
     return false;
   }
   return String::cast(this)->SlowEquals(String::cast(other));
@@ skipping 2131 matching lines @@
 SMI_ACCESSORS(SharedFunctionInfo, compiler_hints,
               kCompilerHintsOffset)
 SMI_ACCESSORS(SharedFunctionInfo, opt_count_and_bailout_reason,
               kOptCountAndBailoutReasonOffset)
 SMI_ACCESSORS(SharedFunctionInfo, counters, kCountersOffset)
 SMI_ACCESSORS(SharedFunctionInfo, ast_node_count, kAstNodeCountOffset)
 SMI_ACCESSORS(SharedFunctionInfo, profiler_ticks, kProfilerTicksOffset)
 
 #else
 
-#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset)             \
-  STATIC_ASSERT(holder::offset % kPointerSize == 0);              \
-  int holder::name() const {                                      \
-    int value = READ_INT_FIELD(this, offset);                     \
-    ASSERT(kHeapObjectTag == 1);                                  \
-    ASSERT((value & kHeapObjectTag) == 0);                        \
-    return value >> 1;                                            \
-  }                                                               \
-  void holder::set_##name(int value) {                            \
-    ASSERT(kHeapObjectTag == 1);                                  \
-    ASSERT((value & 0xC0000000) == 0xC0000000 ||                  \
-           (value & 0xC0000000) == 0x0);                          \
-    WRITE_INT_FIELD(this,                                         \
-                    offset,                                       \
-                    (value << 1) & ~kHeapObjectTag);              \
+#if V8_TARGET_LITTLE_ENDIAN
+#define PSEUDO_SMI_LO_ALIGN 0
+#define PSEUDO_SMI_HI_ALIGN kIntSize
+#else
+#define PSEUDO_SMI_LO_ALIGN kIntSize
+#define PSEUDO_SMI_HI_ALIGN 0
+#endif
+
+#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset)                   \
+  STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_LO_ALIGN);  \
+  int holder::name() const {                                            \
+    int value = READ_INT_FIELD(this, offset);                           \
+    ASSERT(kHeapObjectTag == 1);                                        \
+    ASSERT((value & kHeapObjectTag) == 0);                              \
+    return value >> 1;                                                  \
+  }                                                                     \
+  void holder::set_##name(int value) {                                  \
+    ASSERT(kHeapObjectTag == 1);                                        \
+    ASSERT((value & 0xC0000000) == 0xC0000000 ||                        \
+           (value & 0xC0000000) == 0x0);                                \
+    WRITE_INT_FIELD(this,                                               \
+                    offset,                                             \
+                    (value << 1) & ~kHeapObjectTag);                    \
   }
 
-#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset)             \
-  STATIC_ASSERT(holder::offset % kPointerSize == kIntSize);       \
+#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset)                   \
+  STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_HI_ALIGN);  \
   INT_ACCESSORS(holder, name, offset)
 
 
 PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo, length, kLengthOffset)
 PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo,
                         formal_parameter_count,
                         kFormalParameterCountOffset)
 
 PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo,
                         expected_nof_properties,
@@ skipping 1711 matching lines @@
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_