Lines Matching defs:rax
55 // -- rax : actual argument count
72 __ movq(rcx, rax);
113 // -- rax: number of arguments
120 __ StackOverflowCheck(rax, &stack_overflow, Label::kFar);
127 __ SmiTag(rcx, rax);
141 // rax: Number of arguments.
142 Generate_PushArguments(masm, rbx, rax, rcx, ArgumentsElementType::kRaw);
147 // rax: number of arguments (untagged)
150 __ InvokeFunction(rdi, rdx, rax, InvokeType::kCall);
177 // -- rax: number of arguments (untagged)
190 __ SmiTag(rcx, rax);
221 __ LoadRoot(rax, RootIndex::kTheHoleValue);
224 // -- rax implicit receiver
240 __ Push(rax);
245 // since rax needs to store the number of arguments before
247 __ movq(r8, rax);
255 __ SmiUntag(rax, Operand(rbp, ConstructFrameConstants::kLengthOffset));
258 // Argument count in rax.
260 __ StackOverflowCheck(rax, &stack_overflow);
269 // rax: Number of arguments.
270 Generate_PushArguments(masm, rbx, rax, rcx, ArgumentsElementType::kRaw);
276 __ InvokeFunction(rdi, rdx, rax, InvokeType::kCall);
279 // -- rax constructor result
299 __ JumpIfNotRoot(rax, RootIndex::kUndefinedValue, &check_result,
305 __ movq(rax, Operand(rsp, 0 * kSystemPointerSize));
306 __ JumpIfRoot(rax, RootIndex::kTheHoleValue, &do_throw, Label::kNear);
319 __ JumpIfSmi(rax, &use_receiver, Label::kNear);
324 __ CmpObjectType(rax, FIRST_JS_RECEIVER_TYPE, rcx);
444 __ Load(rax, js_entry_sp);
445 __ testq(rax, rax);
448 __ movq(rax, rbp);
449 __ Store(js_entry_sp, rax);
469 __ Store(pending_exception, rax);
470 __ LoadRoot(rax, RootIndex::kException);
565 // register rax and rbx holds the argument count and argument array,
608 __ movq(rax, Operand(kScratchRegister, EntryFrameConstants::kArgcOffset));
612 __ movq(rax, r8);
621 // rax : argc
629 // Argument count in rax.
631 __ StackOverflowCheck(rax, &stack_overflow, Label::kNear);
645 // rax: Number of arguments.
646 Generate_PushArguments(masm, rbx, rax, rcx, ArgumentsElementType::kHandle);
725 // -- rax : the value to pass to the generator
732 FieldOperand(rdx, JSGeneratorObject::kInputOrDebugPosOffset), rax);
735 __ RecordWriteField(object, JSGeneratorObject::kInputOrDebugPosOffset, rax,
773 __ PopReturnAddressTo(rax);
776 // -- rax : return address
830 __ PushReturnAddressFrom(rax);
832 rax, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
833 __ movzxwq(rax, FieldOperand(
834 rax, SharedFunctionInfo::kFormalParameterCountOffset));
946 // -- rax : actual argument count
976 // rax : actual argument count
983 DCHECK(!AreAliased(rax, rdx, closure, rsi, optimized_code_entry, scratch1,
1166 // o rax: actual argument count
1255 __ movq(rax, rsp);
1256 __ subq(rax, rcx);
1257 __ cmpq(rax, __ StackLimitAsOperand(StackLimitKind::kRealStackLimit));
1330 // The return value is in rax.
1423 // -- rax : the number of arguments
1433 __ decl(rax);
1436 __ movl(rcx, rax);
1486 // -- rax : the number of arguments
1498 __ StackOverflowCheck(rax, &stack_overflow);
1505 __ decl(rax);
1510 __ leaq(argc_without_receiver, Operand(rax, -kJSArgcReceiverSlots));
1530 // Jump to the constructor function (rax, rbx, rdx passed on).
1534 // Call the constructor (rax, rdx, rdi passed on).
1539 // Call the constructor (rax, rdx, rdi passed on).
1826 __ movq(kScratchRegister, rax);
1834 rax);
1846 // the LAZY deopt point. rax contains the arguments count, the return value
1848 __ movq(Operand(rsp, rax, times_system_pointer_size,
1900 DCHECK_EQ(kInterpreterAccumulatorRegister.code(), rax.code());
1901 __ movq(rax, Operand(rsp, kPCOnStackSize));
1902 __ ret(1 * kSystemPointerSize); // Remove rax.
1908 // -- rax : argc
1920 StackArgumentsAccessor args(rax);
1924 __ cmpq(rax, Immediate(JSParameterCount(0)));
1928 __ cmpq(rax, Immediate(JSParameterCount(1)));
1934 __ DropArgumentsAndPushNewReceiver(rax, rdx, rcx,
1964 __ Move(rax, JSParameterCount(0));
1978 // rax contains the number of arguments, n.
1982 StackArgumentsAccessor args(rax);
1993 __ cmpq(rax, Immediate(JSParameterCount(0)));
1996 __ incq(rax);
2003 __ decq(rax); // One fewer argument (first argument is new receiver).
2013 // -- rax : argc
2026 StackArgumentsAccessor args(rax);
2030 __ cmpq(rax, Immediate(JSParameterCount(1)));
2035 __ cmpq(rax, Immediate(JSParameterCount(3)));
2039 __ DropArgumentsAndPushNewReceiver(rax, rdx, rcx,
2062 // -- rax : argc
2076 StackArgumentsAccessor args(rax);
2080 __ cmpq(rax, Immediate(JSParameterCount(1)));
2086 __ cmpq(rax, Immediate(JSParameterCount(3)));
2091 rax, masm->RootAsOperand(RootIndex::kUndefinedValue), rcx,
2171 // -- rax : number of parameters on the stack
2204 // rax: Number of arguments already on the stack.
2206 Generate_AllocateSpaceAndShiftExistingArguments(masm, rcx, rax, r8, r9, r12);
2241 // -- rax : the number of arguments
2272 // -- rax : the number of arguments already in the stack
2287 // rax: Number of arguments already on the stack.
2289 Generate_AllocateSpaceAndShiftExistingArguments(masm, r8, rax, r9, r12,
2326 // -- rax : the number of arguments
2330 StackArgumentsAccessor args(rax);
2336 // -- rax : the number of arguments
2353 // -- rax : the number of arguments
2388 __ SmiTag(rax);
2389 __ Push(rax);
2391 __ movq(rax, rcx);
2396 __ movq(rcx, rax);
2398 __ Pop(rax);
2399 __ SmiUntag(rax);
2410 // -- rax : the number of arguments
2418 __ InvokeFunctionCode(rdi, no_reg, rbx, rax, InvokeType::kJump);
2425 // -- rax : the number of arguments
2439 // -- rax : the number of arguments
2477 __ addq(rax, rbx); // Adjust effective number of arguments.
2503 // -- rax : the number of arguments
2509 StackArgumentsAccessor args(rax);
2527 // -- rax : the number of arguments
2530 Register argc = rax;
2604 // -- rax : the number of arguments
2630 // -- rax : the number of arguments
2659 // -- rax : the number of arguments
2664 Register argc = rax;
2740 __ testq(rax, rax);
2753 __ LoadCodeDataContainerCodeNonBuiltin(rax, rax);
2758 rbx, FieldOperand(rax, Code::kDeoptimizationDataOrInterpreterDataOffset));
2766 __ leaq(rax, FieldOperand(rax, rbx, times_1, Code::kHeaderSize));
2768 Generate_OSREntry(masm, rax);
2969 // Returns the new continuation in rax.
2986 STATIC_ASSERT(kReturnRegister0 == rax);
3158 Register in_param_count = rax;
3193 Register target_continuation = rax; /* fixed */
3369 Register param = rax;
3503 // -- GpParamRegisters = rax, rdx, rcx, rbx, r9
3506 Register temp_params_size = rax;
3531 __ movq(rax, MemOperand(start_int_section, 0));
3702 Register return_reg = rax;
3764 // The builtin expects the parameter to be in register param = rax.
3981 Register promise = rax;
4010 // live: [rax, rbx, rcx]
4045 // live: [rax, rcx]
4079 Register param_count = rax;
4109 Register suspender = rax;
4187 kForeignForeignAddressTag, rax);
4210 // rax: number of arguments including receiver
4222 // returned in register rax. Larger return sizes must be written to an address
4232 // are returned in rax, and a struct of two pointers are returned in rax+rdx.
4252 __ movq(r12, rax);
4274 // Return result in single register (rax), or a register pair (rax, rdx).
4296 // Result is in rax or rdx:rax - do not destroy these registers!
4300 __ CompareRoot(rax, RootIndex::kException);
4336 // Ask the runtime for help to determine the handler. This will set rax to
4402 // Since we must use rcx for shifts below, use some other register (rax)
4404 Register result_reg = rax;
4408 Register save_reg = rax;
4499 __ Move(rax, ExternalReference::is_profiling_address(isolate));
4500 __ cmpb(Operand(rax, 0), Immediate(0));
4502 __ Move(rax, ExternalReference::address_of_runtime_stats_flag());
4503 __ cmpl(Operand(rax, 0), Immediate(0));
4507 __ Move(rax, function_address);
4514 __ Move(rax, thunk_ref);
4519 __ call(rax);
4522 __ movq(rax, return_value_operand);
4548 Register return_value = rax;
4603 __ movq(prev_limit_reg, rax);
4605 __ LoadAddress(rax, ExternalReference::delete_handle_scope_extensions());
4606 __ call(rax);
4607 __ movq(rax, prev_limit_reg);
4667 __ PopReturnAddressTo(rax);
4675 __ PushReturnAddressFrom(rax);
4740 Register scratch = rax;
4867 __ Move(rax, 0);
4871 __ movq(rax, Operand(rbp, StandardFrameConstants::kFunctionOffset));
4873 __ movq(arg_reg_1, rax);
4892 // Preserve deoptimizer object in register rax and get the input
4894 __ movq(rbx, Operand(rax, Deoptimizer::input_offset()));
4939 __ pushq(rax);
4941 __ movq(arg_reg_1, rax);
4947 __ popq(rax);
4949 __ movq(rsp, Operand(rax, Deoptimizer::caller_frame_top_offset()));
4953 // Outer loop state: rax = current FrameDescription**, rdx = one past the
4955 __ movl(rdx, Operand(rax, Deoptimizer::output_count_offset()));
4956 __ movq(rax, Operand(rax, Deoptimizer::output_offset()));
4957 __ leaq(rdx, Operand(rax, rdx, times_system_pointer_size, 0));
4961 __ movq(rbx, Operand(rax, 0));
4970 __ addq(rax, Immediate(kSystemPointerSize));
4972 __ cmpq(rax, rdx);