OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 return Map::cast(transition_map); | 62 return Map::cast(transition_map); |
63 } | 63 } |
64 | 64 |
65 | 65 |
66 void TransitionArray::ClearElementsTransition() { | 66 void TransitionArray::ClearElementsTransition() { |
67 WRITE_FIELD(this, kElementsTransitionOffset, Smi::FromInt(0)); | 67 WRITE_FIELD(this, kElementsTransitionOffset, Smi::FromInt(0)); |
68 } | 68 } |
69 | 69 |
70 | 70 |
71 bool TransitionArray::HasElementsTransition() { | 71 bool TransitionArray::HasElementsTransition() { |
72 return get(kElementsTransitionIndex) != Smi::FromInt(0); | 72 return IsFullTransitionArray() && |
| 73 get(kElementsTransitionIndex) != Smi::FromInt(0); |
73 } | 74 } |
74 | 75 |
75 | 76 |
76 void TransitionArray::set_elements_transition(Map* transition_map, | 77 void TransitionArray::set_elements_transition(Map* transition_map, |
77 WriteBarrierMode mode) { | 78 WriteBarrierMode mode) { |
| 79 ASSERT(IsFullTransitionArray()); |
78 Heap* heap = GetHeap(); | 80 Heap* heap = GetHeap(); |
79 WRITE_FIELD(this, kElementsTransitionOffset, transition_map); | 81 WRITE_FIELD(this, kElementsTransitionOffset, transition_map); |
80 CONDITIONAL_WRITE_BARRIER( | 82 CONDITIONAL_WRITE_BARRIER( |
81 heap, this, kElementsTransitionOffset, transition_map, mode); | 83 heap, this, kElementsTransitionOffset, transition_map, mode); |
82 } | 84 } |
83 | 85 |
84 | 86 |
85 DescriptorArray* TransitionArray::descriptors() { | 87 DescriptorArray* TransitionArray::descriptors() { |
86 return DescriptorArray::cast(descriptors_pointer()->value()); | 88 return DescriptorArray::cast(descriptors_pointer()->value()); |
87 } | 89 } |
(...skipping 26 matching lines...) Expand all Loading... |
114 void TransitionArray::set_back_pointer_storage(Object* back_pointer, | 116 void TransitionArray::set_back_pointer_storage(Object* back_pointer, |
115 WriteBarrierMode mode) { | 117 WriteBarrierMode mode) { |
116 Heap* heap = GetHeap(); | 118 Heap* heap = GetHeap(); |
117 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); | 119 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); |
118 CONDITIONAL_WRITE_BARRIER( | 120 CONDITIONAL_WRITE_BARRIER( |
119 heap, this, kBackPointerStorageOffset, back_pointer, mode); | 121 heap, this, kBackPointerStorageOffset, back_pointer, mode); |
120 } | 122 } |
121 | 123 |
122 | 124 |
123 bool TransitionArray::HasPrototypeTransitions() { | 125 bool TransitionArray::HasPrototypeTransitions() { |
124 Object* prototype_transitions = get(kPrototypeTransitionsIndex); | 126 return IsFullTransitionArray() && |
125 return prototype_transitions != Smi::FromInt(0); | 127 get(kPrototypeTransitionsIndex) != Smi::FromInt(0); |
126 } | 128 } |
127 | 129 |
128 | 130 |
129 FixedArray* TransitionArray::GetPrototypeTransitions() { | 131 FixedArray* TransitionArray::GetPrototypeTransitions() { |
| 132 ASSERT(IsFullTransitionArray()); |
130 Object* prototype_transitions = get(kPrototypeTransitionsIndex); | 133 Object* prototype_transitions = get(kPrototypeTransitionsIndex); |
131 return FixedArray::cast(prototype_transitions); | 134 return FixedArray::cast(prototype_transitions); |
132 } | 135 } |
133 | 136 |
134 | 137 |
135 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { | 138 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { |
136 ASSERT(HasPrototypeTransitions()); | 139 ASSERT(HasPrototypeTransitions()); |
137 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); | 140 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); |
138 } | 141 } |
139 | 142 |
140 | 143 |
141 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, | 144 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, |
142 WriteBarrierMode mode) { | 145 WriteBarrierMode mode) { |
143 ASSERT(this != NULL); | 146 ASSERT(IsFullTransitionArray()); |
144 ASSERT(transitions->IsFixedArray()); | 147 ASSERT(transitions->IsFixedArray()); |
145 Heap* heap = GetHeap(); | 148 Heap* heap = GetHeap(); |
146 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); | 149 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); |
147 CONDITIONAL_WRITE_BARRIER( | 150 CONDITIONAL_WRITE_BARRIER( |
148 heap, this, kPrototypeTransitionsOffset, transitions, mode); | 151 heap, this, kPrototypeTransitionsOffset, transitions, mode); |
149 } | 152 } |
150 | 153 |
151 | 154 |
152 Object** TransitionArray::GetPrototypeTransitionsSlot() { | 155 Object** TransitionArray::GetPrototypeTransitionsSlot() { |
153 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), | 156 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), |
154 kPrototypeTransitionsOffset); | 157 kPrototypeTransitionsOffset); |
155 } | 158 } |
156 | 159 |
157 | 160 |
158 Object** TransitionArray::GetKeySlot(int transition_number) { | 161 Object** TransitionArray::GetKeySlot(int transition_number) { |
| 162 ASSERT(!IsSimpleTransition()); |
159 ASSERT(transition_number < number_of_transitions()); | 163 ASSERT(transition_number < number_of_transitions()); |
160 return HeapObject::RawField( | 164 return HeapObject::RawField( |
161 reinterpret_cast<HeapObject*>(this), | 165 reinterpret_cast<HeapObject*>(this), |
162 OffsetOfElementAt(ToKeyIndex(transition_number))); | 166 OffsetOfElementAt(ToKeyIndex(transition_number))); |
163 } | 167 } |
164 | 168 |
165 | 169 |
166 String* TransitionArray::GetKey(int transition_number) { | 170 String* TransitionArray::GetKey(int transition_number) { |
| 171 if (IsSimpleTransition()) { |
| 172 Map* target = GetTarget(kSimpleTransitionIndex); |
| 173 int descriptor = target->LastAdded(); |
| 174 String* key = target->instance_descriptors()->GetKey(descriptor); |
| 175 return key; |
| 176 } |
167 ASSERT(transition_number < number_of_transitions()); | 177 ASSERT(transition_number < number_of_transitions()); |
168 return String::cast(get(ToKeyIndex(transition_number))); | 178 return String::cast(get(ToKeyIndex(transition_number))); |
169 } | 179 } |
170 | 180 |
171 | 181 |
172 void TransitionArray::SetKey(int transition_number, String* key) { | 182 void TransitionArray::SetKey(int transition_number, String* key) { |
| 183 ASSERT(!IsSimpleTransition()); |
173 ASSERT(transition_number < number_of_transitions()); | 184 ASSERT(transition_number < number_of_transitions()); |
174 set(ToKeyIndex(transition_number), key); | 185 set(ToKeyIndex(transition_number), key); |
175 } | 186 } |
176 | 187 |
177 | 188 |
178 Map* TransitionArray::GetTarget(int transition_number) { | 189 Map* TransitionArray::GetTarget(int transition_number) { |
| 190 if (IsSimpleTransition()) { |
| 191 ASSERT(transition_number == kSimpleTransitionIndex); |
| 192 return Map::cast(get(kSimpleTransitionTarget)); |
| 193 } |
179 ASSERT(transition_number < number_of_transitions()); | 194 ASSERT(transition_number < number_of_transitions()); |
180 return Map::cast(get(ToTargetIndex(transition_number))); | 195 return Map::cast(get(ToTargetIndex(transition_number))); |
181 } | 196 } |
182 | 197 |
183 | 198 |
184 void TransitionArray::SetTarget(int transition_number, Map* value) { | 199 void TransitionArray::SetTarget(int transition_number, Map* value) { |
| 200 if (IsSimpleTransition()) { |
| 201 ASSERT(transition_number == kSimpleTransitionIndex); |
| 202 return set(kSimpleTransitionTarget, value); |
| 203 } |
185 ASSERT(transition_number < number_of_transitions()); | 204 ASSERT(transition_number < number_of_transitions()); |
186 set(ToTargetIndex(transition_number), value); | 205 set(ToTargetIndex(transition_number), value); |
187 } | 206 } |
188 | 207 |
189 | 208 |
190 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { | 209 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { |
191 Map* map = GetTarget(transition_number); | 210 Map* map = GetTarget(transition_number); |
192 DescriptorArray* descriptors = map->instance_descriptors(); | 211 DescriptorArray* descriptors = map->instance_descriptors(); |
193 int descriptor = map->LastAdded(); | 212 int descriptor = map->LastAdded(); |
194 return descriptors->GetDetails(descriptor); | 213 return descriptors->GetDetails(descriptor); |
(...skipping 16 matching lines...) Expand all Loading... |
211 | 230 |
212 | 231 |
213 #undef FIELD_ADDR | 232 #undef FIELD_ADDR |
214 #undef WRITE_FIELD | 233 #undef WRITE_FIELD |
215 #undef CONDITIONAL_WRITE_BARRIER | 234 #undef CONDITIONAL_WRITE_BARRIER |
216 | 235 |
217 | 236 |
218 } } // namespace v8::internal | 237 } } // namespace v8::internal |
219 | 238 |
220 #endif // V8_TRANSITIONS_INL_H_ | 239 #endif // V8_TRANSITIONS_INL_H_ |
OLD | NEW |