OLD | NEW |
---|---|
1 // Copyright 2006-2009 the V8 project authors. All rights reserved. | 1 // Copyright 2006-2009 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 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
96 Object* StubCache::ComputeLoadField(String* name, | 96 Object* StubCache::ComputeLoadField(String* name, |
97 JSObject* receiver, | 97 JSObject* receiver, |
98 JSObject* holder, | 98 JSObject* holder, |
99 int field_index) { | 99 int field_index) { |
100 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD); | 100 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, FIELD); |
101 Object* code = receiver->map()->FindInCodeCache(name, flags); | 101 Object* code = receiver->map()->FindInCodeCache(name, flags); |
102 if (code->IsUndefined()) { | 102 if (code->IsUndefined()) { |
103 LoadStubCompiler compiler; | 103 LoadStubCompiler compiler; |
104 code = compiler.CompileLoadField(receiver, holder, field_index, name); | 104 code = compiler.CompileLoadField(receiver, holder, field_index, name); |
105 if (code->IsFailure()) return code; | 105 if (code->IsFailure()) return code; |
106 LOG(CodeCreateEvent("LoadIC", Code::cast(code), name)); | 106 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); |
107 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 107 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
108 if (result->IsFailure()) return code; | 108 if (result->IsFailure()) return code; |
109 } | 109 } |
110 return Set(name, receiver->map(), Code::cast(code)); | 110 return Set(name, receiver->map(), Code::cast(code)); |
111 } | 111 } |
112 | 112 |
113 | 113 |
114 Object* StubCache::ComputeLoadCallback(String* name, | 114 Object* StubCache::ComputeLoadCallback(String* name, |
115 JSObject* receiver, | 115 JSObject* receiver, |
116 JSObject* holder, | 116 JSObject* holder, |
117 AccessorInfo* callback) { | 117 AccessorInfo* callback) { |
118 ASSERT(v8::ToCData<Address>(callback->getter()) != 0); | 118 ASSERT(v8::ToCData<Address>(callback->getter()) != 0); |
119 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS); | 119 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, CALLBACKS); |
120 Object* code = receiver->map()->FindInCodeCache(name, flags); | 120 Object* code = receiver->map()->FindInCodeCache(name, flags); |
121 if (code->IsUndefined()) { | 121 if (code->IsUndefined()) { |
122 LoadStubCompiler compiler; | 122 LoadStubCompiler compiler; |
123 code = compiler.CompileLoadCallback(receiver, holder, callback, name); | 123 code = compiler.CompileLoadCallback(receiver, holder, callback, name); |
124 if (code->IsFailure()) return code; | 124 if (code->IsFailure()) return code; |
125 LOG(CodeCreateEvent("LoadIC", Code::cast(code), name)); | 125 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); |
126 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 126 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
127 if (result->IsFailure()) return code; | 127 if (result->IsFailure()) return code; |
128 } | 128 } |
129 return Set(name, receiver->map(), Code::cast(code)); | 129 return Set(name, receiver->map(), Code::cast(code)); |
130 } | 130 } |
131 | 131 |
132 | 132 |
133 Object* StubCache::ComputeLoadConstant(String* name, | 133 Object* StubCache::ComputeLoadConstant(String* name, |
134 JSObject* receiver, | 134 JSObject* receiver, |
135 JSObject* holder, | 135 JSObject* holder, |
136 Object* value) { | 136 Object* value) { |
137 Code::Flags flags = | 137 Code::Flags flags = |
138 Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION); | 138 Code::ComputeMonomorphicFlags(Code::LOAD_IC, CONSTANT_FUNCTION); |
139 Object* code = receiver->map()->FindInCodeCache(name, flags); | 139 Object* code = receiver->map()->FindInCodeCache(name, flags); |
140 if (code->IsUndefined()) { | 140 if (code->IsUndefined()) { |
141 LoadStubCompiler compiler; | 141 LoadStubCompiler compiler; |
142 code = compiler.CompileLoadConstant(receiver, holder, value, name); | 142 code = compiler.CompileLoadConstant(receiver, holder, value, name); |
143 if (code->IsFailure()) return code; | 143 if (code->IsFailure()) return code; |
144 LOG(CodeCreateEvent("LoadIC", Code::cast(code), name)); | 144 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); |
145 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 145 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
146 if (result->IsFailure()) return code; | 146 if (result->IsFailure()) return code; |
147 } | 147 } |
148 return Set(name, receiver->map(), Code::cast(code)); | 148 return Set(name, receiver->map(), Code::cast(code)); |
149 } | 149 } |
150 | 150 |
151 | 151 |
152 Object* StubCache::ComputeLoadInterceptor(String* name, | 152 Object* StubCache::ComputeLoadInterceptor(String* name, |
153 JSObject* receiver, | 153 JSObject* receiver, |
154 JSObject* holder) { | 154 JSObject* holder) { |
155 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR); | 155 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, INTERCEPTOR); |
156 Object* code = receiver->map()->FindInCodeCache(name, flags); | 156 Object* code = receiver->map()->FindInCodeCache(name, flags); |
157 if (code->IsUndefined()) { | 157 if (code->IsUndefined()) { |
158 LoadStubCompiler compiler; | 158 LoadStubCompiler compiler; |
159 code = compiler.CompileLoadInterceptor(receiver, holder, name); | 159 code = compiler.CompileLoadInterceptor(receiver, holder, name); |
160 if (code->IsFailure()) return code; | 160 if (code->IsFailure()) return code; |
161 LOG(CodeCreateEvent("LoadIC", Code::cast(code), name)); | 161 LOG(CodeCreateEvent(Logger::LOAD_IC_TAG, Code::cast(code), name)); |
162 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 162 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
163 if (result->IsFailure()) return code; | 163 if (result->IsFailure()) return code; |
164 } | 164 } |
165 return Set(name, receiver->map(), Code::cast(code)); | 165 return Set(name, receiver->map(), Code::cast(code)); |
166 } | 166 } |
167 | 167 |
168 | 168 |
169 Object* StubCache::ComputeLoadNormal(String* name, JSObject* receiver) { | 169 Object* StubCache::ComputeLoadNormal(String* name, JSObject* receiver) { |
170 Code* code = Builtins::builtin(Builtins::LoadIC_Normal); | 170 Code* code = Builtins::builtin(Builtins::LoadIC_Normal); |
171 return Set(name, receiver->map(), code); | 171 return Set(name, receiver->map(), code); |
172 } | 172 } |
173 | 173 |
174 | 174 |
175 Object* StubCache::ComputeKeyedLoadField(String* name, | 175 Object* StubCache::ComputeKeyedLoadField(String* name, |
176 JSObject* receiver, | 176 JSObject* receiver, |
177 JSObject* holder, | 177 JSObject* holder, |
178 int field_index) { | 178 int field_index) { |
179 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD); | 179 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, FIELD); |
180 Object* code = receiver->map()->FindInCodeCache(name, flags); | 180 Object* code = receiver->map()->FindInCodeCache(name, flags); |
181 if (code->IsUndefined()) { | 181 if (code->IsUndefined()) { |
182 KeyedLoadStubCompiler compiler; | 182 KeyedLoadStubCompiler compiler; |
183 code = compiler.CompileLoadField(name, receiver, holder, field_index); | 183 code = compiler.CompileLoadField(name, receiver, holder, field_index); |
184 if (code->IsFailure()) return code; | 184 if (code->IsFailure()) return code; |
185 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 185 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
186 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 186 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
187 if (result->IsFailure()) return result; | 187 if (result->IsFailure()) return result; |
188 } | 188 } |
189 return code; | 189 return code; |
190 } | 190 } |
191 | 191 |
192 | 192 |
193 Object* StubCache::ComputeKeyedLoadConstant(String* name, | 193 Object* StubCache::ComputeKeyedLoadConstant(String* name, |
194 JSObject* receiver, | 194 JSObject* receiver, |
195 JSObject* holder, | 195 JSObject* holder, |
196 Object* value) { | 196 Object* value) { |
197 Code::Flags flags = | 197 Code::Flags flags = |
198 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION); | 198 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CONSTANT_FUNCTION); |
199 Object* code = receiver->map()->FindInCodeCache(name, flags); | 199 Object* code = receiver->map()->FindInCodeCache(name, flags); |
200 if (code->IsUndefined()) { | 200 if (code->IsUndefined()) { |
201 KeyedLoadStubCompiler compiler; | 201 KeyedLoadStubCompiler compiler; |
202 code = compiler.CompileLoadConstant(name, receiver, holder, value); | 202 code = compiler.CompileLoadConstant(name, receiver, holder, value); |
203 if (code->IsFailure()) return code; | 203 if (code->IsFailure()) return code; |
204 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 204 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
205 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 205 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
206 if (result->IsFailure()) return result; | 206 if (result->IsFailure()) return result; |
207 } | 207 } |
208 return code; | 208 return code; |
209 } | 209 } |
210 | 210 |
211 | 211 |
212 Object* StubCache::ComputeKeyedLoadInterceptor(String* name, | 212 Object* StubCache::ComputeKeyedLoadInterceptor(String* name, |
213 JSObject* receiver, | 213 JSObject* receiver, |
214 JSObject* holder) { | 214 JSObject* holder) { |
215 Code::Flags flags = | 215 Code::Flags flags = |
216 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR); | 216 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, INTERCEPTOR); |
217 Object* code = receiver->map()->FindInCodeCache(name, flags); | 217 Object* code = receiver->map()->FindInCodeCache(name, flags); |
218 if (code->IsUndefined()) { | 218 if (code->IsUndefined()) { |
219 KeyedLoadStubCompiler compiler; | 219 KeyedLoadStubCompiler compiler; |
220 code = compiler.CompileLoadInterceptor(receiver, holder, name); | 220 code = compiler.CompileLoadInterceptor(receiver, holder, name); |
221 if (code->IsFailure()) return code; | 221 if (code->IsFailure()) return code; |
222 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 222 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
223 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 223 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
224 if (result->IsFailure()) return result; | 224 if (result->IsFailure()) return result; |
225 } | 225 } |
226 return code; | 226 return code; |
227 } | 227 } |
228 | 228 |
229 | 229 |
230 Object* StubCache::ComputeKeyedLoadCallback(String* name, | 230 Object* StubCache::ComputeKeyedLoadCallback(String* name, |
231 JSObject* receiver, | 231 JSObject* receiver, |
232 JSObject* holder, | 232 JSObject* holder, |
233 AccessorInfo* callback) { | 233 AccessorInfo* callback) { |
234 Code::Flags flags = | 234 Code::Flags flags = |
235 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); | 235 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); |
236 Object* code = receiver->map()->FindInCodeCache(name, flags); | 236 Object* code = receiver->map()->FindInCodeCache(name, flags); |
237 if (code->IsUndefined()) { | 237 if (code->IsUndefined()) { |
238 KeyedLoadStubCompiler compiler; | 238 KeyedLoadStubCompiler compiler; |
239 code = compiler.CompileLoadCallback(name, receiver, holder, callback); | 239 code = compiler.CompileLoadCallback(name, receiver, holder, callback); |
240 if (code->IsFailure()) return code; | 240 if (code->IsFailure()) return code; |
241 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 241 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
242 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 242 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
243 if (result->IsFailure()) return result; | 243 if (result->IsFailure()) return result; |
244 } | 244 } |
245 return code; | 245 return code; |
246 } | 246 } |
247 | 247 |
248 | 248 |
249 | 249 |
250 Object* StubCache::ComputeKeyedLoadArrayLength(String* name, | 250 Object* StubCache::ComputeKeyedLoadArrayLength(String* name, |
251 JSArray* receiver) { | 251 JSArray* receiver) { |
252 Code::Flags flags = | 252 Code::Flags flags = |
253 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); | 253 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); |
254 Object* code = receiver->map()->FindInCodeCache(name, flags); | 254 Object* code = receiver->map()->FindInCodeCache(name, flags); |
255 if (code->IsUndefined()) { | 255 if (code->IsUndefined()) { |
256 KeyedLoadStubCompiler compiler; | 256 KeyedLoadStubCompiler compiler; |
257 code = compiler.CompileLoadArrayLength(name); | 257 code = compiler.CompileLoadArrayLength(name); |
258 if (code->IsFailure()) return code; | 258 if (code->IsFailure()) return code; |
259 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 259 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
260 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 260 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
261 if (result->IsFailure()) return result; | 261 if (result->IsFailure()) return result; |
262 } | 262 } |
263 return code; | 263 return code; |
264 } | 264 } |
265 | 265 |
266 | 266 |
267 Object* StubCache::ComputeKeyedLoadStringLength(String* name, | 267 Object* StubCache::ComputeKeyedLoadStringLength(String* name, |
268 String* receiver) { | 268 String* receiver) { |
269 Code::Flags flags = | 269 Code::Flags flags = |
270 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); | 270 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); |
271 Object* code = receiver->map()->FindInCodeCache(name, flags); | 271 Object* code = receiver->map()->FindInCodeCache(name, flags); |
272 if (code->IsUndefined()) { | 272 if (code->IsUndefined()) { |
273 KeyedLoadStubCompiler compiler; | 273 KeyedLoadStubCompiler compiler; |
274 code = compiler.CompileLoadStringLength(name); | 274 code = compiler.CompileLoadStringLength(name); |
275 if (code->IsFailure()) return code; | 275 if (code->IsFailure()) return code; |
276 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 276 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
277 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 277 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
278 if (result->IsFailure()) return result; | 278 if (result->IsFailure()) return result; |
279 } | 279 } |
280 return code; | 280 return code; |
281 } | 281 } |
282 | 282 |
283 | 283 |
284 Object* StubCache::ComputeKeyedLoadFunctionPrototype(String* name, | 284 Object* StubCache::ComputeKeyedLoadFunctionPrototype(String* name, |
285 JSFunction* receiver) { | 285 JSFunction* receiver) { |
286 Code::Flags flags = | 286 Code::Flags flags = |
287 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); | 287 Code::ComputeMonomorphicFlags(Code::KEYED_LOAD_IC, CALLBACKS); |
288 Object* code = receiver->map()->FindInCodeCache(name, flags); | 288 Object* code = receiver->map()->FindInCodeCache(name, flags); |
289 if (code->IsUndefined()) { | 289 if (code->IsUndefined()) { |
290 KeyedLoadStubCompiler compiler; | 290 KeyedLoadStubCompiler compiler; |
291 code = compiler.CompileLoadFunctionPrototype(name); | 291 code = compiler.CompileLoadFunctionPrototype(name); |
292 if (code->IsFailure()) return code; | 292 if (code->IsFailure()) return code; |
293 LOG(CodeCreateEvent("KeyedLoadIC", Code::cast(code), name)); | 293 LOG(CodeCreateEvent(Logger::KEYED_LOAD_IC_TAG, Code::cast(code), name)); |
294 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 294 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
295 if (result->IsFailure()) return result; | 295 if (result->IsFailure()) return result; |
296 } | 296 } |
297 return code; | 297 return code; |
298 } | 298 } |
299 | 299 |
300 | 300 |
301 Object* StubCache::ComputeStoreField(String* name, | 301 Object* StubCache::ComputeStoreField(String* name, |
302 JSObject* receiver, | 302 JSObject* receiver, |
303 int field_index, | 303 int field_index, |
304 Map* transition) { | 304 Map* transition) { |
305 PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION; | 305 PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION; |
306 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, type); | 306 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, type); |
307 Object* code = receiver->map()->FindInCodeCache(name, flags); | 307 Object* code = receiver->map()->FindInCodeCache(name, flags); |
308 if (code->IsUndefined()) { | 308 if (code->IsUndefined()) { |
309 StoreStubCompiler compiler; | 309 StoreStubCompiler compiler; |
310 code = compiler.CompileStoreField(receiver, field_index, transition, name); | 310 code = compiler.CompileStoreField(receiver, field_index, transition, name); |
311 if (code->IsFailure()) return code; | 311 if (code->IsFailure()) return code; |
312 LOG(CodeCreateEvent("StoreIC", Code::cast(code), name)); | 312 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); |
313 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 313 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
314 if (result->IsFailure()) return result; | 314 if (result->IsFailure()) return result; |
315 } | 315 } |
316 return Set(name, receiver->map(), Code::cast(code)); | 316 return Set(name, receiver->map(), Code::cast(code)); |
317 } | 317 } |
318 | 318 |
319 | 319 |
320 Object* StubCache::ComputeStoreCallback(String* name, | 320 Object* StubCache::ComputeStoreCallback(String* name, |
321 JSObject* receiver, | 321 JSObject* receiver, |
322 AccessorInfo* callback) { | 322 AccessorInfo* callback) { |
323 ASSERT(v8::ToCData<Address>(callback->setter()) != 0); | 323 ASSERT(v8::ToCData<Address>(callback->setter()) != 0); |
324 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, CALLBACKS); | 324 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, CALLBACKS); |
325 Object* code = receiver->map()->FindInCodeCache(name, flags); | 325 Object* code = receiver->map()->FindInCodeCache(name, flags); |
326 if (code->IsUndefined()) { | 326 if (code->IsUndefined()) { |
327 StoreStubCompiler compiler; | 327 StoreStubCompiler compiler; |
328 code = compiler.CompileStoreCallback(receiver, callback, name); | 328 code = compiler.CompileStoreCallback(receiver, callback, name); |
329 if (code->IsFailure()) return code; | 329 if (code->IsFailure()) return code; |
330 LOG(CodeCreateEvent("StoreIC", Code::cast(code), name)); | 330 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); |
331 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 331 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
332 if (result->IsFailure()) return result; | 332 if (result->IsFailure()) return result; |
333 } | 333 } |
334 return Set(name, receiver->map(), Code::cast(code)); | 334 return Set(name, receiver->map(), Code::cast(code)); |
335 } | 335 } |
336 | 336 |
337 | 337 |
338 Object* StubCache::ComputeStoreInterceptor(String* name, | 338 Object* StubCache::ComputeStoreInterceptor(String* name, |
339 JSObject* receiver) { | 339 JSObject* receiver) { |
340 Code::Flags flags = | 340 Code::Flags flags = |
341 Code::ComputeMonomorphicFlags(Code::STORE_IC, INTERCEPTOR); | 341 Code::ComputeMonomorphicFlags(Code::STORE_IC, INTERCEPTOR); |
342 Object* code = receiver->map()->FindInCodeCache(name, flags); | 342 Object* code = receiver->map()->FindInCodeCache(name, flags); |
343 if (code->IsUndefined()) { | 343 if (code->IsUndefined()) { |
344 StoreStubCompiler compiler; | 344 StoreStubCompiler compiler; |
345 code = compiler.CompileStoreInterceptor(receiver, name); | 345 code = compiler.CompileStoreInterceptor(receiver, name); |
346 if (code->IsFailure()) return code; | 346 if (code->IsFailure()) return code; |
347 LOG(CodeCreateEvent("StoreIC", Code::cast(code), name)); | 347 LOG(CodeCreateEvent(Logger::STORE_IC_TAG, Code::cast(code), name)); |
348 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 348 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
349 if (result->IsFailure()) return result; | 349 if (result->IsFailure()) return result; |
350 } | 350 } |
351 return Set(name, receiver->map(), Code::cast(code)); | 351 return Set(name, receiver->map(), Code::cast(code)); |
352 } | 352 } |
353 | 353 |
354 | 354 |
355 Object* StubCache::ComputeKeyedStoreField(String* name, JSObject* receiver, | 355 Object* StubCache::ComputeKeyedStoreField(String* name, JSObject* receiver, |
356 int field_index, Map* transition) { | 356 int field_index, Map* transition) { |
357 PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION; | 357 PropertyType type = (transition == NULL) ? FIELD : MAP_TRANSITION; |
358 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, type); | 358 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::KEYED_STORE_IC, type); |
359 Object* code = receiver->map()->FindInCodeCache(name, flags); | 359 Object* code = receiver->map()->FindInCodeCache(name, flags); |
360 if (code->IsUndefined()) { | 360 if (code->IsUndefined()) { |
361 KeyedStoreStubCompiler compiler; | 361 KeyedStoreStubCompiler compiler; |
362 code = compiler.CompileStoreField(receiver, field_index, transition, name); | 362 code = compiler.CompileStoreField(receiver, field_index, transition, name); |
363 if (code->IsFailure()) return code; | 363 if (code->IsFailure()) return code; |
364 LOG(CodeCreateEvent("KeyedStoreIC", Code::cast(code), name)); | 364 LOG(CodeCreateEvent(Logger::KEYED_STORE_IC_TAG, Code::cast(code), name)); |
365 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); | 365 Object* result = receiver->map()->UpdateCodeCache(name, Code::cast(code)); |
366 if (result->IsFailure()) return result; | 366 if (result->IsFailure()) return result; |
367 } | 367 } |
368 return code; | 368 return code; |
369 } | 369 } |
370 | 370 |
371 | 371 |
372 Object* StubCache::ComputeCallConstant(int argc, | 372 Object* StubCache::ComputeCallConstant(int argc, |
373 InLoopFlag in_loop, | 373 InLoopFlag in_loop, |
374 String* name, | 374 String* name, |
(...skipping 30 matching lines...) Expand all Loading... | |
405 } | 405 } |
406 // If the function hasn't been compiled yet, we cannot do it now | 406 // If the function hasn't been compiled yet, we cannot do it now |
407 // because it may cause GC. To avoid this issue, we return an | 407 // because it may cause GC. To avoid this issue, we return an |
408 // internal error which will make sure we do not update any | 408 // internal error which will make sure we do not update any |
409 // caches. | 409 // caches. |
410 if (!function->is_compiled()) return Failure::InternalError(); | 410 if (!function->is_compiled()) return Failure::InternalError(); |
411 // Compile the stub - only create stubs for fully compiled functions. | 411 // Compile the stub - only create stubs for fully compiled functions. |
412 CallStubCompiler compiler(argc); | 412 CallStubCompiler compiler(argc); |
413 code = compiler.CompileCallConstant(object, holder, function, check, flags); | 413 code = compiler.CompileCallConstant(object, holder, function, check, flags); |
414 if (code->IsFailure()) return code; | 414 if (code->IsFailure()) return code; |
415 LOG(CodeCreateEvent("CallIC", Code::cast(code), name)); | 415 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name)); |
416 Object* result = map->UpdateCodeCache(name, Code::cast(code)); | 416 Object* result = map->UpdateCodeCache(name, Code::cast(code)); |
417 if (result->IsFailure()) return result; | 417 if (result->IsFailure()) return result; |
418 } | 418 } |
419 return Set(name, map, Code::cast(code)); | 419 return Set(name, map, Code::cast(code)); |
420 } | 420 } |
421 | 421 |
422 | 422 |
423 Object* StubCache::ComputeCallField(int argc, | 423 Object* StubCache::ComputeCallField(int argc, |
424 InLoopFlag in_loop, | 424 InLoopFlag in_loop, |
425 String* name, | 425 String* name, |
(...skipping 12 matching lines...) Expand all Loading... | |
438 | 438 |
439 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, | 439 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, |
440 FIELD, | 440 FIELD, |
441 in_loop, | 441 in_loop, |
442 argc); | 442 argc); |
443 Object* code = map->FindInCodeCache(name, flags); | 443 Object* code = map->FindInCodeCache(name, flags); |
444 if (code->IsUndefined()) { | 444 if (code->IsUndefined()) { |
445 CallStubCompiler compiler(argc); | 445 CallStubCompiler compiler(argc); |
446 code = compiler.CompileCallField(object, holder, index, name, flags); | 446 code = compiler.CompileCallField(object, holder, index, name, flags); |
447 if (code->IsFailure()) return code; | 447 if (code->IsFailure()) return code; |
448 LOG(CodeCreateEvent("CallIC", Code::cast(code), name)); | 448 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name)); |
449 Object* result = map->UpdateCodeCache(name, Code::cast(code)); | 449 Object* result = map->UpdateCodeCache(name, Code::cast(code)); |
450 if (result->IsFailure()) return result; | 450 if (result->IsFailure()) return result; |
451 } | 451 } |
452 return Set(name, map, Code::cast(code)); | 452 return Set(name, map, Code::cast(code)); |
453 } | 453 } |
454 | 454 |
455 | 455 |
456 Object* StubCache::ComputeCallInterceptor(int argc, | 456 Object* StubCache::ComputeCallInterceptor(int argc, |
457 String* name, | 457 String* name, |
458 Object* object, | 458 Object* object, |
(...skipping 12 matching lines...) Expand all Loading... | |
471 Code::Flags flags = | 471 Code::Flags flags = |
472 Code::ComputeMonomorphicFlags(Code::CALL_IC, | 472 Code::ComputeMonomorphicFlags(Code::CALL_IC, |
473 INTERCEPTOR, | 473 INTERCEPTOR, |
474 NOT_IN_LOOP, | 474 NOT_IN_LOOP, |
475 argc); | 475 argc); |
476 Object* code = map->FindInCodeCache(name, flags); | 476 Object* code = map->FindInCodeCache(name, flags); |
477 if (code->IsUndefined()) { | 477 if (code->IsUndefined()) { |
478 CallStubCompiler compiler(argc); | 478 CallStubCompiler compiler(argc); |
479 code = compiler.CompileCallInterceptor(object, holder, name); | 479 code = compiler.CompileCallInterceptor(object, holder, name); |
480 if (code->IsFailure()) return code; | 480 if (code->IsFailure()) return code; |
481 LOG(CodeCreateEvent("CallIC", Code::cast(code), name)); | 481 LOG(CodeCreateEvent(Logger::CALL_IC_TAG, Code::cast(code), name)); |
482 Object* result = map->UpdateCodeCache(name, Code::cast(code)); | 482 Object* result = map->UpdateCodeCache(name, Code::cast(code)); |
483 if (result->IsFailure()) return result; | 483 if (result->IsFailure()) return result; |
484 } | 484 } |
485 return Set(name, map, Code::cast(code)); | 485 return Set(name, map, Code::cast(code)); |
486 } | 486 } |
487 | 487 |
488 | 488 |
489 Object* StubCache::ComputeCallNormal(int argc, | 489 Object* StubCache::ComputeCallNormal(int argc, |
490 InLoopFlag in_loop, | 490 InLoopFlag in_loop, |
491 String* name, | 491 String* name, |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
625 Object* StubCache::ComputeLazyCompile(int argc) { | 625 Object* StubCache::ComputeLazyCompile(int argc) { |
626 Code::Flags flags = | 626 Code::Flags flags = |
627 Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, UNINITIALIZED, NORMAL, argc); | 627 Code::ComputeFlags(Code::STUB, NOT_IN_LOOP, UNINITIALIZED, NORMAL, argc); |
628 Object* probe = ProbeCache(flags); | 628 Object* probe = ProbeCache(flags); |
629 if (!probe->IsUndefined()) return probe; | 629 if (!probe->IsUndefined()) return probe; |
630 StubCompiler compiler; | 630 StubCompiler compiler; |
631 Object* result = FillCache(compiler.CompileLazyCompile(flags)); | 631 Object* result = FillCache(compiler.CompileLazyCompile(flags)); |
632 if (result->IsCode()) { | 632 if (result->IsCode()) { |
633 Code* code = Code::cast(result); | 633 Code* code = Code::cast(result); |
634 USE(code); | 634 USE(code); |
635 LOG(CodeCreateEvent("LazyCompile", code, code->arguments_count())); | 635 LOG(CodeCreateEvent(Logger::LAZY_COMPILE_TAG, |
636 code, code->arguments_count())); | |
636 } | 637 } |
637 return result; | 638 return result; |
638 } | 639 } |
639 | 640 |
640 | 641 |
641 void StubCache::Clear() { | 642 void StubCache::Clear() { |
642 for (int i = 0; i < kPrimaryTableSize; i++) { | 643 for (int i = 0; i < kPrimaryTableSize; i++) { |
643 primary_[i].key = Heap::empty_string(); | 644 primary_[i].key = Heap::empty_string(); |
644 primary_[i].value = Builtins::builtin(Builtins::Illegal); | 645 primary_[i].value = Builtins::builtin(Builtins::Illegal); |
645 } | 646 } |
(...skipping 127 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
773 | 774 |
774 Object* StubCompiler::CompileCallInitialize(Code::Flags flags) { | 775 Object* StubCompiler::CompileCallInitialize(Code::Flags flags) { |
775 HandleScope scope; | 776 HandleScope scope; |
776 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 777 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
777 CallIC::GenerateInitialize(masm(), argc); | 778 CallIC::GenerateInitialize(masm(), argc); |
778 Object* result = GetCodeWithFlags(flags, "CompileCallInitialize"); | 779 Object* result = GetCodeWithFlags(flags, "CompileCallInitialize"); |
779 if (!result->IsFailure()) { | 780 if (!result->IsFailure()) { |
780 Counters::call_initialize_stubs.Increment(); | 781 Counters::call_initialize_stubs.Increment(); |
781 Code* code = Code::cast(result); | 782 Code* code = Code::cast(result); |
782 USE(code); | 783 USE(code); |
783 LOG(CodeCreateEvent("CallInitialize", code, code->arguments_count())); | 784 LOG(CodeCreateEvent(Logger::CALL_INITIALIZE_TAG, |
785 code, code->arguments_count())); | |
784 } | 786 } |
785 return result; | 787 return result; |
786 } | 788 } |
787 | 789 |
788 | 790 |
789 Object* StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) { | 791 Object* StubCompiler::CompileCallPreMonomorphic(Code::Flags flags) { |
790 HandleScope scope; | 792 HandleScope scope; |
791 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 793 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
792 CallIC::GenerateInitialize(masm(), argc); | 794 CallIC::GenerateInitialize(masm(), argc); |
793 Object* result = GetCodeWithFlags(flags, "CompileCallPreMonomorphic"); | 795 Object* result = GetCodeWithFlags(flags, "CompileCallPreMonomorphic"); |
794 if (!result->IsFailure()) { | 796 if (!result->IsFailure()) { |
795 Counters::call_premonomorphic_stubs.Increment(); | 797 Counters::call_premonomorphic_stubs.Increment(); |
796 Code* code = Code::cast(result); | 798 Code* code = Code::cast(result); |
797 USE(code); | 799 USE(code); |
798 LOG(CodeCreateEvent("CallPreMonomorphic", code, code->arguments_count())); | 800 LOG(CodeCreateEvent(Logger::CALL_PRE_MONOMORPHIC_TAG, |
801 code, code->arguments_count())); | |
799 } | 802 } |
800 return result; | 803 return result; |
801 } | 804 } |
802 | 805 |
803 | 806 |
804 Object* StubCompiler::CompileCallNormal(Code::Flags flags) { | 807 Object* StubCompiler::CompileCallNormal(Code::Flags flags) { |
805 HandleScope scope; | 808 HandleScope scope; |
806 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 809 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
807 CallIC::GenerateNormal(masm(), argc); | 810 CallIC::GenerateNormal(masm(), argc); |
808 Object* result = GetCodeWithFlags(flags, "CompileCallNormal"); | 811 Object* result = GetCodeWithFlags(flags, "CompileCallNormal"); |
809 if (!result->IsFailure()) { | 812 if (!result->IsFailure()) { |
810 Counters::call_normal_stubs.Increment(); | 813 Counters::call_normal_stubs.Increment(); |
811 Code* code = Code::cast(result); | 814 Code* code = Code::cast(result); |
812 USE(code); | 815 USE(code); |
813 LOG(CodeCreateEvent("CallNormal", code, code->arguments_count())); | 816 LOG(CodeCreateEvent( |
Søren Thygesen Gjesse
2009/06/08 12:28:47
Please format this call like the others:
LOG(Code
Mikhail Naganov
2009/06/08 13:39:09
Done.
| |
817 Logger::CALL_NORMAL_TAG, code, code->arguments_count())); | |
814 } | 818 } |
815 return result; | 819 return result; |
816 } | 820 } |
817 | 821 |
818 | 822 |
819 Object* StubCompiler::CompileCallMegamorphic(Code::Flags flags) { | 823 Object* StubCompiler::CompileCallMegamorphic(Code::Flags flags) { |
820 HandleScope scope; | 824 HandleScope scope; |
821 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 825 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
822 CallIC::GenerateMegamorphic(masm(), argc); | 826 CallIC::GenerateMegamorphic(masm(), argc); |
823 Object* result = GetCodeWithFlags(flags, "CompileCallMegamorphic"); | 827 Object* result = GetCodeWithFlags(flags, "CompileCallMegamorphic"); |
824 if (!result->IsFailure()) { | 828 if (!result->IsFailure()) { |
825 Counters::call_megamorphic_stubs.Increment(); | 829 Counters::call_megamorphic_stubs.Increment(); |
826 Code* code = Code::cast(result); | 830 Code* code = Code::cast(result); |
827 USE(code); | 831 USE(code); |
828 LOG(CodeCreateEvent("CallMegamorphic", code, code->arguments_count())); | 832 LOG(CodeCreateEvent(Logger::CALL_MEGAMORPHIC_TAG, |
833 code, code->arguments_count())); | |
829 } | 834 } |
830 return result; | 835 return result; |
831 } | 836 } |
832 | 837 |
833 | 838 |
834 Object* StubCompiler::CompileCallMiss(Code::Flags flags) { | 839 Object* StubCompiler::CompileCallMiss(Code::Flags flags) { |
835 HandleScope scope; | 840 HandleScope scope; |
836 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 841 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
837 CallIC::GenerateMiss(masm(), argc); | 842 CallIC::GenerateMiss(masm(), argc); |
838 Object* result = GetCodeWithFlags(flags, "CompileCallMiss"); | 843 Object* result = GetCodeWithFlags(flags, "CompileCallMiss"); |
839 if (!result->IsFailure()) { | 844 if (!result->IsFailure()) { |
840 Counters::call_megamorphic_stubs.Increment(); | 845 Counters::call_megamorphic_stubs.Increment(); |
841 Code* code = Code::cast(result); | 846 Code* code = Code::cast(result); |
842 USE(code); | 847 USE(code); |
843 LOG(CodeCreateEvent("CallMiss", code, code->arguments_count())); | 848 LOG(CodeCreateEvent(Logger::CALL_MISS_TAG, code, code->arguments_count())); |
844 } | 849 } |
845 return result; | 850 return result; |
846 } | 851 } |
847 | 852 |
848 | 853 |
849 #ifdef ENABLE_DEBUGGER_SUPPORT | 854 #ifdef ENABLE_DEBUGGER_SUPPORT |
850 Object* StubCompiler::CompileCallDebugBreak(Code::Flags flags) { | 855 Object* StubCompiler::CompileCallDebugBreak(Code::Flags flags) { |
851 HandleScope scope; | 856 HandleScope scope; |
852 Debug::GenerateCallICDebugBreak(masm()); | 857 Debug::GenerateCallICDebugBreak(masm()); |
853 Object* result = GetCodeWithFlags(flags, "CompileCallDebugBreak"); | 858 Object* result = GetCodeWithFlags(flags, "CompileCallDebugBreak"); |
854 if (!result->IsFailure()) { | 859 if (!result->IsFailure()) { |
855 Code* code = Code::cast(result); | 860 Code* code = Code::cast(result); |
856 USE(code); | 861 USE(code); |
857 LOG(CodeCreateEvent("CallDebugBreak", code, code->arguments_count())); | 862 LOG(CodeCreateEvent(Logger::CALL_DEBUG_BREAK_TAG, |
863 code, code->arguments_count())); | |
858 } | 864 } |
859 return result; | 865 return result; |
860 } | 866 } |
861 | 867 |
862 | 868 |
863 Object* StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) { | 869 Object* StubCompiler::CompileCallDebugPrepareStepIn(Code::Flags flags) { |
864 HandleScope scope; | 870 HandleScope scope; |
865 // Use the same code for the the step in preparations as we do for | 871 // Use the same code for the the step in preparations as we do for |
866 // the miss case. | 872 // the miss case. |
867 int argc = Code::ExtractArgumentsCountFromFlags(flags); | 873 int argc = Code::ExtractArgumentsCountFromFlags(flags); |
868 CallIC::GenerateMiss(masm(), argc); | 874 CallIC::GenerateMiss(masm(), argc); |
869 Object* result = GetCodeWithFlags(flags, "CompileCallDebugPrepareStepIn"); | 875 Object* result = GetCodeWithFlags(flags, "CompileCallDebugPrepareStepIn"); |
870 if (!result->IsFailure()) { | 876 if (!result->IsFailure()) { |
871 Code* code = Code::cast(result); | 877 Code* code = Code::cast(result); |
872 USE(code); | 878 USE(code); |
873 LOG(CodeCreateEvent("CallDebugPrepareStepIn", code, | 879 LOG(CodeCreateEvent(Logger::CALL_DEBUG_PREPARE_STEP_IN_TAG, code, |
874 code->arguments_count())); | 880 code->arguments_count())); |
875 } | 881 } |
876 return result; | 882 return result; |
877 } | 883 } |
878 #endif | 884 #endif |
879 | 885 |
880 | 886 |
881 Object* StubCompiler::GetCodeWithFlags(Code::Flags flags, const char* name) { | 887 Object* StubCompiler::GetCodeWithFlags(Code::Flags flags, const char* name) { |
882 CodeDesc desc; | 888 CodeDesc desc; |
883 masm_.GetCode(&desc); | 889 masm_.GetCode(&desc); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
927 int argc = arguments_.immediate(); | 933 int argc = arguments_.immediate(); |
928 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, | 934 Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC, |
929 type, | 935 type, |
930 NOT_IN_LOOP, | 936 NOT_IN_LOOP, |
931 argc); | 937 argc); |
932 return GetCodeWithFlags(flags, name); | 938 return GetCodeWithFlags(flags, name); |
933 } | 939 } |
934 | 940 |
935 | 941 |
936 } } // namespace v8::internal | 942 } } // namespace v8::internal |
OLD | NEW |