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 10namespace v8 { 11namespace internal { 12 13 14inline FieldIndex FieldIndex::ForInObjectOffset(int offset, Map* map) { 15 DCHECK((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 29inline FieldIndex FieldIndex::ForPropertyIndex(Map* map, 30 int property_index, 31 bool is_double) { 32 DCHECK(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// Takes an index as computed by GetLoadFieldByIndex and reconstructs a 49// FieldIndex object from it. 50inline FieldIndex FieldIndex::ForLoadByFieldIndex(Map* map, int orig_index) { 51 int field_index = orig_index; 52 int is_inobject = true; 53 bool is_double = field_index & 1; 54 int first_inobject_offset = 0; 55 field_index >>= 1; 56 if (field_index < 0) { 57 field_index = -(field_index + 1); 58 is_inobject = false; 59 first_inobject_offset = FixedArray::kHeaderSize; 60 field_index += FixedArray::kHeaderSize / kPointerSize; 61 } else { 62 first_inobject_offset = map->GetInObjectPropertyOffset(0); 63 field_index += JSObject::kHeaderSize / kPointerSize; 64 } 65 FieldIndex result(is_inobject, field_index, is_double, 66 map->inobject_properties(), first_inobject_offset); 67 DCHECK(result.GetLoadByFieldIndex() == orig_index); 68 return result; 69} 70 71 72// Returns the index format accepted by the HLoadFieldByIndex instruction. 73// (In-object: zero-based from (object start + JSObject::kHeaderSize), 74// out-of-object: zero-based from FixedArray::kHeaderSize.) 75inline int FieldIndex::GetLoadByFieldIndex() const { 76 // For efficiency, the LoadByFieldIndex instruction takes an index that is 77 // optimized for quick access. If the property is inline, the index is 78 // positive. If it's out-of-line, the encoded index is -raw_index - 1 to 79 // disambiguate the zero out-of-line index from the zero inobject case. 80 // The index itself is shifted up by one bit, the lower-most bit 81 // signifying if the field is a mutable double box (1) or not (0). 82 int result = index(); 83 if (is_inobject()) { 84 result -= JSObject::kHeaderSize / kPointerSize; 85 } else { 86 result -= FixedArray::kHeaderSize / kPointerSize; 87 result = -result - 1; 88 } 89 result <<= 1; 90 return is_double() ? (result | 1) : result; 91} 92 93 94inline FieldIndex FieldIndex::ForDescriptor(Map* map, int descriptor_index) { 95 PropertyDetails details = 96 map->instance_descriptors()->GetDetails(descriptor_index); 97 int field_index = 98 map->instance_descriptors()->GetFieldIndex(descriptor_index); 99 return ForPropertyIndex(map, field_index, 100 details.representation().IsDouble()); 101} 102 103 104inline FieldIndex FieldIndex::ForKeyedLookupCacheIndex(Map* map, int index) { 105 if (FLAG_compiled_keyed_generic_loads) { 106 return ForLoadByFieldIndex(map, index); 107 } else { 108 return ForPropertyIndex(map, index); 109 } 110} 111 112 113inline FieldIndex FieldIndex::FromFieldAccessStubKey(int key) { 114 return FieldIndex(key); 115} 116 117 118inline int FieldIndex::GetKeyedLookupCacheIndex() const { 119 if (FLAG_compiled_keyed_generic_loads) { 120 return GetLoadByFieldIndex(); 121 } else { 122 return property_index(); 123 } 124} 125 126 127} } // namespace v8::internal 128 129#endif 130