Lines Matching defs:rax
56 __ testl(rax, Immediate(delta_to_patch_site));
204 // Context is returned in rax. It replaces the context passed to us.
206 __ movp(rsi, rax);
207 __ movp(Operand(rbp, StandardFrameConstants::kContextOffset), rax);
217 __ movp(rax, Operand(rbp, parameter_offset));
220 __ movp(Operand(rsi, context_offset), rax);
221 // Update the write barrier. This clobbers rax and rbx.
224 rsi, context_offset, rax, rbx, kDontSaveFPRegs);
227 __ JumpIfInNewSpace(rsi, rax, &done, Label::kNear);
268 SetVar(arguments, rax, rbx, rdx);
315 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
322 __ Set(rax, 0);
385 __ Push(rax);
400 __ Push(rax);
403 __ Pop(rax);
751 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
898 __ LoadContext(rax, scope_->ContextChainLength(scope_->GlobalScope()));
899 __ movp(rax, ContextOperand(rax, variable->interface()->Index()));
900 __ movp(rax, ContextOperand(rax, Context::EXTENSION_INDEX));
903 __ movp(ContextOperand(rsi, variable->index()), rax);
907 rax,
1003 __ orp(rcx, rax);
1006 __ cmpp(rdx, rax);
1023 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
1029 __ testp(rax, rax);
1071 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1075 __ cmpp(rax, null_value);
1082 __ JumpIfSmi(rax, &convert);
1083 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1086 __ Push(rax);
1089 __ Push(rax);
1094 __ CmpObjectType(rax, LAST_JS_PROXY_TYPE, rcx);
1106 __ movp(rax, FieldOperand(rax, HeapObject::kMapOffset));
1111 __ Push(rax); // Duplicate the enumerable object on the stack.
1118 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
1122 // We got a map in register rax. Get the enumeration cache from it.
1127 __ EnumLength(rdx, rax);
1131 __ LoadInstanceDescriptors(rax, rcx);
1136 __ Push(rax); // Map.
1146 // We got a fixed array in register rax. Iterate through that.
1162 __ Push(rax); // Array
1163 __ movp(rax, FieldOperand(rax, FixedArray::kLengthOffset));
1164 __ Push(rax); // Fixed array length (as smi).
1170 __ movp(rax, Operand(rsp, 0 * kPointerSize)); // Get the current index.
1171 __ cmpp(rax, Operand(rsp, 1 * kPointerSize)); // Compare to the array length.
1176 SmiIndex index = masm()->SmiToIndex(rax, rax, kPointerSizeLog2);
1204 __ Cmp(rax, Smi::FromInt(0));
1206 __ movp(rbx, rax);
1305 context()->Plug(rax);
1326 __ Cmp(rax, isolate()->factory()->undefined_value());
1444 __ movp(rax, ContextSlotOperandCheckExtensions(local, slow));
1447 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1450 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1478 context()->Plug(rax);
1525 GetVar(rax, var);
1526 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1536 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1539 context()->Plug(rax);
1558 context()->Plug(rax);
1572 // rax = regexp literal clone.
1582 // Result will be in rax.
1588 __ movp(rbx, rax);
1593 __ Allocate(size, rax, rcx, rdx, &runtime_allocate, TAG_OBJECT);
1608 __ movp(FieldOperand(rax, i), rdx);
1609 __ movp(FieldOperand(rax, i + kPointerSize), rcx);
1613 __ movp(FieldOperand(rax, size - kPointerSize), rdx);
1615 context()->Plug(rax);
1651 __ movp(rax, FieldOperand(rdi, JSFunction::kLiteralsOffset));
1660 // result_saved is false the result is in rax.
1676 __ Push(rax); // Save result on the stack
1689 DCHECK(StoreDescriptor::ValueRegister().is(rax));
1749 context()->Plug(rax);
1789 __ movp(rax, FieldOperand(rbx, JSFunction::kLiteralsOffset));
1807 __ Push(rax); // array literal
1840 context()->Plug(rax);
1910 __ Push(rax); // Left operand goes on the stack.
1942 context()->Plug(rax);
1977 __ Move(FieldOperand(rax, JSGeneratorObject::kContinuationOffset),
1979 __ movp(FieldOperand(rax, JSGeneratorObject::kContextOffset), rsi);
1981 __ RecordWriteField(rax, JSGeneratorObject::kContextOffset, rcx, rdx,
1986 __ Push(rax); // generator object
2025 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
2034 __ Push(rax); // exception
2041 __ Pop(rax); // result
2044 __ Push(rax); // result
2050 __ movp(rax, Operand(rsp, generator_object_depth));
2051 __ Push(rax); // g
2053 __ Move(FieldOperand(rax, JSGeneratorObject::kContinuationOffset),
2055 __ movp(FieldOperand(rax, JSGeneratorObject::kContextOffset), rsi);
2057 __ RecordWriteField(rax, JSGeneratorObject::kContextOffset, rcx, rdx,
2062 __ Pop(rax); // result
2064 __ bind(&l_resume); // received in rax
2073 __ Push(rax); // received
2084 __ movp(rdi, rax);
2094 __ Move(load_receiver, rax);
2101 CallLoadIC(NOT_CONTEXTUAL); // rax=result.done
2114 CallLoadIC(NOT_CONTEXTUAL); // result.value in rax
2115 context()->DropAndPlug(2, rax); // drop iter and g
2125 // The value stays in rax, and is ultimately read by the resumed generator, as
2219 __ Push(rax);
2240 __ Allocate(map->instance_size(), rax, rcx, rdx, &gc_required, TAG_OBJECT);
2254 __ movp(FieldOperand(rax, HeapObject::kMapOffset), rbx);
2255 __ Move(FieldOperand(rax, JSObject::kPropertiesOffset),
2257 __ Move(FieldOperand(rax, JSObject::kElementsOffset),
2259 __ movp(FieldOperand(rax, JSGeneratorObject::kResultValuePropertyOffset),
2261 __ movp(FieldOperand(rax, JSGeneratorObject::kResultDonePropertyOffset),
2266 __ RecordWriteField(rax, JSGeneratorObject::kResultValuePropertyOffset,
2293 __ Push(rax);
2319 // stack (popped into rdx). Right operand is in rax but moved into
2323 __ movp(rcx, rax);
2324 __ orp(rax, rdx);
2326 patch_site.EmitJumpIfSmi(rax, &smi_case, Label::kNear);
2329 __ movp(rax, rcx);
2338 __ SmiShiftArithmeticRight(rax, rdx, rcx);
2341 __ SmiShiftLeft(rax, rdx, rcx, &stub_call);
2344 __ SmiShiftLogicalRight(rax, rdx, rcx, &stub_call);
2347 __ SmiAdd(rax, rdx, rcx, &stub_call);
2350 __ SmiSub(rax, rdx, rcx, &stub_call);
2353 __ SmiMul(rax, rdx, rcx, &stub_call);
2356 __ SmiOr(rax, rdx, rcx);
2359 __ SmiAnd(rax, rdx, rcx);
2362 __ SmiXor(rax, rdx, rcx);
2370 context()->Plug(rax);
2382 context()->Plug(rax);
2408 __ Push(rax); // Preserve value.
2410 __ Move(StoreDescriptor::ReceiverRegister(), rax);
2418 __ Push(rax); // Preserve value.
2421 __ Move(StoreDescriptor::NameRegister(), rax);
2430 context()->Plug(rax);
2436 __ movp(location, rax);
2438 __ movp(rdx, rax);
2457 __ Push(rax);
2489 __ Push(rax); // Value.
2525 context()->Plug(rax);
2534 DCHECK(StoreDescriptor::ValueRegister().is(rax));
2541 context()->Plug(rax);
2552 DCHECK(!rax.is(LoadDescriptor::ReceiverRegister()));
2553 __ movp(LoadDescriptor::ReceiverRegister(), rax);
2559 context()->Plug(rax);
2563 __ Move(LoadDescriptor::NameRegister(), rax);
2566 context()->Plug(rax);
2602 __ movp(Operand(rsp, kPointerSize), rax);
2621 __ Push(rax);
2623 __ Push(rax);
2625 __ Push(rax);
2637 __ movp(Operand(rsp, kPointerSize), rax);
2657 __ Move(LoadDescriptor::NameRegister(), rax);
2663 __ movp(Operand(rsp, kPointerSize), rax);
2694 context()->DropAndPlug(1, rax);
2755 // The runtime call returns a pair of values in rax (function) and
2758 __ movp(Operand(rsp, (arg_count + 1) * kPointerSize), rax);
2768 context()->DropAndPlug(1, rax);
2783 // Call the runtime to find the function to call (returned in rax) and
2788 __ Push(rax); // Function.
2798 __ Push(rax);
2865 // Load function and argument count into rdi and rax.
2866 __ Set(rax, arg_count);
2882 context()->Plug(rax);
2900 __ JumpIfSmi(rax, if_true);
2921 Condition non_negative_smi = masm()->CheckNonNegativeSmi(rax);
2941 __ JumpIfSmi(rax, if_false);
2942 __ CompareRoot(rax, Heap::kNullValueRootIndex);
2944 __ movp(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2973 __ JumpIfSmi(rax, if_false);
2974 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
2995 __ JumpIfSmi(rax, if_false);
2996 __ movp(rbx, FieldOperand(rax, HeapObject::kMapOffset));
3020 __ AssertNotSmi(rax);
3024 __ movp(rbx, FieldOperand(rax, HeapObject::kMapOffset));
3030 __ movp(rcx, FieldOperand(rax, JSObject::kPropertiesOffset));
3104 __ JumpIfSmi(rax, if_false);
3105 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3127 __ CheckMap(rax, map, if_false, DO_SMI_CHECK);
3128 __ cmpl(FieldOperand(rax, HeapNumber::kExponentOffset),
3131 __ cmpl(FieldOperand(rax, HeapNumber::kMantissaOffset),
3153 __ JumpIfSmi(rax, if_false);
3154 __ CmpObjectType(rax, JS_ARRAY_TYPE, rbx);
3175 __ JumpIfSmi(rax, if_false);
3176 __ CmpObjectType(rax, JS_REGEXP_TYPE, rbx);
3196 __ movp(rax, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
3200 __ Cmp(Operand(rax, StandardFrameConstants::kContextOffset),
3203 __ movp(rax, Operand(rax, StandardFrameConstants::kCallerFPOffset));
3207 __ Cmp(Operand(rax, StandardFrameConstants::kMarkerOffset),
3232 __ cmpp(rax, rbx);
3245 // parameter count in rax.
3247 __ movp(rdx, rax);
3248 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
3251 context()->Plug(rax);
3260 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
3270 __ movp(rax, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3273 __ AssertSmi(rax);
3274 context()->Plug(rax);
3286 __ JumpIfSmi(rax, &null);
3293 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rax);
3294 // Map is now in rax.
3300 __ CmpInstanceType(rax, LAST_SPEC_OBJECT_TYPE);
3308 __ movp(rax, FieldOperand(rax, Map::kConstructorOffset));
3309 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3312 // rax now contains the constructor function. Grab the
3314 __ movp(rax, FieldOperand(rax, JSFunction::kSharedFunctionInfoOffset));
3315 __ movp(rax, FieldOperand(rax, SharedFunctionInfo::kInstanceClassNameOffset));
3320 __ Move(rax, isolate()->factory()->Function_string());
3325 __ Move(rax, isolate()->factory()->Object_string());
3330 __ LoadRoot(rax, Heap::kNullValueRootIndex);
3335 context()->Plug(rax);
3348 context()->Plug(rax);
3362 context()->Plug(rax);
3374 __ JumpIfSmi(rax, &done);
3376 __ CmpObjectType(rax, JS_VALUE_TYPE, rbx);
3378 __ movp(rax, FieldOperand(rax, JSValue::kValueOffset));
3381 context()->Plug(rax);
3394 Register object = rax;
3395 Register result = rax;
3428 context()->Plug(rax);
3436 Register string = rax;
3469 Register string = rax;
3494 context()->Plug(rax);
3506 context()->Plug(rax);
3516 __ Pop(rbx); // rax = value. rbx = object.
3527 __ movp(FieldOperand(rbx, JSValue::kValueOffset), rax);
3530 __ movp(rdx, rax);
3534 context()->Plug(rax);
3542 // Load the argument into rax and call the stub.
3547 context()->Plug(rax);
3558 StringCharFromCodeGenerator generator(rax, rbx);
3578 Register index = rax;
3624 Register index = rax;
3626 Register result = rax;
3673 context()->Plug(rax);
3686 context()->Plug(rax);
3702 __ JumpIfSmi(rax, &runtime);
3703 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3714 __ Push(rax);
3718 context()->Plug(rax);
3732 context()->Plug(rax);
3747 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
3748 context()->Plug(rax);
3754 Register key = rax;
3776 __ movp(rax, FieldOperand(cache,
3789 context()->Plug(rax);
3806 __ testl(FieldOperand(rax, String::kHashFieldOffset),
3821 __ AssertString(rax);
3823 __ movl(rax, FieldOperand(rax, String::kHashFieldOffset));
3825 __ IndexFromHash(rax, rax);
3827 context()->Plug(rax);
3839 // Load this to rax (= array)
3842 Register array = rax;
3843 Register elements = no_reg; // Will be rax.
3877 __ LoadRoot(rax, Heap::kempty_stringRootIndex);
3931 __ movp(rax, FieldOperand(elements, FixedArray::kHeaderSize));
4015 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
4106 __ movp(rax, result_operand);
4112 context()->Plug(rax);
4121 __ movzxbp(rax, Operand(kScratchRegister, 0));
4122 __ Integer32ToSmi(rax, rax);
4123 context()->Plug(rax);
4141 __ movp(rax, GlobalObjectOperand());
4142 __ Push(FieldOperand(rax, GlobalObject::kBuiltinsOffset));
4157 __ movp(Operand(rsp, kPointerSize), rax);
4172 context()->DropAndPlug(1, rax);
4182 context()->Plug(rax);
4199 context()->Plug(rax);
4210 context()->Plug(rax);
4222 context()->Plug(rax);
4268 __ LoadRoot(rax, Heap::kTrueValueRootIndex);
4276 __ LoadRoot(rax, Heap::kFalseValueRootIndex);
4291 context()->Plug(rax);
4357 patch_site.EmitJumpIfNotSmi(rax, &slow, Label::kNear);
4367 __ Push(rax);
4370 __ movp(Operand(rsp, kPointerSize), rax);
4373 __ movp(Operand(rsp, 2 * kPointerSize), rax);
4383 __ SmiAddConstant(rax, rax, Smi::FromInt(1), mode, &done, Label::kNear);
4385 __ SmiSubConstant(rax, rax, Smi::FromInt(1), mode, &done, Label::kNear);
4402 __ Push(rax);
4405 __ movp(Operand(rsp, kPointerSize), rax);
4408 __ movp(Operand(rsp, 2 * kPointerSize), rax);
4419 __ movp(rdx, rax);
4420 __ Move(rax, Smi::FromInt(1));
4427 // Store the value returned in rax.
4436 context.Plug(rax);
4448 context()->Plug(rax);
4462 context()->Plug(rax);
4478 context()->Plug(rax);
4503 context()->Plug(rax);
4519 context()->Plug(rax);
4544 __ JumpIfSmi(rax, if_true);
4545 __ movp(rax, FieldOperand(rax, HeapObject::kMapOffset));
4546 __ CompareRoot(rax, Heap::kHeapNumberMapRootIndex);
4549 __ JumpIfSmi(rax, if_false);
4551 __ CmpObjectType(rax, FIRST_NONSTRING_TYPE, rdx);
4557 __ JumpIfSmi(rax, if_false);
4558 __ CmpObjectType(rax, SYMBOL_TYPE, rdx);
4561 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4563 __ CompareRoot(rax, Heap::kFalseValueRootIndex);
4566 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
4568 __ JumpIfSmi(rax, if_false);
4570 __ movp(rdx, FieldOperand(rax, HeapObject::kMapOffset));
4575 __ JumpIfSmi(rax, if_false);
4577 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rdx);
4582 __ JumpIfSmi(rax, if_false);
4583 __ CompareRoot(rax, Heap::kNullValueRootIndex);
4585 __ CmpObjectType(rax, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, rdx);
4624 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4633 __ testp(rax, rax);
4649 __ orp(rcx, rax);
4651 __ cmpp(rdx, rax);
4663 __ testp(rax, rax);
4690 __ CompareRoot(rax, nil_value);
4695 __ testp(rax, rax);
4703 __ movp(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
4704 context()->Plug(rax);
4709 return rax;
