Lines Matching full:receiver
47 Register receiver,
70 __ cmp(offset, FieldOperand(receiver, HeapObject::kMapOffset));
102 __ cmp(offset, FieldOperand(receiver, HeapObject::kMapOffset));
143 // This function is safe to call if the receiver has fast properties.
144 // Name must be a symbol and receiver must be a heap object.
147 Register receiver,
156 __ mov(r0, FieldOperand(receiver, HeapObject::kMapOffset));
161 // Bail out if the receiver has a named interceptor or requires access checks.
166 // Check that receiver is a JSObject.
172 __ mov(properties, FieldOperand(receiver, JSObject::kPropertiesOffset));
193 Register receiver,
209 ASSERT(!scratch.is(receiver));
211 ASSERT(!extra.is(receiver));
226 // Check that the receiver isn't a smi.
227 __ JumpIfSmi(receiver, &miss);
229 // Get the map of the receiver and compute the hash.
231 __ add(offset, FieldOperand(receiver, HeapObject::kMapOffset));
241 ProbeTable(isolate(), masm, flags, kPrimary, name, receiver, offset, extra);
245 __ add(offset, FieldOperand(receiver, HeapObject::kMapOffset));
254 isolate(), masm, flags, kSecondary, name, receiver, offset, extra);
293 Register receiver,
296 // Check that the receiver isn't a smi.
297 __ JumpIfSmi(receiver, miss_label);
300 __ CmpObjectType(receiver, JS_ARRAY_TYPE, scratch);
304 __ mov(eax, FieldOperand(receiver, JSArray::kLengthOffset));
312 Register receiver,
317 __ JumpIfSmi(receiver, smi);
320 __ mov(scratch, FieldOperand(receiver, HeapObject::kMapOffset));
329 Register receiver,
338 GenerateStringCheck(masm, receiver, scratch1, miss,
342 __ mov(eax, FieldOperand(receiver, String::kLengthOffset));
353 __ mov(scratch2, FieldOperand(receiver, JSValue::kValueOffset));
362 Register receiver,
366 __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
396 Register receiver,
406 __ push(receiver);
414 Register receiver,
418 PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
478 // -- esp[(argc + 4) * 4] : receiver
542 Register receiver,
550 // Check that the receiver isn't a smi.
551 __ JumpIfSmi(receiver, miss);
555 CompileCacheable(masm, object, receiver, scratch1, scratch2, scratch3,
558 CompileRegular(masm, object, receiver, scratch1, scratch2, scratch3,
566 Register receiver,
601 // Check that the maps from receiver to interceptor's holder
606 stub_compiler_->CheckPrototypes(object, receiver, interceptor_holder,
613 LoadWithInterceptor(masm, receiver, holder, interceptor_holder,
622 stub_compiler_->CheckPrototypes(interceptor_holder, receiver,
661 Register receiver,
669 stub_compiler_->CheckPrototypes(object, receiver, interceptor_holder,
677 PushInterceptorArguments(masm, receiver, holder, name_, interceptor_holder);
691 Register receiver,
701 receiver,
707 __ pop(receiver); // Restore the holder.
763 // Perform map transition for the receiver if necessary.
985 Register receiver,
992 // Check that the receiver isn't a smi.
993 __ JumpIfSmi(receiver, miss);
997 object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
1007 Register receiver,
1015 // Check that the receiver isn't a smi.
1016 __ JumpIfSmi(receiver, miss);
1019 Register reg = CheckPrototypes(object, receiver, holder, scratch1,
1026 __ push(receiver); // receiver
1068 Register receiver,
1075 // Check that the receiver isn't a smi.
1076 __ JumpIfSmi(receiver, miss);
1080 object, receiver, holder, scratch1, scratch2, scratch3, name, miss);
1091 Register receiver,
1101 // Check that the receiver isn't a smi.
1102 __ JumpIfSmi(receiver, miss);
1122 Register holder_reg = CheckPrototypes(object, receiver, interceptor_holder,
1125 ASSERT(holder_reg.is(receiver) || holder_reg.is(scratch1));
1127 // Preserve the receiver register explicitly whenever it is different from
1129 // result. The CALLBACKS case needs the receiver to be passed into C++ code,
1132 bool must_preserve_receiver_reg = !receiver.is(holder_reg) &&
1141 __ push(receiver);
1146 // Invoke an interceptor. Note: map checks from receiver to
1150 receiver,
1166 __ mov(receiver, Immediate(BitCast<int32_t>(kZapValue)));
1174 __ pop(receiver);
1210 // structured to never clobber |receiver| register.
1212 __ push(receiver);
1229 CheckPrototypes(object, receiver, interceptor_holder,
1232 PushInterceptorArguments(masm(), receiver, holder_reg,
1261 // Get the receiver from the stack.
1322 // -- esp[(argc + 1) * 4] : receiver
1328 // Get the receiver from the stack.
1332 // Check that the receiver isn't a smi.
1346 // Patch the receiver on the stack with the global proxy if
1380 // -- esp[(argc + 1) * 4] : receiver
1392 // Get the receiver from the stack.
1396 // Check that the receiver isn't a smi.
1461 // edx: receiver
1545 // Restore receiver to edx as finish sequence assumes it's here.
1587 // -- esp[(argc + 1) * 4] : receiver
1599 // Get the receiver from the stack.
1603 // Check that the receiver isn't a smi.
1669 // -- esp[(argc + 1) * 4] : receiver
1701 Register receiver = ebx;
1704 __ mov(receiver, Operand(esp, (argc + 1) * kPointerSize));
1711 StringCharCodeAtGenerator generator(receiver,
1752 // -- esp[(argc + 1) * 4] : receiver
1784 Register receiver = eax;
1788 __ mov(receiver, Operand(esp, (argc + 1) * kPointerSize));
1795 StringCharAtGenerator generator(receiver,
1837 // -- esp[(argc + 1) * 4] : receiver
1883 // Tail call the full function. We do not have to patch the receiver
1912 // -- esp[(argc + 1) * 4] : receiver
2016 // Tail call the full function. We do not have to patch the receiver
2042 // -- esp[(argc + 1) * 4] : receiver
2121 // Tail call the full function. We do not have to patch the receiver
2145 // repatch it to global receiver.
2157 // Get the receiver from the stack.
2161 // Check that the receiver isn't a smi.
2205 // -- esp[(argc + 1) * 4] : receiver
2219 // Get the receiver from the stack.
2223 // Check that the receiver isn't a smi.
2228 // Make sure that it's okay not to patch the on stack receiver
2229 // unless we're doing a receiver map check.
2239 // Patch the receiver on the stack with the global proxy if
2259 // Calling non-strict non-builtins with a value as the receiver
2280 // Calling non-strict non-builtins with a value as the receiver
2302 // Calling non-strict non-builtins with a value as the receiver
2332 // -- esp[(argc + 1) * 4] : receiver
2344 // Get the receiver from the stack.
2351 // Restore receiver.
2359 // Patch the receiver on the stack with the global proxy if
2394 // -- esp[(argc + 1) * 4] : receiver
2411 // Patch the receiver on the stack with the global proxy.
2451 // -- edx : receiver
2477 // -- edx : receiver
2496 __ push(edx); // receiver
2518 Handle<JSObject> receiver,
2523 // -- edx : receiver
2529 __ CheckMap(edx, Handle<Map>(receiver->map()),
2533 if (receiver->IsJSGlobalProxy()) {
2539 ASSERT(receiver->IsJSGlobalProxy() || !receiver->IsAccessCheckNeeded());
2542 __ push(edx); // receiver
2570 // -- edx : receiver
2618 // -- edx : receiver
2649 // -- edx : receiver
2674 // -- edx : receiver
2680 // ebx: receiver->map().
2706 // -- eax : receiver
2712 // Check that the receiver isn't a smi.
2747 // -- eax : receiver
2768 // -- eax : receiver
2789 // -- eax : receiver
2804 Handle<Code> LoadStubCompiler::CompileLoadInterceptor(Handle<JSObject> receiver,
2808 // -- eax : receiver
2819 GenerateLoadInterceptor(receiver, holder, &lookup, eax, ecx, edx, ebx, edi,
2837 // -- eax : receiver
2879 Handle<JSObject> receiver,
2884 // -- edx : receiver
2896 GenerateLoadField(receiver, holder, edx, ebx, ecx, edi, index, name, &miss);
2909 Handle<JSObject> receiver,
2914 // -- edx : receiver
2926 GenerateLoadCallback(receiver, holder, edx, eax, ebx, ecx, edi, callback,
2940 Handle<JSObject> receiver,
2945 // -- edx : receiver
2958 receiver, holder, edx, ebx, ecx, edi, value, name, &miss);
2969 Handle<JSObject> receiver,
2974 // -- edx : receiver
2988 GenerateLoadInterceptor(receiver, holder, &lookup, edx, eax, ecx, ebx, edi,
3003 // -- edx : receiver
3029 // -- edx : receiver
3055 // -- edx : receiver
3081 // -- edx : receiver
3102 // -- edx : receiver
3238 // Remove caller arguments and receiver from the stack and return.
3266 // -- edx : receiver
3271 // This stub is meant to be tail-jumped to, the receiver must already
3278 // Push receiver on the stack to free up a register for the dictionary
3288 // Pop receiver before returning.
3298 // -- edx : receiver
3310 // -- edx : receiver
3325 // -- edx : receiver
3330 // This stub is meant to be tail-jumped to, the receiver must already
3453 // -- edx : receiver
3462 // -- edx : receiver
3479 // -- edx : receiver
3484 // This stub is meant to be tail-jumped to, the receiver must already
3499 // edx: receiver
3554 // edx: receiver
3651 // -- edx : receiver
3661 // -- edx : receiver
3675 // -- edx : receiver
3680 // This stub is meant to be tail-jumped to, the receiver must already
3713 // -- edx : receiver
3718 // This stub is meant to be tail-jumped to, the receiver must already
3781 // -- edx : receiver
3787 // This stub is meant to be tail-jumped to, the receiver must already
3875 // edx: receiver
3907 // edx: receiver
3936 // -- edx : receiver
3942 // This stub is meant to be tail-jumped to, the receiver must already
4012 // edx: receiver
4035 // edx: receiver
