Lines Matching refs:Receiver
1459 void HGraphBuilder::BuildJSObjectCheck(HValue* receiver,
1462 Add<HCheckHeapObject>(receiver);
1464 // Get the map of the receiver.
1466 Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
1591 void HGraphBuilder::BuildNonGlobalObjectCheck(HValue* receiver) {
1592 // Get the the instance type of the receiver, and make sure that it is
1595 Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
1624 // Load the map of the receiver, compute the keyed lookup cache hash
1676 HValue* receiver, HValue* elements, HValue* key, HValue* hash,
1719 Add<HPushArguments>(receiver, key);
1782 Add<HPushArguments>(receiver, key);
2056 HValue* HGraphBuilder::BuildToObject(HValue* receiver) {
2064 // {receiver} into a JSValue, unless {receiver} is already a {JSReceiver}, in
2065 // which case we just return it. Deopts to Runtime::kToObject if {receiver}
2068 receiver_is_smi.If<HIsSmiAndBranch>(receiver);
2076 // Determine {receiver} map and instance type.
2078 Add<HLoadNamedField>(receiver, nullptr, HObjectAccess::ForMap());
2082 // First check whether {receiver} is already a spec object (fast case).
2089 // Load the constructor function index from the {receiver} map.
2094 // Check if {receiver} has a constructor (null and undefined have no
2111 // Wrap the receiver if necessary.
2139 receiver);
2143 { Push(receiver); }
4968 HValue* receiver = environment()->arguments_environment()->Lookup(0);
4979 AddLeaveInlined(not_spec_object, receiver, state);
6749 HValue* receiver,
6755 if (maps != NULL && receiver->HasMonomorphicJSObjectType()) {
6756 Map* root_map = receiver->GetMonomorphicJSObjectMap()->FindRootMap();
7679 // elements. However a receiver map that has dictionary elements itself
7787 // Number of arguments without receiver.
7805 // Number of arguments without receiver.
8035 HValue* receiver,
8038 int argument_count = expr->arguments()->length() + 1; // Includes receiver.
8097 receiver, empty_smi_block, not_smi_block));
8101 BuildCheckHeapObject(receiver);
8112 compare = New<HCompareMap>(receiver, heap_number_map, if_true, if_false);
8114 compare = New<HIsStringAndBranch>(receiver, if_true, if_false);
8116 compare = New<HCompareMap>(receiver, map, if_true, if_false);
8131 Push(receiver);
8149 // use the regular CallFunctionStub for method calls to wrap the receiver.
8175 BuildNamedGeneric(LOAD, prop, prop->PropertyFeedbackSlot(), receiver,
8182 environment()->SetExpressionStackAt(0, receiver);
8532 // return value is the newly allocated receiver.
8665 Drop(2); // Receiver and function.
8675 Drop(2); // Receiver and function.
8721 int argument_count = args_count_no_receiver + 1; // Plus receiver.
8724 HValue* receiver = environment()->ExpressionStackAt(args_count_no_receiver);
8725 if (receiver->IsConstant() &&
8726 HConstant::cast(receiver)->handle(isolate())->IsHeapObject()) {
8729 HConstant::cast(receiver)->handle(isolate()))->map());
8755 Drop(2); // Receiver and function.
8773 Drop(2); // Receiver and function.
8783 Drop(2); // Receiver and function.
8815 Drop(2); // Receiver and function.
8827 Drop(2); // Receiver and function.
8841 HValue* receiver = Pop();
8843 HValue* checked_object = AddCheckMap(receiver, receiver_map);
8967 HValue* receiver = Pop();
8975 receiver, nullptr, HObjectAccess::ForArrayLength(kind));
8986 HValue* elements = AddLoadElements(receiver);
9038 receiver, HObjectAccess::ForArrayLength(kind),
9043 Add<HPushArguments>(receiver);
9081 HValue* receiver = Pop();
9086 HValue* index = BuildArrayIndexOf(receiver, search_element, kind, mode);
9103 HValue* receiver) {
9108 receiver,
9118 HValue* receiver,
9123 receiver,
9137 NULL, // Receiver is on expression stack.
9151 NULL, // Receiver is on expression stack.
9160 HValue* receiver,
9201 // Need to check that none of the receiver maps could have changed.
9202 Add<HCheckMaps>(receiver, receiver_maps);
9203 // Need to ensure the chain between receiver and api_holder is intact.
9209 // Includes receiver.
9214 // Receiver and prototype chain cannot have changed.
9216 DCHECK_NULL(receiver);
9217 // Receiver is on expression stack.
9218 receiver = Pop();
9219 Add<HPushArguments>(receiver);
9224 // Receiver and prototype chain cannot have changed.
9226 DCHECK_NULL(receiver);
9227 // Receiver and value are on expression stack.
9229 receiver = Pop();
9230 Add<HPushArguments>(receiver, value);
9241 holder = receiver;
9345 // For .apply, only the pattern f.apply(receiver, arguments)
9364 HValue* receiver = Pop(); // receiver
9374 HValue* wrapped_receiver = BuildWrapReceiver(receiver, checked_function);
9389 Push(BuildWrapReceiver(receiver, checked_function));
9410 // Patch the receiver.
9411 HValue* receiver = BuildWrapReceiver(
9413 environment()->SetExpressionStackAt(receiver_index, receiver);
9457 HValue* HOptimizedGraphBuilder::BuildArrayIndexOf(HValue* receiver,
9465 HValue* elements = AddLoadElements(receiver);
9466 HValue* length = AddLoadArrayLength(receiver, kind);
9651 int argument_count = expr->arguments()->length() + 1; // Plus receiver.
9657 HValue* receiver = Top();
9660 ComputeReceiverTypes(expr, receiver, &maps, zone());
9666 HandlePolymorphicCallNamed(expr, receiver, maps, name);
9676 CHECK_ALIVE(PushLoad(prop, receiver, key));
9681 // Push the function under the receiver.
9683 Push(receiver);
9702 if (TryInlineApiMethodCall(expr, receiver, maps)) return;
9704 // Wrap the receiver if necessary.
9708 // the receiver.
9730 // Push the function under the receiver.
9732 Push(receiver);
9757 // Placeholder for the receiver.
9765 // Patch the global object on the stack by the expected receiver.
9766 HValue* receiver = ImplicitReceiverFor(function, expr->target());
9768 environment()->SetExpressionStackAt(receiver_index, receiver);
9778 if (TryInlineApiFunctionCall(expr, receiver)) return;
9948 // Allocate an instance of the implicit receiver object.
9951 HAllocate* receiver = BuildAllocate(
9953 receiver->set_known_initial_map(initial_map);
9958 Add<HStoreNamedField>(receiver,
9962 Add<HStoreNamedField>(receiver,
9966 Add<HStoreNamedField>(receiver,
9970 BuildInitializeInobjectProperties(receiver, initial_map);
9973 // Replace the constructor function with a newly allocated receiver using
9974 // the index of the receiver from the top of the expression stack.
9977 environment()->SetExpressionStackAt(receiver_index, receiver);
9979 if (TryInlineConstruct(expr, receiver)) {
10017 HValue* receiver, Handle<Map> initial_map) {
10022 Add<HStoreNamedField>(receiver, HObjectAccess::ForMapAndOffset(
10948 left_type->Maybe(Type::Receiver()) ||
10950 right_type->Maybe(Type::Receiver()));
11530 if (combined_type->Is(Type::Receiver())) {
12383 // Number of arguments without receiver.
12405 // Number of arguments without receiver.
12788 HValue* receiver = Pop();
12790 receiver, nullptr, HObjectAccess::ForJSCollectionTable());
12863 HValue* receiver = Pop();
12867 Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(), table);
12868 return ast_context()->ReturnValue(receiver);
12875 HValue* receiver = Pop();
12879 Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(), table);
12880 return ast_context()->ReturnValue(receiver);
12885 void HOptimizedGraphBuilder::BuildOrderedHashTableClear(HValue* receiver) {
12887 receiver, nullptr, HObjectAccess::ForJSCollectionTable());
12896 Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(),
12904 HValue* receiver = Pop();
12907 BuildOrderedHashTableClear<OrderedHashSet>(receiver);
12915 HValue* receiver = Pop();
12918 BuildOrderedHashTableClear<OrderedHashMap>(receiver);
13184 for (int i = 0; i <= arguments; ++i) { // Include receiver.
13204 outer->Drop(arguments + 1); // Including receiver.
13208 // Create artificial constructor stub environment. The receiver should
13230 for (int i = 0; i <= arity; ++i) { // Include receiver.
