Lines Matching full:receiver
46 Register receiver,
87 __ ldr(scratch2, FieldMemOperand(receiver, HeapObject::kMapOffset));
132 // This function is safe to call if the receiver has fast properties.
133 // Name must be a symbol and receiver must be a heap object.
136 Register receiver,
150 // Bail out if the receiver has a named interceptor or requires access checks.
152 __ ldr(map, FieldMemOperand(receiver, HeapObject::kMapOffset));
157 // Check that receiver is a JSObject.
164 __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
173 __ ldr(properties, FieldMemOperand(receiver, JSObject::kPropertiesOffset));
179 receiver,
190 Register receiver,
207 ASSERT(!scratch.is(receiver));
209 ASSERT(!extra.is(receiver));
212 ASSERT(!extra2.is(receiver));
227 // Check that the receiver isn't a smi.
228 __ JumpIfSmi(receiver, &miss);
230 // Get the map of the receiver and compute the hash.
232 __ ldr(ip, FieldMemOperand(receiver, HeapObject::kMapOffset));
249 receiver,
267 receiver,
345 Register receiver,
348 // Check that the receiver isn't a smi.
349 __ JumpIfSmi(receiver, miss_label);
352 __ CompareObjectType(receiver, scratch, scratch, JS_ARRAY_TYPE);
356 __ ldr(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
365 Register receiver,
370 // Check that the receiver isn't a smi.
371 __ JumpIfSmi(receiver, smi);
374 __ ldr(scratch1, FieldMemOperand(receiver, HeapObject::kMapOffset));
384 // If the receiver object is not a string or a wrapped string object the
386 // receiver is potentially clobbered.
388 Register receiver,
397 GenerateStringCheck(masm, receiver, scratch1, scratch2, miss,
401 __ ldr(r0, FieldMemOperand(receiver, String::kLengthOffset));
411 receiver, JSValue::kValueOffset));
420 Register receiver,
424 __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
432 // may be clobbered. Upon branch to miss_label, the receiver and name
460 // Perform map transition for the receiver if necessary.
546 // -- r0: receiver
555 // Patch the receiver on the stack with the global proxy if
571 Register receiver,
581 __ push(receiver);
590 Register receiver,
594 PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
638 // -- sp[(argc + 4) * 4] : receiver
709 Register receiver,
717 // Check that the receiver isn't a smi.
718 __ JumpIfSmi(receiver, miss);
721 CompileCacheable(masm, object, receiver, scratch1, scratch2, scratch3,
724 CompileRegular(masm, object, receiver, scratch1, scratch2, scratch3,
732 Register receiver,
768 // Check that the maps from receiver to interceptor's holder
773 stub_compiler_->CheckPrototypes(object, receiver, interceptor_holder,
780 LoadWithInterceptor(masm, receiver, holder, interceptor_holder, scratch2,
789 stub_compiler_->CheckPrototypes(interceptor_holder, receiver,
828 Register receiver,
836 stub_compiler_->CheckPrototypes(object, receiver, interceptor_holder,
844 PushInterceptorArguments(masm, receiver, holder, name_, interceptor_holder);
855 Register receiver,
864 receiver,
869 __ pop(receiver); // Restore the holder.
1140 Register receiver,
1147 // Check that the receiver isn't a smi.
1148 __ JumpIfSmi(receiver, miss);
1152 object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
1160 Register receiver,
1167 // Check that the receiver isn't a smi.
1168 __ JumpIfSmi(receiver, miss);
1172 object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
1182 Register receiver,
1190 // Check that the receiver isn't a smi.
1191 __ JumpIfSmi(receiver, miss);
1194 Register reg = CheckPrototypes(object, receiver, holder, scratch1,
1199 __ push(receiver);
1233 Register receiver,
1243 // Check that the receiver isn't a smi.
1244 __ JumpIfSmi(receiver, miss);
1264 Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
1267 ASSERT(holder_reg.is(receiver) || holder_reg.is(scratch1));
1269 // Preserve the receiver register explicitly whenever it is different from
1271 // result. The CALLBACKS case needs the receiver to be passed into C++ code,
1274 bool must_preserve_receiver_reg = !receiver.is(holder_reg) &&
1282 __ Push(receiver, holder_reg, name_reg);
1286 // Invoke an interceptor. Note: map checks from receiver to
1290 receiver,
1307 __ pop(receiver);
1341 // structured to never clobber |receiver| register.
1343 // holder_reg is either receiver or scratch1.
1344 if (!receiver.is(holder_reg)) {
1346 __ Push(receiver, holder_reg);
1351 __ push(receiver);
1365 Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
1368 PushInterceptorArguments(masm(), receiver, holder_reg,
1396 // Get the receiver from the stack.
1458 // Get the receiver of the function from the stack into r0.
1460 // Check that the receiver isn't a smi.
1489 // -- sp[argc * 4] : receiver
1498 Register receiver = r1;
1499 // Get the receiver from the stack
1501 __ ldr(receiver, MemOperand(sp, argc * kPointerSize));
1503 // Check that the receiver isn't a smi.
1504 __ JumpIfSmi(receiver, &miss);
1507 CheckPrototypes(Handle<JSObject>::cast(object), receiver, holder, r3, r0, r4,
1512 __ ldr(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
1524 __ ldr(elements, FieldMemOperand(receiver, JSArray::kElementsOffset));
1535 __ ldr(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
1553 __ str(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
1570 __ ldr(r3, FieldMemOperand(receiver, HeapObject::kMapOffset));
1579 // edx: receiver
1586 __ mov(r2, receiver);
1594 __ str(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
1626 __ ldr(r7, FieldMemOperand(receiver, HeapObject::kMapOffset));
1664 __ str(r0, FieldMemOperand(receiver, JSArray::kLengthOffset));
1699 // -- sp[argc * 4] : receiver
1706 Register receiver = r1;
1710 // Get the receiver from the stack
1712 __ ldr(receiver, MemOperand(sp, argc * kPointerSize));
1713 // Check that the receiver isn't a smi.
1714 __ JumpIfSmi(receiver, &miss);
1717 CheckPrototypes(Handle<JSObject>::cast(object), receiver, holder, elements,
1721 __ ldr(elements, FieldMemOperand(receiver, JSArray::kElementsOffset));
1731 __ ldr(r4, FieldMemOperand(receiver, JSArray::kLengthOffset));
1747 __ str(r4, FieldMemOperand(receiver, JSArray::kLengthOffset));
1785 // -- sp[argc * 4] : receiver
1813 Register receiver = r1;
1816 __ ldr(receiver, MemOperand(sp, argc * kPointerSize));
1823 StringCharCodeAtGenerator generator(receiver,
1866 // -- sp[argc * 4] : receiver
1893 Register receiver = r0;
1897 __ ldr(receiver, MemOperand(sp, argc * kPointerSize));
1904 StringCharAtGenerator generator(receiver,
1948 // -- sp[argc * 4] : receiver
1995 // Tail call the full function. We do not have to patch the receiver
2021 // -- sp[argc * 4] : receiver
2142 // Tail call the full function. We do not have to patch the receiver
2167 // -- sp[argc * 4] : receiver
2240 // Tail call the full function. We do not have to patch the receiver
2266 // repatch it to global receiver.
2277 // Get the receiver from the stack.
2281 // Check that the receiver isn't a smi.
2326 // Get the receiver from the stack
2330 // Check that the receiver isn't a smi.
2335 // Make sure that it's okay not to patch the on stack receiver
2336 // unless we're doing a receiver map check.
2347 // Patch the receiver on the stack with the global proxy if
2367 // Calling non-strict non-builtins with a value as the receiver
2388 // Calling non-strict non-builtins with a value as the receiver
2412 // Calling non-strict non-builtins with a value as the receiver
2449 // Get the receiver from the stack.
2458 // Restore receiver.
2496 // Patch the receiver on the stack with the global proxy if
2536 // -- r1 : receiver
2558 // -- r1 : receiver
2577 __ push(r1); // receiver
2598 Handle<JSObject> receiver,
2602 // -- r1 : receiver
2609 __ CheckMap(r1, r3, Handle<Map>(receiver->map()), &miss,
2613 if (receiver->IsJSGlobalProxy()) {
2619 ASSERT(receiver->IsJSGlobalProxy() || !receiver->IsAccessCheckNeeded());
2621 __ Push(r1, r2, r0); // Receiver, name, value.
2648 // -- r1 : receiver
2692 // -- r0 : receiver
2697 // Check that receiver is not a smi.
2728 // -- r0 : receiver
2749 // -- r0 : receiver
2769 // -- r0 : receiver
2788 // -- r0 : receiver
2813 // -- r0 : receiver
2849 Handle<JSObject> receiver,
2855 // -- r1 : receiver
2863 GenerateLoadField(receiver, holder, r1, r2, r3, r4, index, name, &miss);
2873 Handle<JSObject> receiver,
2879 // -- r1 : receiver
2887 GenerateLoadCallback(receiver, holder, r1, r0, r2, r3, r4, callback, name,
2898 Handle<JSObject> receiver,
2904 // -- r1 : receiver
2912 GenerateLoadConstant(receiver, holder, r1, r2, r3, r4, value, name, &miss);
2922 Handle<JSObject> receiver,
2928 // -- r1 : receiver
2938 GenerateLoadInterceptor(receiver, holder, &lookup, r1, r0, r2, r3, r4, name,
2952 // -- r1 : receiver
2973 // -- r1 : receiver
2999 // -- r1 : receiver
3024 // -- r1 : receiver
3045 // -- r1 : receiver
3074 // -- r2 : receiver
3105 // -- r2 : receiver
3131 // -- r2 : receiver
3283 // Remove caller arguments and receiver from the stack and return.
3311 // -- r1 : receiver
3316 Register receiver = r1;
3320 __ ldr(r4, FieldMemOperand(receiver, JSObject::kElementsOffset));
3332 // -- r1 : receiver
3344 // -- r1 : receiver
3386 // -- r1 : receiver
3391 Register receiver = r1;
3393 // This stub is meant to be tail-jumped to, the receiver must already
3399 __ ldr(r3, FieldMemOperand(receiver, JSObject::kElementsOffset));
3684 // Slow case, key and receiver still in r0 and r1.
3693 // -- r1 : receiver
3713 // -- r2 : receiver
3721 Register receiver = r2;
3724 // This stub is meant to be tail-jumped to, the receiver must already
3730 __ ldr(r3, FieldMemOperand(receiver, JSObject::kElementsOffset));
4012 // Slow case, key and receiver still in r0 and r1.
4021 // -- r1 : receiver
4033 // -- r1 : receiver
4046 // -- r1 : receiver
4050 // This stub is meant to be tail-jumped to, the receiver must already
4088 // -- r1 : receiver
4102 // This stub is meant to be tail-jumped to, the receiver must already
4162 // -- r2 : receiver
4178 // This stub is meant to be tail-jumped to, the receiver must already
4327 // -- r2 : receiver
4346 // This stub is meant to be tail-jumped to, the receiver must already
