OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_STUB_CACHE_H_ | 5 #ifndef V8_STUB_CACHE_H_ |
6 #define V8_STUB_CACHE_H_ | 6 #define V8_STUB_CACHE_H_ |
7 | 7 |
8 #include "src/allocation.h" | 8 #include "src/allocation.h" |
9 #include "src/arguments.h" | 9 #include "src/arguments.h" |
10 #include "src/code-stubs.h" | 10 #include "src/code-stubs.h" |
11 #include "src/ic-inl.h" | 11 #include "src/ic-inl.h" |
12 #include "src/macro-assembler.h" | 12 #include "src/macro-assembler.h" |
13 #include "src/objects.h" | 13 #include "src/objects.h" |
14 #include "src/zone-inl.h" | 14 #include "src/zone-inl.h" |
15 | 15 |
16 namespace v8 { | 16 namespace v8 { |
17 namespace internal { | 17 namespace internal { |
18 | 18 |
19 | 19 |
20 // The stub cache is used for megamorphic calls and property accesses. | 20 // The stub cache is used for megamorphic property accesses. |
21 // It maps (map, name, type)->Code* | 21 // It maps (map, name, type) to property access handlers. The cache does not |
22 | 22 // need explicit invalidation when a prototype chain is modified, since the |
23 // The design of the table uses the inline cache stubs used for | 23 // handlers verify the chain. |
24 // mono-morphic calls. The beauty of this, we do not have to | |
25 // invalidate the cache whenever a prototype map is changed. The stub | |
26 // validates the map chain as in the mono-morphic case. | |
27 | 24 |
28 | 25 |
29 class CallOptimization; | 26 class CallOptimization; |
30 class SmallMapList; | 27 class SmallMapList; |
31 class StubCache; | 28 class StubCache; |
32 | 29 |
33 | 30 |
34 class SCTableReference { | 31 class SCTableReference { |
35 public: | 32 public: |
36 Address address() const { return address_; } | 33 Address address() const { return address_; } |
37 | 34 |
38 private: | 35 private: |
39 explicit SCTableReference(Address address) : address_(address) {} | 36 explicit SCTableReference(Address address) : address_(address) {} |
40 | 37 |
41 Address address_; | 38 Address address_; |
42 | 39 |
43 friend class StubCache; | 40 friend class StubCache; |
44 }; | 41 }; |
45 | 42 |
46 | 43 |
47 class StubCache { | 44 class StubCache { |
48 public: | 45 public: |
49 struct Entry { | 46 struct Entry { |
50 Name* key; | 47 Name* key; |
51 Code* value; | 48 Code* value; |
52 Map* map; | 49 Map* map; |
53 }; | 50 }; |
54 | 51 |
55 void Initialize(); | 52 void Initialize(); |
56 | 53 // Access cache for entry hash(name, map). |
57 Handle<Code> ComputeMonomorphicIC(Code::Kind kind, | |
58 Handle<Name> name, | |
59 Handle<HeapType> type, | |
60 Handle<Code> handler, | |
61 ExtraICState extra_ic_state); | |
62 | |
63 Handle<Code> ComputeLoadNonexistent(Handle<Name> name, Handle<HeapType> type); | |
64 | |
65 Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map); | |
66 | |
67 Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map, | |
68 StrictMode strict_mode, | |
69 KeyedAccessStoreMode store_mode); | |
70 | |
71 // --- | |
72 | |
73 Handle<Code> ComputeLoad(InlineCacheState ic_state, ExtraICState extra_state); | |
74 Handle<Code> ComputeStore(InlineCacheState ic_state, | |
75 ExtraICState extra_state); | |
76 | |
77 // --- | |
78 | |
79 Handle<Code> ComputeCompareNil(Handle<Map> receiver_map, | |
80 CompareNilICStub* stub); | |
81 | |
82 // --- | |
83 | |
84 Handle<Code> ComputeLoadElementPolymorphic(MapHandleList* receiver_maps); | |
85 Handle<Code> ComputeStoreElementPolymorphic(MapHandleList* receiver_maps, | |
86 KeyedAccessStoreMode store_mode, | |
87 StrictMode strict_mode); | |
88 | |
89 Handle<Code> ComputePolymorphicIC(Code::Kind kind, | |
90 TypeHandleList* types, | |
91 CodeHandleList* handlers, | |
92 int number_of_valid_maps, | |
93 Handle<Name> name, | |
94 ExtraICState extra_ic_state); | |
95 | |
96 // Finds the Code object stored in the Heap::non_monomorphic_cache(). | |
97 Code* FindPreMonomorphicIC(Code::Kind kind, ExtraICState extra_ic_state); | |
98 | |
99 // Update cache for entry hash(name, map). | |
100 Code* Set(Name* name, Map* map, Code* code); | 54 Code* Set(Name* name, Map* map, Code* code); |
101 | |
102 Code* Get(Name* name, Map* map, Code::Flags flags); | 55 Code* Get(Name* name, Map* map, Code::Flags flags); |
103 | |
104 // Clear the lookup table (@ mark compact collection). | 56 // Clear the lookup table (@ mark compact collection). |
105 void Clear(); | 57 void Clear(); |
106 | |
107 // Collect all maps that match the name and flags. | 58 // Collect all maps that match the name and flags. |
108 void CollectMatchingMaps(SmallMapList* types, | 59 void CollectMatchingMaps(SmallMapList* types, |
109 Handle<Name> name, | 60 Handle<Name> name, |
110 Code::Flags flags, | 61 Code::Flags flags, |
111 Handle<Context> native_context, | 62 Handle<Context> native_context, |
112 Zone* zone); | 63 Zone* zone); |
113 | |
114 // Generate code for probing the stub cache table. | 64 // Generate code for probing the stub cache table. |
115 // Arguments extra, extra2 and extra3 may be used to pass additional scratch | 65 // Arguments extra, extra2 and extra3 may be used to pass additional scratch |
116 // registers. Set to no_reg if not needed. | 66 // registers. Set to no_reg if not needed. |
117 void GenerateProbe(MacroAssembler* masm, | 67 void GenerateProbe(MacroAssembler* masm, |
118 Code::Flags flags, | 68 Code::Flags flags, |
119 Register receiver, | 69 Register receiver, |
120 Register name, | 70 Register name, |
121 Register scratch, | 71 Register scratch, |
122 Register extra, | 72 Register extra, |
123 Register extra2 = no_reg, | 73 Register extra2 = no_reg, |
124 Register extra3 = no_reg); | 74 Register extra3 = no_reg); |
125 | 75 |
126 enum Table { | 76 enum Table { |
127 kPrimary, | 77 kPrimary, |
128 kSecondary | 78 kSecondary |
129 }; | 79 }; |
130 | 80 |
131 | |
132 SCTableReference key_reference(StubCache::Table table) { | 81 SCTableReference key_reference(StubCache::Table table) { |
133 return SCTableReference( | 82 return SCTableReference( |
134 reinterpret_cast<Address>(&first_entry(table)->key)); | 83 reinterpret_cast<Address>(&first_entry(table)->key)); |
135 } | 84 } |
136 | 85 |
137 | |
138 SCTableReference map_reference(StubCache::Table table) { | 86 SCTableReference map_reference(StubCache::Table table) { |
139 return SCTableReference( | 87 return SCTableReference( |
140 reinterpret_cast<Address>(&first_entry(table)->map)); | 88 reinterpret_cast<Address>(&first_entry(table)->map)); |
141 } | 89 } |
142 | 90 |
143 | |
144 SCTableReference value_reference(StubCache::Table table) { | 91 SCTableReference value_reference(StubCache::Table table) { |
145 return SCTableReference( | 92 return SCTableReference( |
146 reinterpret_cast<Address>(&first_entry(table)->value)); | 93 reinterpret_cast<Address>(&first_entry(table)->value)); |
147 } | 94 } |
148 | 95 |
149 | |
150 StubCache::Entry* first_entry(StubCache::Table table) { | 96 StubCache::Entry* first_entry(StubCache::Table table) { |
151 switch (table) { | 97 switch (table) { |
152 case StubCache::kPrimary: return StubCache::primary_; | 98 case StubCache::kPrimary: return StubCache::primary_; |
153 case StubCache::kSecondary: return StubCache::secondary_; | 99 case StubCache::kSecondary: return StubCache::secondary_; |
154 } | 100 } |
155 UNREACHABLE(); | 101 UNREACHABLE(); |
156 return NULL; | 102 return NULL; |
157 } | 103 } |
158 | 104 |
159 Isolate* isolate() { return isolate_; } | 105 Isolate* isolate() { return isolate_; } |
160 Heap* heap() { return isolate()->heap(); } | |
161 Factory* factory() { return isolate()->factory(); } | |
162 | |
163 // These constants describe the structure of the interceptor arguments on the | |
164 // stack. The arguments are pushed by the (platform-specific) | |
165 // PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and | |
166 // LoadWithInterceptor. | |
167 static const int kInterceptorArgsNameIndex = 0; | |
168 static const int kInterceptorArgsInfoIndex = 1; | |
169 static const int kInterceptorArgsThisIndex = 2; | |
170 static const int kInterceptorArgsHolderIndex = 3; | |
171 static const int kInterceptorArgsLength = 4; | |
172 | 106 |
173 // Setting the entry size such that the index is shifted by Name::kHashShift | 107 // Setting the entry size such that the index is shifted by Name::kHashShift |
174 // is convenient; shifting down the length field (to extract the hash code) | 108 // is convenient; shifting down the length field (to extract the hash code) |
175 // automatically discards the hash bit field. | 109 // automatically discards the hash bit field. |
176 static const int kCacheIndexShift = Name::kHashShift; | 110 static const int kCacheIndexShift = Name::kHashShift; |
177 | 111 |
178 private: | 112 private: |
179 explicit StubCache(Isolate* isolate); | 113 explicit StubCache(Isolate* isolate); |
180 | 114 |
181 // The stub cache has a primary and secondary level. The two levels have | 115 // The stub cache has a primary and secondary level. The two levels have |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
328 Code::Kind kind_; | 262 Code::Kind kind_; |
329 CacheHolderFlag cache_holder_; | 263 CacheHolderFlag cache_holder_; |
330 | 264 |
331 Isolate* isolate_; | 265 Isolate* isolate_; |
332 MacroAssembler masm_; | 266 MacroAssembler masm_; |
333 }; | 267 }; |
334 | 268 |
335 | 269 |
336 class PropertyICCompiler : public PropertyAccessCompiler { | 270 class PropertyICCompiler : public PropertyAccessCompiler { |
337 public: | 271 public: |
| 272 // Finds the Code object stored in the Heap::non_monomorphic_cache(). |
| 273 static Code* FindPreMonomorphicIC(Isolate* isolate, Code::Kind kind, |
| 274 ExtraICState extra_ic_state); |
| 275 |
| 276 // Named |
| 277 static Handle<Code> ComputeLoad(Isolate* isolate, InlineCacheState ic_state, |
| 278 ExtraICState extra_state); |
| 279 static Handle<Code> ComputeStore(Isolate* isolate, InlineCacheState ic_state, |
| 280 ExtraICState extra_state); |
| 281 |
| 282 static Handle<Code> ComputeMonomorphicIC(Code::Kind kind, Handle<Name> name, |
| 283 Handle<HeapType> type, |
| 284 Handle<Code> handler, |
| 285 ExtraICState extra_ic_state); |
| 286 static Handle<Code> ComputePolymorphicIC( |
| 287 Code::Kind kind, TypeHandleList* types, CodeHandleList* handlers, |
| 288 int number_of_valid_maps, Handle<Name> name, ExtraICState extra_ic_state); |
| 289 |
| 290 // Keyed |
| 291 static Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map); |
| 292 |
| 293 static Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map, |
| 294 StrictMode strict_mode, |
| 295 KeyedAccessStoreMode store_mode); |
| 296 static Handle<Code> ComputeLoadElementPolymorphic( |
| 297 MapHandleList* receiver_maps); |
| 298 static Handle<Code> ComputeStoreElementPolymorphic( |
| 299 MapHandleList* receiver_maps, KeyedAccessStoreMode store_mode, |
| 300 StrictMode strict_mode); |
| 301 |
| 302 // Compare nil |
| 303 static Handle<Code> ComputeCompareNil(Handle<Map> receiver_map, |
| 304 CompareNilICStub* stub); |
| 305 |
| 306 |
| 307 private: |
338 PropertyICCompiler(Isolate* isolate, Code::Kind kind, | 308 PropertyICCompiler(Isolate* isolate, Code::Kind kind, |
339 ExtraICState extra_ic_state = kNoExtraICState, | 309 ExtraICState extra_ic_state = kNoExtraICState, |
340 CacheHolderFlag cache_holder = kCacheOnReceiver) | 310 CacheHolderFlag cache_holder = kCacheOnReceiver) |
341 : PropertyAccessCompiler(isolate, kind, cache_holder), | 311 : PropertyAccessCompiler(isolate, kind, cache_holder), |
342 extra_ic_state_(extra_ic_state) {} | 312 extra_ic_state_(extra_ic_state) {} |
343 | 313 |
344 static Handle<Code> Find(Handle<Name> name, Handle<Map> stub_holder_map, | 314 static Handle<Code> Find(Handle<Name> name, Handle<Map> stub_holder_map, |
345 Code::Kind kind, | 315 Code::Kind kind, |
346 ExtraICState extra_ic_state = kNoExtraICState, | 316 ExtraICState extra_ic_state = kNoExtraICState, |
347 CacheHolderFlag cache_holder = kCacheOnReceiver); | 317 CacheHolderFlag cache_holder = kCacheOnReceiver); |
348 | 318 |
349 Handle<Code> CompileLoadInitialize(Code::Flags flags); | 319 Handle<Code> CompileLoadInitialize(Code::Flags flags); |
350 Handle<Code> CompileLoadPreMonomorphic(Code::Flags flags); | 320 Handle<Code> CompileLoadPreMonomorphic(Code::Flags flags); |
351 Handle<Code> CompileLoadMegamorphic(Code::Flags flags); | 321 Handle<Code> CompileLoadMegamorphic(Code::Flags flags); |
352 Handle<Code> CompileStoreInitialize(Code::Flags flags); | 322 Handle<Code> CompileStoreInitialize(Code::Flags flags); |
353 Handle<Code> CompileStorePreMonomorphic(Code::Flags flags); | 323 Handle<Code> CompileStorePreMonomorphic(Code::Flags flags); |
354 Handle<Code> CompileStoreGeneric(Code::Flags flags); | 324 Handle<Code> CompileStoreGeneric(Code::Flags flags); |
355 Handle<Code> CompileStoreMegamorphic(Code::Flags flags); | 325 Handle<Code> CompileStoreMegamorphic(Code::Flags flags); |
356 | 326 |
357 Handle<Code> CompileMonomorphic(Handle<HeapType> type, Handle<Code> handler, | 327 Handle<Code> CompileMonomorphic(Handle<HeapType> type, Handle<Code> handler, |
358 Handle<Name> name, IcCheckType check); | 328 Handle<Name> name, IcCheckType check); |
359 | |
360 Handle<Code> CompilePolymorphic(TypeHandleList* types, | 329 Handle<Code> CompilePolymorphic(TypeHandleList* types, |
361 CodeHandleList* handlers, Handle<Name> name, | 330 CodeHandleList* handlers, Handle<Name> name, |
362 Code::StubType type, IcCheckType check); | 331 Code::StubType type, IcCheckType check); |
363 | 332 |
364 Handle<Code> CompileIndexedStoreMonomorphic(Handle<Map> receiver_map, | 333 Handle<Code> CompileIndexedStoreMonomorphic(Handle<Map> receiver_map, |
365 KeyedAccessStoreMode store_mode); | 334 KeyedAccessStoreMode store_mode); |
366 Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps, | 335 Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps, |
367 KeyedAccessStoreMode store_mode); | 336 KeyedAccessStoreMode store_mode); |
| 337 Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps, |
| 338 CodeHandleList* handler_stubs, |
| 339 MapHandleList* transitioned_maps); |
368 | 340 |
369 private: | |
370 bool IncludesNumberType(TypeHandleList* types); | 341 bool IncludesNumberType(TypeHandleList* types); |
371 | 342 |
372 Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name, | 343 Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name, |
373 InlineCacheState state = MONOMORPHIC); | 344 InlineCacheState state = MONOMORPHIC); |
374 | 345 |
375 Logger::LogEventsAndTags log_kind(Handle<Code> code) { | 346 Logger::LogEventsAndTags log_kind(Handle<Code> code) { |
376 if (kind() == Code::LOAD_IC) { | 347 if (kind() == Code::LOAD_IC) { |
377 return code->ic_state() == MONOMORPHIC ? Logger::LOAD_IC_TAG | 348 return code->ic_state() == MONOMORPHIC ? Logger::LOAD_IC_TAG |
378 : Logger::LOAD_POLYMORPHIC_IC_TAG; | 349 : Logger::LOAD_POLYMORPHIC_IC_TAG; |
379 } else if (kind() == Code::KEYED_LOAD_IC) { | 350 } else if (kind() == Code::KEYED_LOAD_IC) { |
380 return code->ic_state() == MONOMORPHIC | 351 return code->ic_state() == MONOMORPHIC |
381 ? Logger::KEYED_LOAD_IC_TAG | 352 ? Logger::KEYED_LOAD_IC_TAG |
382 : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; | 353 : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; |
383 } else if (kind() == Code::STORE_IC) { | 354 } else if (kind() == Code::STORE_IC) { |
384 return code->ic_state() == MONOMORPHIC ? Logger::STORE_IC_TAG | 355 return code->ic_state() == MONOMORPHIC ? Logger::STORE_IC_TAG |
385 : Logger::STORE_POLYMORPHIC_IC_TAG; | 356 : Logger::STORE_POLYMORPHIC_IC_TAG; |
386 } else { | 357 } else { |
387 ASSERT_EQ(Code::KEYED_STORE_IC, kind()); | 358 ASSERT_EQ(Code::KEYED_STORE_IC, kind()); |
388 return code->ic_state() == MONOMORPHIC | 359 return code->ic_state() == MONOMORPHIC |
389 ? Logger::KEYED_STORE_IC_TAG | 360 ? Logger::KEYED_STORE_IC_TAG |
390 : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; | 361 : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; |
391 } | 362 } |
392 } | 363 } |
393 | 364 |
394 Handle<Code> CompileIndexedStorePolymorphic(MapHandleList* receiver_maps, | |
395 CodeHandleList* handler_stubs, | |
396 MapHandleList* transitioned_maps); | |
397 const ExtraICState extra_ic_state_; | 365 const ExtraICState extra_ic_state_; |
398 }; | 366 }; |
399 | 367 |
400 | 368 |
401 class PropertyHandlerCompiler : public PropertyAccessCompiler { | 369 class PropertyHandlerCompiler : public PropertyAccessCompiler { |
402 public: | 370 public: |
403 static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind, | 371 static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind, |
404 CacheHolderFlag cache_holder, Code::StubType type); | 372 CacheHolderFlag cache_holder, Code::StubType type); |
405 | 373 |
406 protected: | 374 protected: |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
507 | 475 |
508 Handle<Code> CompileLoadInterceptor(Handle<HeapType> type, | 476 Handle<Code> CompileLoadInterceptor(Handle<HeapType> type, |
509 Handle<JSObject> holder, | 477 Handle<JSObject> holder, |
510 Handle<Name> name); | 478 Handle<Name> name); |
511 | 479 |
512 Handle<Code> CompileLoadViaGetter(Handle<HeapType> type, | 480 Handle<Code> CompileLoadViaGetter(Handle<HeapType> type, |
513 Handle<JSObject> holder, | 481 Handle<JSObject> holder, |
514 Handle<Name> name, | 482 Handle<Name> name, |
515 Handle<JSFunction> getter); | 483 Handle<JSFunction> getter); |
516 | 484 |
517 Handle<Code> CompileLoadNonexistent(Handle<HeapType> type, | 485 static Handle<Code> ComputeLoadNonexistent(Handle<Name> name, |
518 Handle<JSObject> last, | 486 Handle<HeapType> type); |
519 Handle<Name> name); | |
520 | 487 |
521 Handle<Code> CompileLoadGlobal(Handle<HeapType> type, | 488 Handle<Code> CompileLoadGlobal(Handle<HeapType> type, |
522 Handle<GlobalObject> holder, | 489 Handle<GlobalObject> holder, |
523 Handle<PropertyCell> cell, | 490 Handle<PropertyCell> cell, |
524 Handle<Name> name, | 491 Handle<Name> name, |
525 bool is_dont_delete); | 492 bool is_dont_delete); |
526 | 493 |
527 static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type, | 494 static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type, |
528 Register receiver, | 495 Register receiver, |
529 Handle<JSFunction> getter); | 496 Handle<JSFunction> getter); |
530 | 497 |
531 static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) { | 498 static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) { |
532 GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg, | 499 GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg, |
533 Handle<JSFunction>()); | 500 Handle<JSFunction>()); |
534 } | 501 } |
535 | 502 |
536 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, | 503 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, |
537 Register receiver, | 504 Register receiver, |
538 Register scratch1, | 505 Register scratch1, |
539 Register scratch2, | 506 Register scratch2, |
540 Label* miss_label); | 507 Label* miss_label); |
541 | 508 |
| 509 // These constants describe the structure of the interceptor arguments on the |
| 510 // stack. The arguments are pushed by the (platform-specific) |
| 511 // PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and |
| 512 // LoadWithInterceptor. |
| 513 static const int kInterceptorArgsNameIndex = 0; |
| 514 static const int kInterceptorArgsInfoIndex = 1; |
| 515 static const int kInterceptorArgsThisIndex = 2; |
| 516 static const int kInterceptorArgsHolderIndex = 3; |
| 517 static const int kInterceptorArgsLength = 4; |
| 518 |
542 protected: | 519 protected: |
543 virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg, | 520 virtual Register FrontendHeader(Handle<HeapType> type, Register object_reg, |
544 Handle<JSObject> holder, Handle<Name> name, | 521 Handle<JSObject> holder, Handle<Name> name, |
545 Label* miss); | 522 Label* miss); |
546 | 523 |
547 virtual void FrontendFooter(Handle<Name> name, Label* miss); | 524 virtual void FrontendFooter(Handle<Name> name, Label* miss); |
548 | 525 |
549 private: | 526 private: |
550 Register CallbackFrontend(Handle<HeapType> type, Register object_reg, | 527 Register CallbackFrontend(Handle<HeapType> type, Register object_reg, |
551 Handle<JSObject> holder, Handle<Name> name, | 528 Handle<JSObject> holder, Handle<Name> name, |
552 Handle<Object> callback); | 529 Handle<Object> callback); |
| 530 Handle<Code> CompileLoadNonexistent(Handle<HeapType> type, |
| 531 Handle<JSObject> last, Handle<Name> name); |
553 void NonexistentFrontend(Handle<HeapType> type, Handle<JSObject> last, | 532 void NonexistentFrontend(Handle<HeapType> type, Handle<JSObject> last, |
554 Handle<Name> name); | 533 Handle<Name> name); |
555 | 534 |
556 void GenerateLoadField(Register reg, | 535 void GenerateLoadField(Register reg, |
557 Handle<JSObject> holder, | 536 Handle<JSObject> holder, |
558 FieldIndex field, | 537 FieldIndex field, |
559 Representation representation); | 538 Representation representation); |
560 void GenerateLoadConstant(Handle<Object> value); | 539 void GenerateLoadConstant(Handle<Object> value); |
561 void GenerateLoadCallback(Register reg, | 540 void GenerateLoadCallback(Register reg, |
562 Handle<ExecutableAccessorInfo> callback); | 541 Handle<ExecutableAccessorInfo> callback); |
(...skipping 194 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
757 Handle<JSFunction> constant_function_; | 736 Handle<JSFunction> constant_function_; |
758 bool is_simple_api_call_; | 737 bool is_simple_api_call_; |
759 Handle<FunctionTemplateInfo> expected_receiver_type_; | 738 Handle<FunctionTemplateInfo> expected_receiver_type_; |
760 Handle<CallHandlerInfo> api_call_info_; | 739 Handle<CallHandlerInfo> api_call_info_; |
761 }; | 740 }; |
762 | 741 |
763 | 742 |
764 } } // namespace v8::internal | 743 } } // namespace v8::internal |
765 | 744 |
766 #endif // V8_STUB_CACHE_H_ | 745 #endif // V8_STUB_CACHE_H_ |
OLD | NEW |