[runtime] Store constructor function index on primitive maps.

src/layout-descriptor-inl.h

 // Copyright 2014 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_LAYOUT_DESCRIPTOR_INL_H_
 #define V8_LAYOUT_DESCRIPTOR_INL_H_
 
 #include "src/layout-descriptor.h"
 
 namespace v8 {
@@ skipping 143 matching lines @@
     // to utilize that "lost" space which could also help to avoid layout
     // descriptor reallocations.
     ++length;
   }
   return length;
 }
 
 
 int LayoutDescriptor::CalculateCapacity(Map* map, DescriptorArray* descriptors,
                                         int num_descriptors) {
-  int inobject_properties = map->inobject_properties();
+  int inobject_properties = map->GetInObjectProperties();
   if (inobject_properties == 0) return 0;
 
   DCHECK_LE(num_descriptors, descriptors->number_of_descriptors());
 
   int layout_descriptor_length;
   const int kMaxWordsPerField = kDoubleSize / kPointerSize;
 
   if (num_descriptors <= kSmiValueSize / kMaxWordsPerField) {
     // Even in the "worst" case (all fields are doubles) it would fit into
     // a Smi, so no need to calculate length.
@@ skipping 13 matching lines @@
   }
   layout_descriptor_length = Min(layout_descriptor_length, inobject_properties);
   return layout_descriptor_length;
 }
 
 
 LayoutDescriptor* LayoutDescriptor::Initialize(
     LayoutDescriptor* layout_descriptor, Map* map, DescriptorArray* descriptors,
     int num_descriptors) {
   DisallowHeapAllocation no_allocation;
-  int inobject_properties = map->inobject_properties();
+  int inobject_properties = map->GetInObjectProperties();
 
   for (int i = 0; i < num_descriptors; i++) {
     PropertyDetails details = descriptors->GetDetails(i);
     if (!InobjectUnboxedField(inobject_properties, details)) {
       DCHECK(details.location() != kField ||
              layout_descriptor->IsTagged(details.field_index()));
       continue;
     }
     int field_index = details.field_index();
     layout_descriptor = layout_descriptor->SetRawData(field_index);
     if (details.field_width_in_words() > 1) {
       layout_descriptor = layout_descriptor->SetRawData(field_index + 1);
     }
   }
   return layout_descriptor;
 }
 
 
-// InobjectPropertiesHelper is a helper class for querying whether inobject
+// LayoutDescriptorHelper is a helper class for querying whether inobject
 // property at offset is Double or not.
 LayoutDescriptorHelper::LayoutDescriptorHelper(Map* map)
     : all_fields_tagged_(true),
       header_size_(0),
       layout_descriptor_(LayoutDescriptor::FastPointerLayout()) {
   if (!FLAG_unbox_double_fields) return;
 
   layout_descriptor_ = map->layout_descriptor_gc_safe();
   if (layout_descriptor_->IsFastPointerLayout()) {
     return;
   }
 
-  int inobject_properties = map->inobject_properties();
+  int inobject_properties = map->GetInObjectProperties();
   DCHECK(inobject_properties > 0);
   header_size_ = map->instance_size() - (inobject_properties * kPointerSize);
   DCHECK(header_size_ >= 0);
 
   all_fields_tagged_ = false;
 }
 
 
 bool LayoutDescriptorHelper::IsTagged(int offset_in_bytes) {
   DCHECK(IsAligned(offset_in_bytes, kPointerSize));
   if (all_fields_tagged_) return true;
   // Object headers do not contain non-tagged fields.
   if (offset_in_bytes < header_size_) return true;
   int field_index = (offset_in_bytes - header_size_) / kPointerSize;
 
   return layout_descriptor_->IsTagged(field_index);
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_LAYOUT_DESCRIPTOR_INL_H_