Lines Matching full:receiver
249 // Check there's the right string value or wrapper in the receiver slot.
272 bool IC::TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver,
276 LookupForRead(receiver, name, &lookup);
277 if (static_cast<CallIC*>(this)->TryUpdateExtraICState(&lookup, receiver)) {
296 if (!receiver->IsJSObject()) return false;
300 if (receiver->GetPrototype(isolate())->IsNull()) return false;
305 IC::GetCodeCacheHolder(isolate(), *receiver, cache_holder)->map());
308 // receiver itself or changes to one of its prototypes.
310 // If there are changes to the receiver itself, the map of the
311 // receiver will have changed and the current target will not be in
312 // the receiver map's code cache. Therefore, if the current target
313 // is in the receiver map's code cache, the inline cache failed due
343 if (receiver->IsGlobalObject()) {
345 GlobalObject* global = GlobalObject::cast(*receiver);
370 void IC::UpdateState(Handle<Object> receiver, Handle<Object> name) {
373 if (state() == POLYMORPHIC && receiver->IsHeapObject()) {
375 handle(Handle<HeapObject>::cast(receiver)->map()),
380 if (receiver->IsUndefined() || receiver->IsNull()) return;
386 receiver, Handle<String>::cast(name))) {
396 if (receiver->IsJSBuiltinsObject()) state_ = UNINITIALIZED;
565 // Patch the receiver and use the delegate as the function to
588 // Do not wrap receiver for strict mode functions or for builtins.
595 // Change the receiver to the result of calling ToObject on it.
607 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
608 if (!receiver->map()->is_deprecated()) return false;
670 // Make receiver an object if the callee requires it. Strict mode or builtin
671 // functions do not wrap the receiver, non-strict functions and objects
720 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
730 receiver, global, cell, function);
734 // property must be found in the receiver for the stub to be
736 if (!holder.is_identical_to(receiver)) return Handle<Code>::null();
828 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
829 if (receiver->elements()->map() ==
843 // Make receiver an object if the callee requires it. Strict mode or builtin
844 // functions do not wrap the receiver, non-strict functions and objects
986 // If the receiver type is already in the polymorphic IC, this indicates
1251 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
1252 Handle<Map> map(receiver->map());
1276 // Calling non-strict non-builtins with a value as the receiver
1325 Handle<Code> KeyedLoadIC::LoadElementStub(Handle<JSObject> receiver) {
1334 Handle<Map> receiver_map(receiver->map(), isolate());
1351 // The first time a receiver is seen that is a transitioned version of the
1352 // previous monomorphic receiver type, assume the new ElementsKind is the
1361 receiver->GetElementsKind())) {
1367 // Determine the list of receiver maps that this call site has seen,
1376 // If the maximum number of receiver maps has been exceeded, use the generic
1408 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
1409 if (receiver->elements()->map() ==
1412 } else if (receiver->HasIndexedInterceptor()) {
1416 stub = LoadElementStub(receiver);
1435 static bool LookupForWrite(Handle<JSObject> receiver,
1440 Handle<JSObject> holder = receiver;
1441 receiver->Lookup(*name, lookup);
1445 if (lookup->holder() == *receiver) {
1446 if (lookup->IsInterceptor() && !HasInterceptorSetter(*receiver)) {
1447 receiver->LocalLookupRealNamedProperty(*name, lookup);
1458 if (receiver->IsJSGlobalProxy()) return true;
1466 // While normally LookupTransition gets passed the receiver, in this case we
1470 // receiver when trying to fetch extra information from the transition.
1471 receiver->map()->LookupTransition(*holder, *name, lookup);
1482 ASSERT(!receiver->map()->is_deprecated());
1490 receiver->map()->LookupTransition(*holder, *name, lookup);
1521 // Ignore other stores where the receiver is not a JSObject.
1525 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
1531 JSObject::SetElement(receiver, index, value, NONE, strict_mode());
1537 if (FLAG_harmony_observation && receiver->map()->is_observed()) {
1539 receiver, name, value, NONE, strict_mode(), store_mode);
1549 receiver->IsJSArray() &&
1551 Handle<JSArray>::cast(receiver)->AllowsSetElementsLength() &&
1552 receiver->HasFastProperties() &&
1553 !receiver->map()->is_frozen()) {
1559 receiver, name, value, NONE, strict_mode(), store_mode);
1565 bool can_store = LookupForWrite(receiver, name, value, &lookup, this);
1579 UpdateCaches(&lookup, receiver, name, value);
1590 receiver, name, value, NONE, strict_mode(), store_mode);
1597 Handle<JSObject> receiver,
1605 Handle<Code> code = ComputeHandler(lookup, receiver, name, value);
1607 PatchCache(CurrentTypeOf(receiver, isolate()), name, code);
1620 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
1627 return compiler.CompileStoreField(receiver, lookup, name);
1629 // Explicitly pass in the receiver map since LookupForWrite may have
1630 // stored something else than the receiver in the holder.
1637 receiver, lookup, transition, name);
1641 if (receiver->IsGlobalObject()) {
1645 Handle<GlobalObject> global = Handle<GlobalObject>::cast(receiver);
1651 isolate(), receiver->map(), *cell);
1653 HeapObject::UpdateMapCodeCache(receiver, name, code);
1656 ASSERT(holder.is_identical_to(receiver));
1666 if (!info->IsCompatibleReceiver(*receiver)) break;
1667 return compiler.CompileStoreCallback(receiver, holder, name, info);
1677 call_optimization.IsCompatibleReceiver(*receiver)) {
1679 receiver, holder, name, call_optimization);
1682 receiver, holder, name, Handle<JSFunction>::cast(setter));
1692 ASSERT(HasInterceptorSetter(*receiver));
1693 return compiler.CompileStoreInterceptor(receiver, name);
1705 Handle<Code> KeyedStoreIC::StoreElementStub(Handle<JSObject> receiver,
1715 Handle<Map> receiver_map(receiver->map(), isolate());
1719 Handle<Map> monomorphic_map = ComputeTransitionedMap(receiver, store_mode);
1730 // receiver maps in the target.
1736 // superset of the original IC. Handle those here if the receiver map hasn't
1747 ComputeTransitionedMap(receiver, store_mode);
1754 } else if (*previous_receiver_map == receiver->map() &&
1774 ComputeTransitionedMap(receiver, store_mode);
1786 // If the maximum number of receiver maps has been exceeded, use the generic
1829 Handle<JSObject> receiver,
1836 return JSObject::GetElementsTransitionMap(receiver, FAST_ELEMENTS);
1839 return JSObject::GetElementsTransitionMap(receiver, FAST_DOUBLE_ELEMENTS);
1844 return JSObject::GetElementsTransitionMap(receiver,
1848 return JSObject::GetElementsTransitionMap(receiver,
1851 ASSERT(receiver->map()->has_external_array_elements());
1856 return Handle<Map>(receiver->map(), isolate());
1862 bool IsOutOfBoundsAccess(Handle<JSObject> receiver,
1864 if (receiver->IsJSArray()) {
1865 return JSArray::cast(*receiver)->length()->IsSmi() &&
1866 index >= Smi::cast(JSArray::cast(*receiver)->length())->value();
1868 return index >= receiver->elements()->length();
1872 KeyedAccessStoreMode KeyedStoreIC::GetStoreMode(Handle<JSObject> receiver,
1879 bool oob_access = IsOutOfBoundsAccess(receiver, index);
1880 bool allow_growth = receiver->IsJSArray() && oob_access;
1883 if (receiver->HasFastSmiElements()) {
1885 if (receiver->HasFastHoleyElements()) {
1892 if (receiver->HasFastHoleyElements()) {
1898 } else if (receiver->HasFastDoubleElements()) {
1900 if (receiver->HasFastHoleyElements()) {
1910 if (receiver->HasFastSmiElements()) {
1912 if (receiver->HasFastHoleyElements()) {
1918 if (receiver->HasFastHoleyElements()) {
1924 } else if (receiver->HasFastDoubleElements()) {
1926 if (receiver->HasFastHoleyElements()) {
1934 receiver->map()->has_external_array_elements() && oob_access) {
1937 Heap* heap = receiver->GetHeap();
1938 if (receiver->elements()->map() == heap->fixed_cow_array_map()) {
1989 Handle<JSObject> receiver = Handle<JSObject>::cast(object);
1991 if (receiver->elements()->map() ==
1996 // We should go generic if receiver isn't a dictionary, but our
2000 if (!(receiver->map()->DictionaryElementsInPrototypeChainOnly())) {
2002 GetStoreMode(receiver, key, value);
2003 stub = StoreElementStub(receiver, store_mode);
2041 Handle<Object> receiver = args.at<Object>(0);
2043 ic.UpdateState(receiver, key);
2044 MaybeObject* maybe_result = ic.LoadFunction(receiver, key);
2066 Handle<Object> receiver = args.at<Object>(0);
2068 ic.UpdateState(receiver, key);
2069 MaybeObject* maybe_result = ic.LoadFunction(receiver, key);
2087 Handle<Object> receiver = args.at<Object>(0);
2089 ic.UpdateState(receiver, key);
2090 return ic.Load(receiver, key);
2099 Handle<Object> receiver = args.at<Object>(0);
2101 ic.UpdateState(receiver, key);
2102 return ic.Load(receiver, key);
2110 Handle<Object> receiver = args.at<Object>(0);
2112 ic.UpdateState(receiver, key);
2113 return ic.Load(receiver, key);
2122 Handle<Object> receiver = args.at<Object>(0);
2124 ic.UpdateState(receiver, key);
2125 return ic.Store(receiver, key, args.at<Object>(2));
2133 Handle<Object> receiver = args.at<Object>(0);
2135 ic.UpdateState(receiver, key);
2136 return ic.Store(receiver, key, args.at<Object>(2));
2146 Handle<Object> receiver((*caller_args)[0], isolate);
2148 ic.UpdateState(receiver, key);
2149 MaybeObject* maybe_result = ic.LoadFunction(receiver, key);
2166 JSArray* receiver = JSArray::cast(args[0]);
2175 receiver->LocalLookup(isolate->heap()->length_string(), &debug_lookup);
2180 MaybeObject* maybe_result = receiver->SetElementsLength(len);
2241 Handle<Object> receiver = args.at<Object>(0);
2243 ic.UpdateState(receiver, key);
2244 return ic.Store(receiver, key, args.at<Object>(2));
2252 Handle<Object> receiver = args.at<Object>(0);
2254 ic.UpdateState(receiver, key);
2255 return ic.Store(receiver, key, args.at<Object>(2));
2827 return handle(Type::Receiver(), isolate);
2830 map.is_null() ? Type::Receiver() : Type::Class(map), isolate);
