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 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
116 Code::ExtraICState extra_ic_state) { | 116 Code::ExtraICState extra_ic_state) { |
117 Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_ic_state, type); | 117 Code::Flags flags = Code::ComputeMonomorphicFlags(kind, extra_ic_state, type); |
118 Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags), | 118 Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags), |
119 isolate_); | 119 isolate_); |
120 if (probe->IsCode()) return Handle<Code>::cast(probe); | 120 if (probe->IsCode()) return Handle<Code>::cast(probe); |
121 return Handle<Code>::null(); | 121 return Handle<Code>::null(); |
122 } | 122 } |
123 | 123 |
124 | 124 |
125 Handle<Code> StubCache::FindHandler(Handle<Name> name, | 125 Handle<Code> StubCache::FindHandler(Handle<Name> name, |
| 126 Handle<JSObject> receiver, |
126 Handle<JSObject> stub_holder, | 127 Handle<JSObject> stub_holder, |
127 Code::Kind kind, | 128 Code::Kind kind, |
128 Code::StubType type, | 129 Code::StubType type) { |
129 Code::ExtraICState extra_ic_state) { | 130 Code::ExtraICState extra_ic_state = Code::ComputeExtraICState( |
| 131 receiver.is_identical_to(stub_holder) ? Code::OWN_STUB |
| 132 : Code::PROTOTYPE_STUB); |
130 ASSERT(type != Code::NORMAL); | 133 ASSERT(type != Code::NORMAL); |
131 Code::Flags flags = Code::ComputeMonomorphicFlags( | 134 Code::Flags flags = Code::ComputeMonomorphicFlags( |
132 Code::STUB, extra_ic_state, type, kind); | 135 Code::STUB, extra_ic_state, type, kind); |
133 Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags), | 136 Handle<Object> probe(stub_holder->map()->FindInCodeCache(*name, flags), |
134 isolate_); | 137 isolate_); |
135 if (probe->IsCode()) return Handle<Code>::cast(probe); | 138 if (probe->IsCode()) return Handle<Code>::cast(probe); |
136 return Handle<Code>::null(); | 139 return Handle<Code>::null(); |
137 } | 140 } |
138 | 141 |
139 | 142 |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
187 global = Handle<GlobalObject>::cast(current); | 190 global = Handle<GlobalObject>::cast(current); |
188 cache_name = name; | 191 cache_name = name; |
189 } else if (!current->HasFastProperties()) { | 192 } else if (!current->HasFastProperties()) { |
190 cache_name = name; | 193 cache_name = name; |
191 } | 194 } |
192 } while (!next->IsNull()); | 195 } while (!next->IsNull()); |
193 | 196 |
194 // Compile the stub that is either shared for all names or | 197 // Compile the stub that is either shared for all names or |
195 // name specific if there are global objects involved. | 198 // name specific if there are global objects involved. |
196 Handle<Code> handler = FindHandler( | 199 Handle<Code> handler = FindHandler( |
197 cache_name, receiver, Code::LOAD_IC, Code::NONEXISTENT); | 200 cache_name, receiver, receiver, Code::LOAD_IC, Code::NONEXISTENT); |
198 if (!handler.is_null()) return handler; | 201 if (!handler.is_null()) return handler; |
199 | 202 |
200 LoadStubCompiler compiler(isolate_); | 203 LoadStubCompiler compiler(isolate_); |
201 handler = | 204 handler = |
202 compiler.CompileLoadNonexistent(receiver, current, cache_name, global); | 205 compiler.CompileLoadNonexistent(receiver, current, cache_name, global); |
203 JSObject::UpdateMapCodeCache(receiver, cache_name, handler); | 206 JSObject::UpdateMapCodeCache(receiver, cache_name, handler); |
204 return handler; | 207 return handler; |
205 } | 208 } |
206 | 209 |
207 | 210 |
208 Handle<Code> StubCache::ComputeLoadField(Handle<Name> name, | 211 Handle<Code> StubCache::ComputeLoadField(Handle<Name> name, |
209 Handle<JSObject> receiver, | 212 Handle<JSObject> receiver, |
210 Handle<JSObject> holder, | 213 Handle<JSObject> holder, |
211 PropertyIndex field) { | 214 PropertyIndex field) { |
212 if (receiver.is_identical_to(holder)) { | 215 if (receiver.is_identical_to(holder)) { |
213 LoadFieldStub stub(LoadStubCompiler::receiver(), | 216 LoadFieldStub stub(LoadStubCompiler::receiver(), |
214 field.is_inobject(holder), | 217 field.is_inobject(holder), |
215 field.translate(holder)); | 218 field.translate(holder)); |
216 return stub.GetCode(isolate()); | 219 return stub.GetCode(isolate()); |
217 } | 220 } |
218 | 221 |
219 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 222 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
220 Handle<Code> stub = FindHandler( | 223 Handle<Code> stub = FindHandler( |
221 name, stub_holder, Code::LOAD_IC, Code::FIELD); | 224 name, receiver, stub_holder, Code::LOAD_IC, Code::FIELD); |
222 if (!stub.is_null()) return stub; | 225 if (!stub.is_null()) return stub; |
223 | 226 |
224 LoadStubCompiler compiler(isolate_); | 227 LoadStubCompiler compiler(isolate_); |
225 Handle<Code> handler = | 228 Handle<Code> handler = |
226 compiler.CompileLoadField(receiver, holder, name, field); | 229 compiler.CompileLoadField(receiver, holder, name, field); |
227 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 230 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
228 return handler; | 231 return handler; |
229 } | 232 } |
230 | 233 |
231 | 234 |
232 Handle<Code> StubCache::ComputeLoadCallback( | 235 Handle<Code> StubCache::ComputeLoadCallback( |
233 Handle<Name> name, | 236 Handle<Name> name, |
234 Handle<JSObject> receiver, | 237 Handle<JSObject> receiver, |
235 Handle<JSObject> holder, | 238 Handle<JSObject> holder, |
236 Handle<ExecutableAccessorInfo> callback) { | 239 Handle<ExecutableAccessorInfo> callback) { |
237 ASSERT(v8::ToCData<Address>(callback->getter()) != 0); | 240 ASSERT(v8::ToCData<Address>(callback->getter()) != 0); |
238 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 241 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
239 Handle<Code> stub = FindHandler( | 242 Handle<Code> stub = FindHandler( |
240 name, stub_holder, Code::LOAD_IC, Code::CALLBACKS); | 243 name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); |
241 if (!stub.is_null()) return stub; | 244 if (!stub.is_null()) return stub; |
242 | 245 |
243 LoadStubCompiler compiler(isolate_); | 246 LoadStubCompiler compiler(isolate_); |
244 Handle<Code> handler = | 247 Handle<Code> handler = |
245 compiler.CompileLoadCallback(receiver, holder, name, callback); | 248 compiler.CompileLoadCallback(receiver, holder, name, callback); |
246 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 249 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
247 return handler; | 250 return handler; |
248 } | 251 } |
249 | 252 |
250 | 253 |
251 Handle<Code> StubCache::ComputeLoadViaGetter(Handle<Name> name, | 254 Handle<Code> StubCache::ComputeLoadViaGetter(Handle<Name> name, |
252 Handle<JSObject> receiver, | 255 Handle<JSObject> receiver, |
253 Handle<JSObject> holder, | 256 Handle<JSObject> holder, |
254 Handle<JSFunction> getter) { | 257 Handle<JSFunction> getter) { |
255 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 258 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
256 Handle<Code> stub = FindHandler( | 259 Handle<Code> stub = FindHandler( |
257 name, stub_holder, Code::LOAD_IC, Code::CALLBACKS); | 260 name, receiver, stub_holder, Code::LOAD_IC, Code::CALLBACKS); |
258 if (!stub.is_null()) return stub; | 261 if (!stub.is_null()) return stub; |
259 | 262 |
260 LoadStubCompiler compiler(isolate_); | 263 LoadStubCompiler compiler(isolate_); |
261 Handle<Code> handler = | 264 Handle<Code> handler = |
262 compiler.CompileLoadViaGetter(receiver, holder, name, getter); | 265 compiler.CompileLoadViaGetter(receiver, holder, name, getter); |
263 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 266 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
264 return handler; | 267 return handler; |
265 } | 268 } |
266 | 269 |
267 | 270 |
268 Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name, | 271 Handle<Code> StubCache::ComputeLoadConstant(Handle<Name> name, |
269 Handle<JSObject> receiver, | 272 Handle<JSObject> receiver, |
270 Handle<JSObject> holder, | 273 Handle<JSObject> holder, |
271 Handle<JSFunction> value) { | 274 Handle<JSFunction> value) { |
272 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 275 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
273 Handle<Code> handler = FindHandler( | 276 Handle<Code> handler = FindHandler( |
274 name, stub_holder, Code::LOAD_IC, Code::CONSTANT_FUNCTION); | 277 name, receiver, stub_holder, Code::LOAD_IC, Code::CONSTANT_FUNCTION); |
275 if (!handler.is_null()) return handler; | 278 if (!handler.is_null()) return handler; |
276 | 279 |
277 LoadStubCompiler compiler(isolate_); | 280 LoadStubCompiler compiler(isolate_); |
278 handler = compiler.CompileLoadConstant(receiver, holder, name, value); | 281 handler = compiler.CompileLoadConstant(receiver, holder, name, value); |
279 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 282 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
280 | 283 |
281 return handler; | 284 return handler; |
282 } | 285 } |
283 | 286 |
284 | 287 |
285 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name, | 288 Handle<Code> StubCache::ComputeLoadInterceptor(Handle<Name> name, |
286 Handle<JSObject> receiver, | 289 Handle<JSObject> receiver, |
287 Handle<JSObject> holder) { | 290 Handle<JSObject> holder) { |
288 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 291 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
289 Handle<Code> stub = FindHandler( | 292 Handle<Code> stub = FindHandler( |
290 name, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR); | 293 name, receiver, stub_holder, Code::LOAD_IC, Code::INTERCEPTOR); |
291 if (!stub.is_null()) return stub; | 294 if (!stub.is_null()) return stub; |
292 | 295 |
293 LoadStubCompiler compiler(isolate_); | 296 LoadStubCompiler compiler(isolate_); |
294 Handle<Code> handler = | 297 Handle<Code> handler = |
295 compiler.CompileLoadInterceptor(receiver, holder, name); | 298 compiler.CompileLoadInterceptor(receiver, holder, name); |
296 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 299 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
297 return handler; | 300 return handler; |
298 } | 301 } |
299 | 302 |
300 | 303 |
(...skipping 26 matching lines...) Expand all Loading... |
327 PropertyIndex field) { | 330 PropertyIndex field) { |
328 if (receiver.is_identical_to(holder)) { | 331 if (receiver.is_identical_to(holder)) { |
329 LoadFieldStub stub(KeyedLoadStubCompiler::receiver(), | 332 LoadFieldStub stub(KeyedLoadStubCompiler::receiver(), |
330 field.is_inobject(holder), | 333 field.is_inobject(holder), |
331 field.translate(holder)); | 334 field.translate(holder)); |
332 return stub.GetCode(isolate()); | 335 return stub.GetCode(isolate()); |
333 } | 336 } |
334 | 337 |
335 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 338 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
336 Handle<Code> stub = FindHandler( | 339 Handle<Code> stub = FindHandler( |
337 name, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD); | 340 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::FIELD); |
338 if (!stub.is_null()) return stub; | 341 if (!stub.is_null()) return stub; |
339 | 342 |
340 KeyedLoadStubCompiler compiler(isolate_); | 343 KeyedLoadStubCompiler compiler(isolate_); |
341 Handle<Code> handler = | 344 Handle<Code> handler = |
342 compiler.CompileLoadField(receiver, holder, name, field); | 345 compiler.CompileLoadField(receiver, holder, name, field); |
343 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 346 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
344 return handler; | 347 return handler; |
345 } | 348 } |
346 | 349 |
347 | 350 |
348 Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name, | 351 Handle<Code> StubCache::ComputeKeyedLoadConstant(Handle<Name> name, |
349 Handle<JSObject> receiver, | 352 Handle<JSObject> receiver, |
350 Handle<JSObject> holder, | 353 Handle<JSObject> holder, |
351 Handle<JSFunction> value) { | 354 Handle<JSFunction> value) { |
352 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 355 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
353 Handle<Code> handler = FindHandler( | 356 Handle<Code> handler = FindHandler( |
354 name, stub_holder, Code::KEYED_LOAD_IC, Code::CONSTANT_FUNCTION); | 357 name, receiver, stub_holder, Code::KEYED_LOAD_IC, |
| 358 Code::CONSTANT_FUNCTION); |
355 if (!handler.is_null()) return handler; | 359 if (!handler.is_null()) return handler; |
356 | 360 |
357 KeyedLoadStubCompiler compiler(isolate_); | 361 KeyedLoadStubCompiler compiler(isolate_); |
358 handler = compiler.CompileLoadConstant(receiver, holder, name, value); | 362 handler = compiler.CompileLoadConstant(receiver, holder, name, value); |
359 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 363 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
360 return handler; | 364 return handler; |
361 } | 365 } |
362 | 366 |
363 | 367 |
364 Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name, | 368 Handle<Code> StubCache::ComputeKeyedLoadInterceptor(Handle<Name> name, |
365 Handle<JSObject> receiver, | 369 Handle<JSObject> receiver, |
366 Handle<JSObject> holder) { | 370 Handle<JSObject> holder) { |
367 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 371 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
368 Handle<Code> stub = FindHandler( | 372 Handle<Code> stub = FindHandler( |
369 name, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR); | 373 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::INTERCEPTOR); |
370 if (!stub.is_null()) return stub; | 374 if (!stub.is_null()) return stub; |
371 | 375 |
372 KeyedLoadStubCompiler compiler(isolate_); | 376 KeyedLoadStubCompiler compiler(isolate_); |
373 Handle<Code> handler = | 377 Handle<Code> handler = |
374 compiler.CompileLoadInterceptor(receiver, holder, name); | 378 compiler.CompileLoadInterceptor(receiver, holder, name); |
375 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 379 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
376 return handler; | 380 return handler; |
377 } | 381 } |
378 | 382 |
379 | 383 |
380 Handle<Code> StubCache::ComputeKeyedLoadCallback( | 384 Handle<Code> StubCache::ComputeKeyedLoadCallback( |
381 Handle<Name> name, | 385 Handle<Name> name, |
382 Handle<JSObject> receiver, | 386 Handle<JSObject> receiver, |
383 Handle<JSObject> holder, | 387 Handle<JSObject> holder, |
384 Handle<ExecutableAccessorInfo> callback) { | 388 Handle<ExecutableAccessorInfo> callback) { |
385 Handle<JSObject> stub_holder = StubHolder(receiver, holder); | 389 Handle<JSObject> stub_holder = StubHolder(receiver, holder); |
386 Handle<Code> stub = FindHandler( | 390 Handle<Code> stub = FindHandler( |
387 name, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); | 391 name, receiver, stub_holder, Code::KEYED_LOAD_IC, Code::CALLBACKS); |
388 if (!stub.is_null()) return stub; | 392 if (!stub.is_null()) return stub; |
389 | 393 |
390 KeyedLoadStubCompiler compiler(isolate_); | 394 KeyedLoadStubCompiler compiler(isolate_); |
391 Handle<Code> handler = | 395 Handle<Code> handler = |
392 compiler.CompileLoadCallback(receiver, holder, name, callback); | 396 compiler.CompileLoadCallback(receiver, holder, name, callback); |
393 JSObject::UpdateMapCodeCache(stub_holder, name, handler); | 397 JSObject::UpdateMapCodeCache(stub_holder, name, handler); |
394 return handler; | 398 return handler; |
395 } | 399 } |
396 | 400 |
397 | 401 |
(...skipping 1611 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2009 Handle<FunctionTemplateInfo>( | 2013 Handle<FunctionTemplateInfo>( |
2010 FunctionTemplateInfo::cast(signature->receiver())); | 2014 FunctionTemplateInfo::cast(signature->receiver())); |
2011 } | 2015 } |
2012 } | 2016 } |
2013 | 2017 |
2014 is_simple_api_call_ = true; | 2018 is_simple_api_call_ = true; |
2015 } | 2019 } |
2016 | 2020 |
2017 | 2021 |
2018 } } // namespace v8::internal | 2022 } } // namespace v8::internal |
OLD | NEW |