Home | History | Annotate | Download | only in src 
      1 // Copyright 2014 the V8 project authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef V8_FIELD_INDEX_INL_H_
      6 #define V8_FIELD_INDEX_INL_H_
      7 
      8 #include "src/field-index.h"
      9 
     10 namespace v8 {
     11 namespace internal {
     12 
     13 
     14 inline FieldIndex FieldIndex::ForInObjectOffset(int offset, Map* map) {
     15   ASSERT((offset % kPointerSize) == 0);
     16   int index = offset / kPointerSize;
     17   if (map == NULL) {
     18     return FieldIndex(true, index, false, index + 1, 0, true);
     19   }
     20   int first_inobject_offset = map->GetInObjectPropertyOffset(0);
     21   if (offset < first_inobject_offset) {
     22     return FieldIndex(true, index, false, 0, 0, true);
     23   } else {
     24     return FieldIndex::ForPropertyIndex(map, offset / kPointerSize);
     25   }
     26 }
     27 
     28 
     29 inline FieldIndex FieldIndex::ForPropertyIndex(Map* map,
     30                                                int property_index,
     31                                                bool is_double) {
     32   ASSERT(map->instance_type() >= FIRST_NONSTRING_TYPE);
     33   int inobject_properties = map->inobject_properties();
     34   bool is_inobject = property_index < inobject_properties;
     35   int first_inobject_offset;
     36   if (is_inobject) {
     37     first_inobject_offset = map->GetInObjectPropertyOffset(0);
     38   } else {
     39     first_inobject_offset = FixedArray::kHeaderSize;
     40     property_index -= inobject_properties;
     41   }
     42   return FieldIndex(is_inobject,
     43                     property_index + first_inobject_offset / kPointerSize,
     44                     is_double, inobject_properties, first_inobject_offset);
     45 }
     46 
     47 
     48 inline FieldIndex FieldIndex::ForLoadByFieldIndex(Map* map, int orig_index) {
     49   int field_index = orig_index;
     50   int is_inobject = true;
     51   bool is_double = field_index & 1;
     52   int first_inobject_offset = 0;
     53   field_index >>= 1;
     54   if (field_index < 0) {
     55     field_index = -(field_index + 1);
     56     is_inobject = false;
     57     first_inobject_offset = FixedArray::kHeaderSize;
     58     field_index += FixedArray::kHeaderSize / kPointerSize;
     59   } else {
     60     first_inobject_offset = map->GetInObjectPropertyOffset(0);
     61     field_index += JSObject::kHeaderSize / kPointerSize;
     62   }
     63   return FieldIndex(is_inobject, field_index, is_double,
     64                     map->inobject_properties(), first_inobject_offset);
     65 }
     66 
     67 
     68 inline FieldIndex FieldIndex::ForDescriptor(Map* map, int descriptor_index) {
     69   PropertyDetails details =
     70       map->instance_descriptors()->GetDetails(descriptor_index);
     71   int field_index =
     72       map->instance_descriptors()->GetFieldIndex(descriptor_index);
     73   return ForPropertyIndex(map, field_index,
     74                           details.representation().IsDouble());
     75 }
     76 
     77 
     78 inline FieldIndex FieldIndex::ForKeyedLookupCacheIndex(Map* map, int index) {
     79   if (FLAG_compiled_keyed_generic_loads) {
     80     return ForLoadByFieldIndex(map, index);
     81   } else {
     82     return ForPropertyIndex(map, index);
     83   }
     84 }
     85 
     86 
     87 inline int FieldIndex::GetKeyedLookupCacheIndex() const {
     88   if (FLAG_compiled_keyed_generic_loads) {
     89     return GetLoadByFieldIndex();
     90   } else {
     91     return property_index();
     92   }
     93 }
     94 
     95 
     96 } }  // namespace v8::internal
     97 
     98 #endif
     99