Lines Matching defs:rax
78 __ testl(rax, Immediate(delta_to_patch_site));
194 // Context is returned in both rax and rsi. It replaces the context
206 __ movq(rax, Operand(rbp, parameter_offset));
209 __ movq(Operand(rsi, context_offset), rax);
210 // Update the write barrier. This clobbers rax and rbx.
212 rsi, context_offset, rax, rbx, kDontSaveFPRegs);
250 SetVar(arguments, rax, rbx, rdx);
298 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
305 __ Set(rax, 0);
370 __ push(rax);
386 __ push(rax);
394 __ pop(rax);
742 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
889 __ LoadContext(rax, scope_->ContextChainLength(scope_->GlobalScope()));
890 __ movq(rax, ContextOperand(rax, variable->interface()->Index()));
891 __ movq(rax, ContextOperand(rax, Context::EXTENSION_INDEX));
894 __ movq(ContextOperand(rsi, variable->index()), rax);
898 rax,
994 __ or_(rcx, rax);
997 __ cmpq(rdx, rax);
1010 __ testq(rax, rax);
1051 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1055 __ cmpq(rax, null_value);
1062 __ JumpIfSmi(rax, &convert);
1063 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1066 __ push(rax);
1069 __ push(rax);
1074 __ CmpObjectType(rax, LAST_JS_PROXY_TYPE, rcx);
1086 __ movq(rax, FieldOperand(rax, HeapObject::kMapOffset));
1091 __ push(rax); // Duplicate the enumerable object on the stack.
1098 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
1102 // We got a map in register rax. Get the enumeration cache from it.
1107 __ EnumLength(rdx, rax);
1111 __ LoadInstanceDescriptors(rax, rcx);
1116 __ push(rax); // Map.
1126 // We got a fixed array in register rax. Iterate through that.
1146 __ push(rax); // Array
1147 __ movq(rax, FieldOperand(rax, FixedArray::kLengthOffset));
1148 __ push(rax); // Fixed array length (as smi).
1154 __ movq(rax, Operand(rsp, 0 * kPointerSize)); // Get the current index.
1155 __ cmpq(rax, Operand(rsp, 1 * kPointerSize)); // Compare to the array length.
1160 SmiIndex index = masm()->SmiToIndex(rax, rax, kPointerSizeLog2);
1188 __ Cmp(rax, Smi::FromInt(0));
1190 __ movq(rbx, rax);
1234 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1236 __ CompareRoot(rax, Heap::kNullValueRootIndex);
1241 __ JumpIfSmi(rax, &convert);
1242 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
1245 __ push(rax);
1305 context()->Plug(rax);
1366 __ movq(rax, GlobalObjectOperand());
1420 __ movq(rax, ContextSlotOperandCheckExtensions(local, slow));
1424 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1427 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1451 __ movq(rax, GlobalObjectOperand());
1454 context()->Plug(rax);
1500 GetVar(rax, var);
1501 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1511 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1514 context()->Plug(rax);
1533 context()->Plug(rax);
1547 // rax = regexp literal clone.
1557 // Result will be in rax.
1563 __ movq(rbx, rax);
1568 __ Allocate(size, rax, rcx, rdx, &runtime_allocate, TAG_OBJECT);
1583 __ movq(FieldOperand(rax, i), rdx);
1584 __ movq(FieldOperand(rax, i + kPointerSize), rcx);
1588 __ movq(FieldOperand(rax, size - kPointerSize), rdx);
1590 context()->Plug(rax);
1631 __ movq(rax, FieldOperand(rdi, JSFunction::kLiteralsOffset));
1640 // result_saved is false the result is in rax.
1656 __ push(rax); // Save result on the stack
1731 context()->Plug(rax);
1757 __ movq(rax, FieldOperand(rbx, JSFunction::kLiteralsOffset));
1794 __ movq(rax, FieldOperand(rbx, JSFunction::kLiteralsOffset));
1812 __ push(rax); // array literal
1845 context()->Plug(rax);
1889 __ push(rax);
1919 __ push(rax); // Left operand goes on the stack.
1951 context()->Plug(rax);
1986 __ Move(FieldOperand(rax, JSGeneratorObject::kContinuationOffset),
1988 __ movq(FieldOperand(rax, JSGeneratorObject::kContextOffset), rsi);
1990 __ RecordWriteField(rax, JSGeneratorObject::kContextOffset, rcx, rdx,
1995 __ push(rax); // generator object
2031 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
2040 __ push(rax); // exception
2047 __ pop(rax); // result
2050 __ push(rax); // result
2056 __ movq(rax, Operand(rsp, generator_object_depth));
2057 __ push(rax); // g
2059 __ Move(FieldOperand(rax, JSGeneratorObject::kContinuationOffset),
2061 __ movq(FieldOperand(rax, JSGeneratorObject::kContextOffset), rsi);
2063 __ RecordWriteField(rax, JSGeneratorObject::kContextOffset, rcx, rdx,
2068 __ pop(rax); // result
2070 __ bind(&l_resume); // received in rax
2078 __ push(rax); // received
2089 __ push(rax); // save result
2092 CallIC(done_ic); // result.done in rax
2099 __ pop(rax); // result
2102 CallIC(value_ic); // result.value in rax
2103 context()->DropAndPlug(2, rax); // drop iter and g
2113 // The value stays in rax, and is ultimately read by the resumed generator, as
2213 __ Allocate(map->instance_size(), rax, rcx, rdx, &gc_required, TAG_OBJECT);
2227 __ movq(FieldOperand(rax, HeapObject::kMapOffset), rbx);
2228 __ Move(FieldOperand(rax, JSObject::kPropertiesOffset),
2230 __ Move(FieldOperand(rax, JSObject::kElementsOffset),
2232 __ movq(FieldOperand(rax, JSGeneratorObject::kResultValuePropertyOffset),
2234 __ movq(FieldOperand(rax, JSGeneratorObject::kResultDonePropertyOffset),
2239 __ RecordWriteField(rax, JSGeneratorObject::kResultValuePropertyOffset,
2266 // stack (popped into rdx). Right operand is in rax but moved into
2270 __ movq(rcx, rax);
2271 __ or_(rax, rdx);
2273 patch_site.EmitJumpIfSmi(rax, &smi_case, Label::kNear);
2276 __ movq(rax, rcx);
2286 __ SmiShiftArithmeticRight(rax, rdx, rcx);
2289 __ SmiShiftLeft(rax, rdx, rcx);
2292 __ SmiShiftLogicalRight(rax, rdx, rcx, &stub_call);
2295 __ SmiAdd(rax, rdx, rcx, &stub_call);
2298 __ SmiSub(rax
2301 __ SmiMul(rax, rdx, rcx, &stub_call);
2304 __ SmiOr(rax, rdx, rcx);
2307 __ SmiAnd(rax, rdx, rcx);
2310 __ SmiXor(rax, rdx, rcx);
2318 context()->Plug(rax);
2331 context()->Plug(rax);
2362 __ push(rax); // Preserve value.
2364 __ movq(rdx, rax);
2365 __ pop(rax); // Restore value.
2374 __ push(rax); // Preserve value.
2377 __ movq(rcx, rax);
2379 __ pop(rax); // Restore value.
2387 context()->Plug(rax);
2409 __ movq(StackOperand(var), rax);
2418 __ push(rax);
2427 __ push(rax); // Value.
2442 __ movq(location, rax);
2444 __ movq(rdx, rax);
2462 __ movq(location, rax);
2464 __ movq(rdx, rax);
2470 __ push(rax); // Value.
2497 context()->Plug(rax);
2514 context()->Plug(rax);
2526 context()->Plug(rax);
2532 context()->Plug(rax);
2566 context()->Plug(rax);
2578 __ push(rax);
2599 context()->DropAndPlug(1, rax); // Drop the key still on the stack.
2630 context()->DropAndPlug(1, rax);
2688 // The runtime call returns a pair of values in rax (function) and
2691 __ movq(Operand(rsp, (arg_count + 1) * kPointerSize), rax);
2701 context()->DropAndPlug(1, rax);
2717 // Call the runtime to find the function to call (returned in rax) and
2722 __ push(rax); // Function.
2732 __ push(rax);
2795 // Load function and argument count into rdi and rax.
2796 __ Set(rax, arg_count);
2809 context()->Plug(rax);
2827 __ JumpIfSmi(rax, if_true);
2848 Condition non_negative_smi = masm()->CheckNonNegativeSmi(rax);
2868 __ JumpIfSmi(rax, if_false);
2869 __ CompareRoot(rax, Heap::kNullValueRootIndex);
2871 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2900 __ JumpIfSmi(rax, if_false);
2901 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
2922 __ JumpIfSmi(rax, if_false);
2923 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2947 __ AssertNotSmi(rax);
2951 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2957 __ movq(rcx, FieldOperand(rax, JSObject::kPropertiesOffset));
2997 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
3034 __ JumpIfSmi(rax, if_false);
3035 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3056 __ JumpIfSmi(rax, if_false);
3057 __ CmpObjectType(rax, JS_ARRAY_TYPE, rbx);
3078 __ JumpIfSmi(rax, if_false);
3079 __ CmpObjectType(rax, JS_REGEXP_TYPE, rbx);
3099 __ movq(rax, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
3103 __ Cmp(Operand(rax, StandardFrameConstants::kContextOffset),
3106 __ movq(rax, Operand(rax, StandardFrameConstants::kCallerFPOffset));
3110 __ Cmp(Operand(rax, StandardFrameConstants::kMarkerOffset),
3135 __ cmpq(rax, rbx);
3148 // parameter count in rax.
3150 __ movq(rdx, rax);
3151 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
3154 context()->Plug(rax);
3163 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
3173 __ movq(rax, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3176 __ AssertSmi(rax);
3177 context()->Plug(rax);
3189 __ JumpIfSmi(rax, &null);
3196 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rax);
3197 // Map is now in rax.
3203 __ CmpInstanceType(rax, LAST_SPEC_OBJECT_TYPE);
3211 __ movq(rax, FieldOperand(rax, Map::kConstructorOffset));
3212 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3215 // rax now contains the constructor function. Grab the
3217 __ movq(rax, FieldOperand(rax, JSFunction::kSharedFunctionInfoOffset));
3218 __ movq(rax, FieldOperand(rax, SharedFunctionInfo::kInstanceClassNameOffset));
3223 __ Move(rax, isolate()->factory()->function_class_string());
3228 __ Move(rax, isolate()->factory()->Object_string());
3233 __ LoadRoot(rax, Heap::kNullValueRootIndex);
3238 context()->Plug(rax);
3258 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
3259 context()->Plug(rax);
3275 __ movq(rbx, rax);
3279 // Return a random uint32 number in rax.
3288 // Convert 32 random bits in rax to 0.(32 random bits) in a double
3293 __ movd(xmm0, rax);
3299 __ movq(rax, rbx);
3300 context()->Plug(rax);
3313 context()->Plug(rax);
3327 context()->Plug(rax);
3339 __ JumpIfSmi(rax, &done);
3341 __ CmpObjectType(rax, JS_VALUE_TYPE, rbx);
3343 __ movq(rax, FieldOperand(rax, JSValue::kValueOffset));
3346 context()->Plug(rax);
3359 Register object = rax;
3360 Register result = rax;
3393 context()->Plug(rax);
3425 Register string = rax;
3452 Register string = rax;
3471 context()->Plug(rax);
3483 context()->Plug(rax);
3493 __ pop(rbx); // rax = value. rbx = object.
3504 __ movq(FieldOperand(rbx, JSValue::kValueOffset), rax);
3507 __ movq(rdx, rax);
3511 context()->Plug(rax);
3524 context()->Plug(rax);
3535 StringCharFromCodeGenerator generator(rax, rbx);
3555 Register index = rax;
3601 Register index = rax;
3603 Register result = rax;
3650 context()->Plug(rax);
3663 context()->Plug(rax);
3675 context()->Plug(rax);
3687 context()->Plug(rax);
3699 context()->Plug(rax);
3711 context()->Plug(rax);
3721 context()->Plug(rax);
3737 __ JumpIfSmi(rax, &runtime);
3738 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
3750 __ push(rax);
3754 context()->Plug(rax);
3766 context()->Plug(rax);
3781 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
3782 context()->Plug(rax);
3788 Register key = rax;
3810 __ movq(rax, FieldOperand(cache,
3823 context()->Plug(rax);
3831 Register right = rax;
3856 __ Move(rax, isolate()->factory()->false_value());
3859 __ Move(rax, isolate()->factory()->true_value());
3862 context()->Plug(rax);
3879 __ testl(FieldOperand(rax, String::kHashFieldOffset),
3894 __ AssertString(rax);
3896 __ movl(rax, FieldOperand(rax, String::kHashFieldOffset));
3898 __ IndexFromHash(rax, rax);
3900 context()->Plug(rax);
3912 // Load this to rax (= array)
3915 Register array = rax;
3916 Register elements = no_reg; // Will be rax.
3950 __ LoadRoot(rax, Heap::kempty_stringRootIndex);
4004 __ movq(rax, FieldOperand(elements, FixedArray::kHeaderSize));
4088 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
4179 __ movq(rax, result_operand);
4185 context()->Plug(rax);
4202 __ movq(rax, GlobalObjectOperand());
4203 __ push(FieldOperand(rax, GlobalObject::kBuiltinsOffset));
4224 context()->Plug(rax);
4242 context()->Plug(rax);
4253 context()->Plug(rax);
4265 context()->Plug(rax);
4311 __ LoadRoot(rax, Heap::kTrueValueRootIndex);
4319 __ LoadRoot(rax, Heap::kFalseValueRootIndex);
4334 context()->Plug(rax);
4379 __ push(rax); // Copy of receiver, needed for later store.
4385 __ push(rax); // Copy of key, needed for later store.
4401 __ JumpIfSmi(rax, &no_conversion, Label::kNear);
4415 __ push(rax);
4418 __ movq(Operand(rsp, kPointerSize), rax);
4421 __ movq(Operand(rsp, 2 * kPointerSize), rax);
4433 __ SmiAddConstant(rax, rax, Smi::FromInt(1));
4435 __ SmiSubConstant(rax, rax, Smi::FromInt(1));
4440 patch_site.EmitJumpIfSmi(rax, &done, Label::kNear);
4445 __ SmiSubConstant(rax, rax, Smi::FromInt(1));
4447 __ SmiAddConstant(rax, rax, Smi::FromInt(1));
4455 __ movq(rdx, rax);
4456 __ Move(rax, Smi::FromInt(1));
4464 // Store the value returned in rax.
4473 context.Plug(rax);
4485 context()->Plug(rax);
4501 context()->Plug(rax);
4518 context()->Plug(rax);
4534 __ movq(rax, GlobalObjectOperand());
4540 context()->Plug(rax);
4555 context()->Plug(rax);
4579 __ JumpIfSmi(rax, if_true);
4580 __ movq(rax, FieldOperand(rax, HeapObject::kMapOffset));
4581 __ CompareRoot(rax, Heap::kHeapNumberMapRootIndex);
4584 __ JumpIfSmi(rax, if_false);
4586 __ CmpObjectType(rax, FIRST_NONSTRING_TYPE, rdx);
4592 __ JumpIfSmi(rax, if_false);
4593 __ CmpObjectType(rax, SYMBOL_TYPE, rdx);
4596 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4598 __ CompareRoot(rax, Heap::kFalseValueRootIndex);
4602 __ CompareRoot(rax, Heap::kNullValueRootIndex);
4605 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
4607 __ JumpIfSmi(rax, if_false);
4609 __ movq(rdx, FieldOperand(rax, HeapObject::kMapOffset));
4614 __ JumpIfSmi(rax, if_false);
4616 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rdx);
4621 __ JumpIfSmi(rax, if_false);
4623 __ CompareRoot(rax, Heap::kNullValueRootIndex);
4626 __ CmpObjectType(rax, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, rdx);
4665 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4674 __ testq(rax, rax);
4690 __ or_(rcx, rax);
4692 __ cmpq(rdx, rax);
4704 __ testq(rax, rax);
4731 __ CompareRoot(rax, nil_value);
4736 __ testq(rax, rax);
4744 __ movq(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
4745 context()->Plug(rax);
4750 return rax;
