Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 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 | DCHECK((offset % kPointerSize) == 0); |
| 16 | int index = offset / kPointerSize; |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 17 | DCHECK(map == NULL || |
| 18 | index < (map->GetInObjectPropertyOffset(0) / kPointerSize + |
| 19 | map->GetInObjectProperties())); |
| 20 | return FieldIndex(true, index, false, 0, 0, true); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 21 | } |
| 22 | |
| 23 | |
| 24 | inline FieldIndex FieldIndex::ForPropertyIndex(Map* map, |
| 25 | int property_index, |
| 26 | bool is_double) { |
| 27 | DCHECK(map->instance_type() >= FIRST_NONSTRING_TYPE); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 28 | int inobject_properties = map->GetInObjectProperties(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 29 | bool is_inobject = property_index < inobject_properties; |
| 30 | int first_inobject_offset; |
| 31 | if (is_inobject) { |
| 32 | first_inobject_offset = map->GetInObjectPropertyOffset(0); |
| 33 | } else { |
| 34 | first_inobject_offset = FixedArray::kHeaderSize; |
| 35 | property_index -= inobject_properties; |
| 36 | } |
| 37 | return FieldIndex(is_inobject, |
| 38 | property_index + first_inobject_offset / kPointerSize, |
| 39 | is_double, inobject_properties, first_inobject_offset); |
| 40 | } |
| 41 | |
| 42 | |
| 43 | // Takes an index as computed by GetLoadFieldByIndex and reconstructs a |
| 44 | // FieldIndex object from it. |
| 45 | inline FieldIndex FieldIndex::ForLoadByFieldIndex(Map* map, int orig_index) { |
| 46 | int field_index = orig_index; |
| 47 | int is_inobject = true; |
| 48 | bool is_double = field_index & 1; |
| 49 | int first_inobject_offset = 0; |
| 50 | field_index >>= 1; |
| 51 | if (field_index < 0) { |
| 52 | field_index = -(field_index + 1); |
| 53 | is_inobject = false; |
| 54 | first_inobject_offset = FixedArray::kHeaderSize; |
| 55 | field_index += FixedArray::kHeaderSize / kPointerSize; |
| 56 | } else { |
| 57 | first_inobject_offset = map->GetInObjectPropertyOffset(0); |
| 58 | field_index += JSObject::kHeaderSize / kPointerSize; |
| 59 | } |
| 60 | FieldIndex result(is_inobject, field_index, is_double, |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 61 | map->GetInObjectProperties(), first_inobject_offset); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 62 | DCHECK(result.GetLoadByFieldIndex() == orig_index); |
| 63 | return result; |
| 64 | } |
| 65 | |
| 66 | |
| 67 | // Returns the index format accepted by the HLoadFieldByIndex instruction. |
| 68 | // (In-object: zero-based from (object start + JSObject::kHeaderSize), |
| 69 | // out-of-object: zero-based from FixedArray::kHeaderSize.) |
| 70 | inline int FieldIndex::GetLoadByFieldIndex() const { |
| 71 | // For efficiency, the LoadByFieldIndex instruction takes an index that is |
| 72 | // optimized for quick access. If the property is inline, the index is |
| 73 | // positive. If it's out-of-line, the encoded index is -raw_index - 1 to |
| 74 | // disambiguate the zero out-of-line index from the zero inobject case. |
| 75 | // The index itself is shifted up by one bit, the lower-most bit |
| 76 | // signifying if the field is a mutable double box (1) or not (0). |
| 77 | int result = index(); |
| 78 | if (is_inobject()) { |
| 79 | result -= JSObject::kHeaderSize / kPointerSize; |
| 80 | } else { |
| 81 | result -= FixedArray::kHeaderSize / kPointerSize; |
| 82 | result = -result - 1; |
| 83 | } |
| 84 | result <<= 1; |
| 85 | return is_double() ? (result | 1) : result; |
| 86 | } |
| 87 | |
| 88 | |
| 89 | inline FieldIndex FieldIndex::ForDescriptor(Map* map, int descriptor_index) { |
| 90 | PropertyDetails details = |
| 91 | map->instance_descriptors()->GetDetails(descriptor_index); |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 92 | int field_index = details.field_index(); |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 93 | return ForPropertyIndex(map, field_index, |
| 94 | details.representation().IsDouble()); |
| 95 | } |
| 96 | |
| 97 | |
| 98 | inline FieldIndex FieldIndex::ForKeyedLookupCacheIndex(Map* map, int index) { |
| 99 | if (FLAG_compiled_keyed_generic_loads) { |
| 100 | return ForLoadByFieldIndex(map, index); |
| 101 | } else { |
| 102 | return ForPropertyIndex(map, index); |
| 103 | } |
| 104 | } |
| 105 | |
| 106 | |
| 107 | inline FieldIndex FieldIndex::FromFieldAccessStubKey(int key) { |
| 108 | return FieldIndex(key); |
| 109 | } |
| 110 | |
| 111 | |
| 112 | inline int FieldIndex::GetKeyedLookupCacheIndex() const { |
| 113 | if (FLAG_compiled_keyed_generic_loads) { |
| 114 | return GetLoadByFieldIndex(); |
| 115 | } else { |
| 116 | return property_index(); |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 121 | } // namespace internal |
| 122 | } // namespace v8 |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 123 | |
| 124 | #endif |