Lines Matching defs:ecx
66 __ mov(ecx, eax);
75 static_assert(kJavaScriptCallCodeStartRegister == ecx, "ABI mismatch");
76 __ JumpCodeObject(ecx);
117 __ StackOverflowCheck(eax, ecx, &stack_overflow);
140 Generate_PushArguments(masm, esi, eax, ecx, no_reg,
161 __ DropArguments(edx, ecx, TurboAssembler::kCountIsSmi,
192 __ mov(ecx, eax);
193 __ SmiTag(ecx);
195 __ Push(ecx);
213 static_cast<uint32_t>(FunctionKind::kDerivedConstructor), ecx,
261 // Argument count in eax. Clobbers ecx.
263 __ StackOverflowCheck(eax, ecx, &stack_overflow);
273 Generate_PushArguments(masm, edi, eax, ecx, no_reg,
277 __ movd(ecx, xmm0);
278 __ Push(ecx);
318 __ DropArguments(edx, ecx, TurboAssembler::kCountIsSmi,
332 __ CmpObjectType(eax, FIRST_JS_RECEIVER_TYPE, ecx);
522 // Argument count in eax. Clobbers ecx.
524 __ StackOverflowCheck(eax, ecx, &stack_overflow);
537 Generate_PushArguments(masm, scratch1, eax, ecx, scratch2,
657 __ cmpb(__ ExternalReferenceAsOperand(debug_hook, ecx), Immediate(0));
663 __ cmp(edx, __ ExternalReferenceAsOperand(debug_suspended_generator, ecx));
687 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
688 __ movzx_w(ecx, FieldOperand(
689 ecx, SharedFunctionInfo::kFormalParameterCountOffset));
690 __ dec(ecx); // Exclude receiver.
696 __ dec(ecx);
699 FieldOperand(ebx, ecx, times_tagged_size, FixedArray::kHeaderSize));
715 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
716 __ mov(ecx, FieldOperand(ecx, SharedFunctionInfo::kFunctionDataOffset));
718 GetSharedFunctionInfoBytecodeOrBaseline(masm, ecx, eax, &is_baseline);
721 __ CmpObjectType(ecx, BYTECODE_ARRAY_TYPE, ecx);
727 __ CmpObjectType(ecx, CODET_TYPE, ecx);
742 static_assert(kJavaScriptCallCodeStartRegister == ecx, "ABI mismatch");
743 __ mov(ecx, FieldOperand(edi, JSFunction::kCodeOffset));
744 __ JumpCodeObject(ecx);
869 ecx);
870 static_assert(kJavaScriptCallCodeStartRegister == ecx, "ABI mismatch");
872 __ LoadCodeObjectEntry(ecx, optimized_code_entry);
875 __ jmp(ecx);
1074 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
1075 __ mov(ecx, FieldOperand(ecx, SharedFunctionInfo::kFunctionDataOffset));
1078 GetSharedFunctionInfoBytecodeOrBaseline(masm, ecx, eax, &is_baseline);
1081 __ CmpObjectType(ecx, BYTECODE_ARRAY_TYPE, eax);
1084 Register feedback_vector = ecx;
1099 Register optimization_state = ecx;
1152 Register frame_size = ecx;
1179 __ mov(ecx, FieldOperand(
1182 __ test(ecx, ecx);
1184 __ mov(Operand(ebp, ecx, times_system_pointer_size, 0), edx);
1206 __ movzx_b(ecx, Operand(kInterpreterBytecodeArrayRegister,
1209 Operand(kInterpreterDispatchTableRegister, ecx,
1228 kInterpreterBytecodeOffsetRegister, ecx,
1237 LeaveInterpreterFrame(masm, edx, ecx);
1280 __ movd(xmm2, ecx); // Save baseline data.
1298 __ movd(ecx, xmm2);
1299 static_assert(kJavaScriptCallCodeStartRegister == ecx, "ABI mismatch");
1301 __ push(ecx);
1303 ReplaceClosureCodeWithOptimizedCode(masm, ecx, closure, eax, ecx);
1305 __ pop(ecx);
1307 __ JumpCodeObject(ecx);
1345 // -- ecx : the address of the first argument to be pushed. Subsequent
1352 const Register argv = ecx;
1381 // Pass the spread in the register ecx.
1382 __ movd(ecx, xmm1);
1383 __ mov(ecx, Operand(ecx, 0));
1483 // -- ecx : the address of the first argument to be pushed. Subsequent
1499 // stack. The eax register is readonly. The ecx register will be modified. edx
1502 masm, eax, ecx, edx, edi,
1506 // Call the appropriate constructor. eax and ecx already contain intended
1532 // Pass the spread in the register ecx, overwriting ecx.
1533 __ mov(ecx, Operand(ecx, 0));
1540 __ PopReturnAddressTo(ecx);
1544 __ PushReturnAddressFrom(ecx);
1562 static constexpr Register scratch = ecx;
1654 kInterpreterBytecodeOffsetRegister, ecx, esi,
1660 __ mov(ecx, kInterpreterBytecodeOffsetRegister);
1661 __ SmiTag(ecx);
1662 __ mov(Operand(ebp, InterpreterFrameConstants::kBytecodeOffsetFromFp), ecx);
1705 Register feedback_vector = ecx;
1719 Register optimization_state = ecx;
1940 __ DropArgumentsAndPushNewReceiver(eax, edi, ecx,
1996 __ Pop(ecx);
2035 __ mov(ecx, edi);
2040 __ mov(ecx, args[2]); // thisArgument
2049 __ DropArgumentsAndPushNewReceiver(eax, ecx, edx,
2083 // 1. Load target into edi (if present), argumentsList into ecx (if present),
2092 __ mov(ecx, edi);
2098 __ mov(ecx, args[2]); // argumentsList
2104 // Spill argumentsList to use ecx as a scratch register.
2105 __ movd(xmm0, ecx);
2108 eax, masm->RootAsOperand(RootIndex::kUndefinedValue), ecx,
2113 __ movd(ecx, xmm0);
2117 // -- ecx : argumentsList
2190 // -- ecx : len (number of elements to from args)
2201 const Register kArgumentsLength = ecx;
2234 // kArgumentsLength (ecx): Number of arguments to make room for.
2286 // -- ecx : start index (to support rest parameters)
2317 __ sub(edx, ecx);
2322 // -- ecx : start index (to support rest parameters)
2346 __ lea(ecx, Operand(ecx, times_system_pointer_size,
2349 __ add(ecx, ebp);
2355 Register src = ecx, dest = esi, num = edx;
2413 __ LoadGlobalProxy(ecx);
2416 __ mov(ecx, args.GetReceiverOperand());
2417 __ JumpIfSmi(ecx, &convert_to_object, Label::kNear);
2419 __ CmpObjectType(ecx, FIRST_JS_RECEIVER_TYPE, ecx); // Clobbers ecx.
2422 __ mov(ecx, args.GetReceiverOperand());
2425 __ JumpIfRoot(ecx, RootIndex::kUndefinedValue, &convert_global_proxy,
2427 __ JumpIfNotRoot(ecx, RootIndex::kNullValue, &convert_to_object,
2432 __ LoadGlobalProxy(ecx);
2445 __ mov(eax, ecx);
2450 __ mov(ecx, eax);
2458 __ mov(args.GetReceiverOperand(), ecx);
2470 ecx, FieldOperand(edx, SharedFunctionInfo::kFormalParameterCountOffset));
2471 __ InvokeFunctionCode(edi, no_reg, ecx, eax, InvokeType::kJump);
2484 // Load [[BoundArguments]] into ecx and length of that into edx.
2486 __ mov(ecx, FieldOperand(edi, JSBoundFunction::kBoundArgumentsOffset));
2487 __ mov(edx, FieldOperand(ecx, FixedArray::kLengthOffset));
2496 // -- ecx : the [[BoundArguments]] (implemented as FixedArray)
2503 __ StackOverflowCheck(edx, ecx, &stack_overflow);
2527 __ mov(ecx, FieldOperand(edi, JSBoundFunction::kBoundArgumentsOffset));
2528 __ mov(edx, FieldOperand(ecx, FixedArray::kLengthOffset));
2536 __ mov(esi, FieldOperand(ecx, edx, times_tagged_size,
2568 __ mov(ecx, FieldOperand(edi, JSBoundFunction::kBoundThisOffset));
2569 __ mov(args.GetReceiverOperand(), ecx);
2588 Register map = ecx;
2675 __ AssertFunction(edi, ecx);
2680 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
2681 __ test(FieldOperand(ecx, SharedFunctionInfo::kFlagsOffset),
2686 // ecx to contain either an AllocationSite or undefined.
2687 __ LoadRoot(ecx, RootIndex::kUndefinedValue);
2693 // ecx to contain either an AllocationSite or undefined.
2694 __ LoadRoot(ecx, RootIndex::kUndefinedValue);
2736 Register map = ecx;
2826 __ mov(ecx, Operand(eax, Code::kDeoptimizationDataOrInterpreterDataOffset -
2830 __ mov(ecx, Operand(ecx, FixedArray::OffsetOfElementAt(
2833 __ SmiUntag(ecx);
2836 __ lea(eax, Operand(eax, ecx, times_1, Code::kHeaderSize - kHeapObjectTag));
2998 // ecx: pointer to the first argument
3001 STATIC_ASSERT(ecx == kRuntimeCallArgvRegister);
3023 __ mov(esi, ecx);
3046 __ Move(ecx, Immediate(ExternalReference::isolate_address(masm->isolate())));
3047 __ mov(Operand(esp, 2 * kSystemPointerSize), ecx);
3065 __ cmp(edx, __ ExternalReferenceAsOperand(pending_exception_address, ecx));
3146 // Since we must use ecx for shifts below, use some other register (eax)
3149 // Save ecx if it isn't the return register and therefore volatile, or if it
3153 __ push(ecx);
3163 __ mov(ecx, exponent_operand);
3165 __ and_(ecx, HeapNumber::kExponentMask);
3166 __ shr(ecx, HeapNumber::kExponentShift);
3167 __ lea(result_reg, MemOperand(ecx, -HeapNumber::kExponentBias));
3177 __ sub(ecx, Immediate(delta));
3179 __ cmp(ecx, Immediate(31));
3196 __ sub(ecx, Immediate(delta));
3197 __ neg(ecx);
3206 __ test(ecx, Immediate(32));
3222 __ pop(ecx);
3304 __ mov(__ ExternalReferenceAsOperand(next_address, ecx), esi);
3305 __ sub(__ ExternalReferenceAsOperand(level_address, ecx), Immediate(1));
3307 __ cmp(edi, __ ExternalReferenceAsOperand(limit_address, ecx));
3321 __ mov(ecx, __ ExternalReferenceAsOperand(scheduled_exception_address, ecx));
3322 __ CompareRoot(ecx, RootIndex::kTheHoleValue);
3329 Register map = ecx;
3368 __ pop(ecx);
3370 __ jmp(ecx);
3381 __ mov(__ ExternalReferenceAsOperand(limit_address, ecx), edi);
3397 // -- ecx : arguments count (not including the receiver)
3409 Register argc = ecx;
3442 __ PopReturnAddressTo(ecx);
3449 __ PushReturnAddressFrom(ecx);
3596 // ecx - count (copy size in bytes)
3603 Register count = ecx;
3692 Register count = ecx;
4006 __ mov(ecx, Operand(esp, kSavedRegistersAreaSize));
4023 __ mov(Operand(esp, 2 * kSystemPointerSize), ecx); // Code address or 0.
4067 // Compute a pointer to the unwinding limit in register ecx; that is
4069 __ mov(ecx, Operand(esi, FrameDescription::frame_size_offset()));
4070 __ add(ecx, esp);
4083 __ cmp(ecx, esp);
4107 // Inner loop state: esi = current FrameDescription*, ecx = loop
4110 __ mov(ecx, Operand(esi, FrameDescription::frame_size_offset()));
4113 __ sub(ecx, Immediate(sizeof(uint32_t)));
4114 __ push(Operand(esi, ecx, times_1, FrameDescription::frame_content_offset()));
4116 __ test(ecx, ecx);
4218 AssertCodeIsBaseline(masm, code_obj, ecx);
4222 Register feedback_vector = ecx;
4252 Register get_baseline_pc = ecx;
4313 // scope, to keep the stack valid. Use ecx for this -- we can't save it in
4315 DCHECK(!AreAliased(ecx, kContextRegister, closure));
4316 __ pop(ecx);
4322 __ Push(ecx);