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 IsFullTransitionArray() && | 72 return get(kElementsTransitionIndex) != Smi::FromInt(0); |
73 get(kElementsTransitionIndex) != Smi::FromInt(0); | |
74 } | 73 } |
75 | 74 |
76 | 75 |
77 void TransitionArray::set_elements_transition(Map* transition_map, | 76 void TransitionArray::set_elements_transition(Map* transition_map, |
78 WriteBarrierMode mode) { | 77 WriteBarrierMode mode) { |
79 ASSERT(IsFullTransitionArray()); | |
80 Heap* heap = GetHeap(); | 78 Heap* heap = GetHeap(); |
81 WRITE_FIELD(this, kElementsTransitionOffset, transition_map); | 79 WRITE_FIELD(this, kElementsTransitionOffset, transition_map); |
82 CONDITIONAL_WRITE_BARRIER( | 80 CONDITIONAL_WRITE_BARRIER( |
83 heap, this, kElementsTransitionOffset, transition_map, mode); | 81 heap, this, kElementsTransitionOffset, transition_map, mode); |
84 } | 82 } |
85 | 83 |
86 | 84 |
87 DescriptorArray* TransitionArray::descriptors() { | 85 DescriptorArray* TransitionArray::descriptors() { |
88 return DescriptorArray::cast(descriptors_pointer()->value()); | 86 return DescriptorArray::cast(descriptors_pointer()->value()); |
89 } | 87 } |
(...skipping 26 matching lines...) Expand all Loading... |
116 void TransitionArray::set_back_pointer_storage(Object* back_pointer, | 114 void TransitionArray::set_back_pointer_storage(Object* back_pointer, |
117 WriteBarrierMode mode) { | 115 WriteBarrierMode mode) { |
118 Heap* heap = GetHeap(); | 116 Heap* heap = GetHeap(); |
119 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); | 117 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); |
120 CONDITIONAL_WRITE_BARRIER( | 118 CONDITIONAL_WRITE_BARRIER( |
121 heap, this, kBackPointerStorageOffset, back_pointer, mode); | 119 heap, this, kBackPointerStorageOffset, back_pointer, mode); |
122 } | 120 } |
123 | 121 |
124 | 122 |
125 bool TransitionArray::HasPrototypeTransitions() { | 123 bool TransitionArray::HasPrototypeTransitions() { |
126 return IsFullTransitionArray() && | 124 Object* prototype_transitions = get(kPrototypeTransitionsIndex); |
127 get(kPrototypeTransitionsIndex) != Smi::FromInt(0); | 125 return prototype_transitions != Smi::FromInt(0); |
128 } | 126 } |
129 | 127 |
130 | 128 |
131 FixedArray* TransitionArray::GetPrototypeTransitions() { | 129 FixedArray* TransitionArray::GetPrototypeTransitions() { |
132 ASSERT(IsFullTransitionArray()); | |
133 Object* prototype_transitions = get(kPrototypeTransitionsIndex); | 130 Object* prototype_transitions = get(kPrototypeTransitionsIndex); |
134 return FixedArray::cast(prototype_transitions); | 131 return FixedArray::cast(prototype_transitions); |
135 } | 132 } |
136 | 133 |
137 | 134 |
138 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { | 135 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { |
139 ASSERT(HasPrototypeTransitions()); | 136 ASSERT(HasPrototypeTransitions()); |
140 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); | 137 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); |
141 } | 138 } |
142 | 139 |
143 | 140 |
144 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, | 141 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, |
145 WriteBarrierMode mode) { | 142 WriteBarrierMode mode) { |
146 ASSERT(IsFullTransitionArray()); | 143 ASSERT(this != NULL); |
147 ASSERT(transitions->IsFixedArray()); | 144 ASSERT(transitions->IsFixedArray()); |
148 Heap* heap = GetHeap(); | 145 Heap* heap = GetHeap(); |
149 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); | 146 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); |
150 CONDITIONAL_WRITE_BARRIER( | 147 CONDITIONAL_WRITE_BARRIER( |
151 heap, this, kPrototypeTransitionsOffset, transitions, mode); | 148 heap, this, kPrototypeTransitionsOffset, transitions, mode); |
152 } | 149 } |
153 | 150 |
154 | 151 |
155 Object** TransitionArray::GetPrototypeTransitionsSlot() { | 152 Object** TransitionArray::GetPrototypeTransitionsSlot() { |
156 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), | 153 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), |
157 kPrototypeTransitionsOffset); | 154 kPrototypeTransitionsOffset); |
158 } | 155 } |
159 | 156 |
160 | 157 |
161 Object** TransitionArray::GetKeySlot(int transition_number) { | 158 Object** TransitionArray::GetKeySlot(int transition_number) { |
162 ASSERT(!IsSimpleTransition()); | |
163 ASSERT(transition_number < number_of_transitions()); | 159 ASSERT(transition_number < number_of_transitions()); |
164 return HeapObject::RawField( | 160 return HeapObject::RawField( |
165 reinterpret_cast<HeapObject*>(this), | 161 reinterpret_cast<HeapObject*>(this), |
166 OffsetOfElementAt(ToKeyIndex(transition_number))); | 162 OffsetOfElementAt(ToKeyIndex(transition_number))); |
167 } | 163 } |
168 | 164 |
169 | 165 |
170 String* TransitionArray::GetKey(int transition_number) { | 166 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 } | |
177 ASSERT(transition_number < number_of_transitions()); | 167 ASSERT(transition_number < number_of_transitions()); |
178 return String::cast(get(ToKeyIndex(transition_number))); | 168 return String::cast(get(ToKeyIndex(transition_number))); |
179 } | 169 } |
180 | 170 |
181 | 171 |
182 void TransitionArray::SetKey(int transition_number, String* key) { | 172 void TransitionArray::SetKey(int transition_number, String* key) { |
183 ASSERT(!IsSimpleTransition()); | |
184 ASSERT(transition_number < number_of_transitions()); | 173 ASSERT(transition_number < number_of_transitions()); |
185 set(ToKeyIndex(transition_number), key); | 174 set(ToKeyIndex(transition_number), key); |
186 } | 175 } |
187 | 176 |
188 | 177 |
189 Map* TransitionArray::GetTarget(int transition_number) { | 178 Map* TransitionArray::GetTarget(int transition_number) { |
190 if (IsSimpleTransition()) { | |
191 ASSERT(transition_number == kSimpleTransitionIndex); | |
192 return Map::cast(get(kSimpleTransitionTarget)); | |
193 } | |
194 ASSERT(transition_number < number_of_transitions()); | 179 ASSERT(transition_number < number_of_transitions()); |
195 return Map::cast(get(ToTargetIndex(transition_number))); | 180 return Map::cast(get(ToTargetIndex(transition_number))); |
196 } | 181 } |
197 | 182 |
198 | 183 |
199 void TransitionArray::SetTarget(int transition_number, Map* value) { | 184 void TransitionArray::SetTarget(int transition_number, Map* value) { |
200 if (IsSimpleTransition()) { | |
201 ASSERT(transition_number == kSimpleTransitionIndex); | |
202 return set(kSimpleTransitionTarget, value); | |
203 } | |
204 ASSERT(transition_number < number_of_transitions()); | 185 ASSERT(transition_number < number_of_transitions()); |
205 set(ToTargetIndex(transition_number), value); | 186 set(ToTargetIndex(transition_number), value); |
206 } | 187 } |
207 | 188 |
208 | 189 |
209 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { | 190 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { |
210 Map* map = GetTarget(transition_number); | 191 Map* map = GetTarget(transition_number); |
211 DescriptorArray* descriptors = map->instance_descriptors(); | 192 DescriptorArray* descriptors = map->instance_descriptors(); |
212 int descriptor = map->LastAdded(); | 193 int descriptor = map->LastAdded(); |
213 return descriptors->GetDetails(descriptor); | 194 return descriptors->GetDetails(descriptor); |
(...skipping 16 matching lines...) Expand all Loading... |
230 | 211 |
231 | 212 |
232 #undef FIELD_ADDR | 213 #undef FIELD_ADDR |
233 #undef WRITE_FIELD | 214 #undef WRITE_FIELD |
234 #undef CONDITIONAL_WRITE_BARRIER | 215 #undef CONDITIONAL_WRITE_BARRIER |
235 | 216 |
236 | 217 |
237 } } // namespace v8::internal | 218 } } // namespace v8::internal |
238 | 219 |
239 #endif // V8_TRANSITIONS_INL_H_ | 220 #endif // V8_TRANSITIONS_INL_H_ |
OLD | NEW |