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(get(kDescriptorsIndex)); |
89 } | 87 } |
90 | 88 |
91 | 89 |
92 void TransitionArray::set_descriptors(DescriptorArray* descriptors) { | 90 void TransitionArray::set_descriptors(DescriptorArray* descriptors, |
93 ASSERT(!this->descriptors()->IsDescriptorArray() || | 91 WriteBarrierMode mode) { |
94 descriptors->number_of_descriptors() == 0 || | 92 Heap* heap = GetHeap(); |
95 descriptors->HasEnumCache() || | 93 WRITE_FIELD(this, kDescriptorsOffset, descriptors); |
96 !this->descriptors()->HasEnumCache()); | 94 CONDITIONAL_WRITE_BARRIER( |
97 descriptors_pointer()->set_value(descriptors); | 95 heap, this, kDescriptorsOffset, descriptors, mode); |
98 } | 96 } |
99 | 97 |
100 | 98 |
101 JSGlobalPropertyCell* TransitionArray::descriptors_pointer() { | 99 Object** TransitionArray::GetDescriptorsSlot() { |
102 return JSGlobalPropertyCell::cast(get(kDescriptorsPointerIndex)); | 100 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), |
| 101 kDescriptorsOffset); |
103 } | 102 } |
104 | 103 |
105 | 104 |
106 void TransitionArray::set_descriptors_pointer(JSGlobalPropertyCell* pointer) { | |
107 set(kDescriptorsPointerIndex, pointer); | |
108 } | |
109 | |
110 | |
111 Object* TransitionArray::back_pointer_storage() { | 105 Object* TransitionArray::back_pointer_storage() { |
112 return get(kBackPointerStorageIndex); | 106 return get(kBackPointerStorageIndex); |
113 } | 107 } |
114 | 108 |
115 | 109 |
116 void TransitionArray::set_back_pointer_storage(Object* back_pointer, | 110 void TransitionArray::set_back_pointer_storage(Object* back_pointer, |
117 WriteBarrierMode mode) { | 111 WriteBarrierMode mode) { |
118 Heap* heap = GetHeap(); | 112 Heap* heap = GetHeap(); |
119 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); | 113 WRITE_FIELD(this, kBackPointerStorageOffset, back_pointer); |
120 CONDITIONAL_WRITE_BARRIER( | 114 CONDITIONAL_WRITE_BARRIER( |
121 heap, this, kBackPointerStorageOffset, back_pointer, mode); | 115 heap, this, kBackPointerStorageOffset, back_pointer, mode); |
122 } | 116 } |
123 | 117 |
124 | 118 |
125 bool TransitionArray::HasPrototypeTransitions() { | 119 bool TransitionArray::HasPrototypeTransitions() { |
126 return IsFullTransitionArray() && | 120 Object* prototype_transitions = get(kPrototypeTransitionsIndex); |
127 get(kPrototypeTransitionsIndex) != Smi::FromInt(0); | 121 return prototype_transitions != Smi::FromInt(0); |
128 } | 122 } |
129 | 123 |
130 | 124 |
131 FixedArray* TransitionArray::GetPrototypeTransitions() { | 125 FixedArray* TransitionArray::GetPrototypeTransitions() { |
132 ASSERT(IsFullTransitionArray()); | |
133 Object* prototype_transitions = get(kPrototypeTransitionsIndex); | 126 Object* prototype_transitions = get(kPrototypeTransitionsIndex); |
134 return FixedArray::cast(prototype_transitions); | 127 return FixedArray::cast(prototype_transitions); |
135 } | 128 } |
136 | 129 |
137 | 130 |
138 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { | 131 HeapObject* TransitionArray::UncheckedPrototypeTransitions() { |
139 ASSERT(HasPrototypeTransitions()); | 132 ASSERT(HasPrototypeTransitions()); |
140 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); | 133 return reinterpret_cast<HeapObject*>(get(kPrototypeTransitionsIndex)); |
141 } | 134 } |
142 | 135 |
143 | 136 |
144 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, | 137 void TransitionArray::SetPrototypeTransitions(FixedArray* transitions, |
145 WriteBarrierMode mode) { | 138 WriteBarrierMode mode) { |
146 ASSERT(IsFullTransitionArray()); | 139 ASSERT(this != NULL); |
147 ASSERT(transitions->IsFixedArray()); | 140 ASSERT(transitions->IsFixedArray()); |
148 Heap* heap = GetHeap(); | 141 Heap* heap = GetHeap(); |
149 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); | 142 WRITE_FIELD(this, kPrototypeTransitionsOffset, transitions); |
150 CONDITIONAL_WRITE_BARRIER( | 143 CONDITIONAL_WRITE_BARRIER( |
151 heap, this, kPrototypeTransitionsOffset, transitions, mode); | 144 heap, this, kPrototypeTransitionsOffset, transitions, mode); |
152 } | 145 } |
153 | 146 |
154 | 147 |
155 Object** TransitionArray::GetPrototypeTransitionsSlot() { | 148 Object** TransitionArray::GetPrototypeTransitionsSlot() { |
156 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), | 149 return HeapObject::RawField(reinterpret_cast<HeapObject*>(this), |
157 kPrototypeTransitionsOffset); | 150 kPrototypeTransitionsOffset); |
158 } | 151 } |
159 | 152 |
160 | 153 |
161 Object** TransitionArray::GetKeySlot(int transition_number) { | 154 Object** TransitionArray::GetKeySlot(int transition_number) { |
162 ASSERT(!IsSimpleTransition()); | |
163 ASSERT(transition_number < number_of_transitions()); | 155 ASSERT(transition_number < number_of_transitions()); |
164 return HeapObject::RawField( | 156 return HeapObject::RawField( |
165 reinterpret_cast<HeapObject*>(this), | 157 reinterpret_cast<HeapObject*>(this), |
166 OffsetOfElementAt(ToKeyIndex(transition_number))); | 158 OffsetOfElementAt(ToKeyIndex(transition_number))); |
167 } | 159 } |
168 | 160 |
169 | 161 |
170 String* TransitionArray::GetKey(int transition_number) { | 162 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()); | 163 ASSERT(transition_number < number_of_transitions()); |
178 return String::cast(get(ToKeyIndex(transition_number))); | 164 return String::cast(get(ToKeyIndex(transition_number))); |
179 } | 165 } |
180 | 166 |
181 | 167 |
182 void TransitionArray::SetKey(int transition_number, String* key) { | 168 void TransitionArray::SetKey(int transition_number, String* key) { |
183 ASSERT(!IsSimpleTransition()); | |
184 ASSERT(transition_number < number_of_transitions()); | 169 ASSERT(transition_number < number_of_transitions()); |
185 set(ToKeyIndex(transition_number), key); | 170 set(ToKeyIndex(transition_number), key); |
186 } | 171 } |
187 | 172 |
188 | 173 |
189 Map* TransitionArray::GetTarget(int transition_number) { | 174 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()); | 175 ASSERT(transition_number < number_of_transitions()); |
195 return Map::cast(get(ToTargetIndex(transition_number))); | 176 return Map::cast(get(ToTargetIndex(transition_number))); |
196 } | 177 } |
197 | 178 |
198 | 179 |
199 void TransitionArray::SetTarget(int transition_number, Map* value) { | 180 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()); | 181 ASSERT(transition_number < number_of_transitions()); |
205 set(ToTargetIndex(transition_number), value); | 182 set(ToTargetIndex(transition_number), value); |
206 } | 183 } |
207 | 184 |
208 | 185 |
209 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { | 186 PropertyDetails TransitionArray::GetTargetDetails(int transition_number) { |
210 Map* map = GetTarget(transition_number); | 187 Map* map = GetTarget(transition_number); |
211 DescriptorArray* descriptors = map->instance_descriptors(); | 188 DescriptorArray* descriptors = map->instance_descriptors(); |
212 int descriptor = map->LastAdded(); | 189 int descriptor = map->LastAdded(); |
213 return descriptors->GetDetails(descriptor); | 190 return descriptors->GetDetails(descriptor); |
214 } | 191 } |
215 | 192 |
216 | 193 |
217 int TransitionArray::Search(String* name) { | 194 int TransitionArray::Search(String* name) { |
218 return internal::Search<ALL_ENTRIES>(this, name); | 195 return internal::Search(this, name); |
219 } | 196 } |
220 | 197 |
221 | 198 |
222 void TransitionArray::NoIncrementalWriteBarrierSet(int transition_number, | 199 void TransitionArray::Set(int transition_number, |
223 String* key, | 200 String* key, |
224 Map* target) { | 201 Map* target, |
225 FixedArray::NoIncrementalWriteBarrierSet( | 202 const WhitenessWitness&) { |
226 this, ToKeyIndex(transition_number), key); | 203 NoIncrementalWriteBarrierSet(this, |
227 FixedArray::NoIncrementalWriteBarrierSet( | 204 ToKeyIndex(transition_number), |
228 this, ToTargetIndex(transition_number), target); | 205 key); |
| 206 NoIncrementalWriteBarrierSet(this, |
| 207 ToTargetIndex(transition_number), |
| 208 target); |
229 } | 209 } |
230 | 210 |
231 | 211 |
232 #undef FIELD_ADDR | 212 #undef FIELD_ADDR |
233 #undef WRITE_FIELD | 213 #undef WRITE_FIELD |
234 #undef CONDITIONAL_WRITE_BARRIER | 214 #undef CONDITIONAL_WRITE_BARRIER |
235 | 215 |
236 | 216 |
237 } } // namespace v8::internal | 217 } } // namespace v8::internal |
238 | 218 |
239 #endif // V8_TRANSITIONS_INL_H_ | 219 #endif // V8_TRANSITIONS_INL_H_ |
OLD | NEW |