Lines Matching defs:handler
12 #include "src/ic/handler-configuration.h"
21 #include "src/objects/megadom-handler.h"
39 TNode<DataHandler> handler, int data_index) {
41 TNode<Map> handler_map = LoadMap(handler);
69 return LoadMaybeWeakObjectField(handler, offset);
95 TNode<MaybeObject> handler = UncheckedCast<MaybeObject>(
99 *var_handler = handler;
131 // Found, now call handler.
132 TNode<MaybeObject> handler =
134 *var_handler = handler;
163 TNode<MegaDomHandler> handler;
165 handler = CAST(var_handler->value());
170 handler = CAST(maybe_handler);
177 TNode<MaybeObject> maybe_getter = LoadMegaDomHandlerAccessor(handler);
183 TNode<MaybeObject> maybe_context = LoadMegaDomHandlerContext(handler);
195 const LazyLoadICParameters* p, TNode<Object> handler, Label* miss,
201 TVARIABLE(Object, var_smi_handler, handler);
207 Branch(TaggedIsSmi(handler), &if_smi_handler, &try_proto_handler);
211 GotoIf(IsCodeT(CAST(handler)), &call_handler);
212 HandleLoadICProtoHandler(p, CAST(handler), &var_holder, &var_smi_handler,
217 // |handler| is a Smi, encoding what to do. See SmiHandler methods
222 p, var_holder.value(), CAST(var_smi_handler.value()), handler, miss,
228 TNode<CodeT> code_handler = CAST(handler);
252 TNode<WordT> handler_word, TNode<DataHandler> handler,
256 // the access check is enabled for this handler or not.
260 [=] { return LoadHandlerDataField(handler, 3); },
261 [=] { return LoadHandlerDataField(handler, 2); });
464 TNode<Object> handler, Label* miss, ExitPoint* exit_point, ICMode ic_mode,
629 handler, miss, exit_point, ic_mode, on_nonexistent, support_elements);
636 TVariable<Float64T>* var_double_value, TNode<Object> handler, Label* miss,
695 // This is a handler for a load of a non-existent value.
760 HandleLoadAccessor(p, CAST(holder), handler_word, CAST(handler),
858 // The handler is only installed for exports that exist.
963 // 2. If |on_code_handler| is provided, then it checks if the sub handler is
966 // If |on_code_handler| is not provided, then only smi sub handler are
970 // handler.
972 // ICHandler::LookupOnLookupStartObjectBits bit is set in the smi handler. If
976 // 5. Falls through in a case of a smi handler which is returned from this
982 const ICParameters* p, TNode<DataHandler> handler,
991 LoadObjectField(handler, ICHandler::kValidityCellOffset);
996 // Check smi handler bits.
1000 LoadObjectField(handler, ICHandler::kSmiHandlerOffset);
1036 TNode<MaybeObject> data2 = LoadHandlerDataField(handler, 2);
1078 const LazyLoadICParameters* p, TNode<DataHandler> handler,
1083 p, handler,
1104 LoadHandlerDataField(handler, 1);
1114 // If the "maybe_holder_or_constant" in the handler is a smi, then it's
1227 const StoreICParameters* p, TNode<MaybeObject> handler, Label* miss,
1233 Branch(TaggedIsSmi(handler), &if_smi_handler, &if_nonsmi_handler);
1235 // |handler| is a Smi, encoding what to do. See SmiHandler methods
1240 TNode<Int32T> handler_word = SmiToInt32(CAST(handler));
1370 GotoIf(IsWeakOrCleared(handler), &store_transition_or_global);
1371 TNode<HeapObject> strong_handler = CAST(handler);
1381 // |handler| is a heap object. Must be code, call it.
1393 // Load value or miss if the {handler} weak cell is cleared.
1394 CSA_DCHECK(this, IsWeakOrCleared(handler));
1396 GetHeapObjectAssumeWeak(handler, miss);
1795 const StoreICParameters* p, TNode<StoreHandler> handler, Label* miss,
1805 Branch(IsStoreHandler0Map(LoadMap(handler)), &if_element_store,
1817 LoadHandlerDataField(handler, 1);
1831 p, handler, on_code_handler,
1861 TNode<MaybeObject> maybe_holder = LoadHandlerDataField(handler, 1);
1906 // handler.
1930 CSA_DCHECK(this, TaggedIsNotSmi(handler));
1934 // the access check is enabled for this handler or not.
1938 [=] { return LoadHandlerDataField(handler, 3); },
1939 [=] { return LoadHandlerDataField(handler, 2); });
2712 // look for a handler in the stub cache.
2944 TNode<MaybeObject> handler = ReinterpretCast<MaybeObject>(
2949 // We found the handler.
2950 *var_handler = handler;
3190 // bytecode handler.
3330 // Load value or try handler case if the weak reference is cleared.
3365 TNode<Object> handler = CAST(feedback_element);
3366 GotoIf(TaggedEqual(handler, UninitializedSymbolConstant()), miss);
3382 HandleLoadICHandlerCase(&p, handler, miss, exit_point, ICMode::kGlobalIC,
3547 // with at least one map/handler pair.
3664 // LoadIC handler logic below.
3669 // Check if we have a matching handler for the {lookup_start_object_map}.
3784 TNode<MaybeObject> handler =
3787 GotoIf(TaggedEqual(handler, UninitializedSymbolConstant()), &miss);
3797 HandleStoreICHandlerCase(&p, handler, &miss, ICMode::kGlobalIC);
3951 // with at least one map/handler pair.
4025 // with at least one map/handler pair.
4066 // Currently only the Slow case uses a Smi handler.
4069 TNode<HeapObject> handler = CAST(var_handler.value());
4070 GotoIfNot(IsCodeT(handler), &if_transitioning_element_store);
4073 // Call the handler.
4074 TNode<CodeT> code_handler = CAST(handler);
4083 LoadHandlerDataField(CAST(handler), 1);
4088 CAST(LoadObjectField(handler, StoreHandler::kSmiHandlerOffset));
4097 // A check to ensure that no other Smi handler uses this path.