Lines Matching defs:rax
77 __ testl(rax, Immediate(delta_to_patch_site));
140 __ movq(rax, Handle<JSGlobalPropertyCell>(cell),
142 __ SmiAddConstant(FieldOperand(rax, JSGlobalPropertyCell::kValueOffset),
210 // Context is returned in both rax and rsi. It replaces the context
222 __ movq(rax, Operand(rbp, parameter_offset));
225 __ movq(Operand(rsi, context_offset), rax);
226 // Update the write barrier. This clobbers rax and rbx.
228 rsi, context_offset, rax, rbx, kDontSaveFPRegs);
266 SetVar(arguments, rax, rbx, rdx);
314 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
321 __ Set(rax, 0);
343 __ testl(rax, Immediate(Min(loop_depth(), Code::kMaxLoopNestingMarker)));
361 __ push(rax);
699 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
846 __ or_(rcx, rax);
849 __ cmpq(rdx, rax);
862 __ testq(rax, rax);
904 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
908 __ cmpq(rax, null_value);
915 __ JumpIfSmi(rax, &convert);
916 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
919 __ push(rax);
922 __ push(rax);
927 __ CmpObjectType(rax, LAST_JS_PROXY_TYPE, rcx);
939 __ movq(rax, FieldOperand(rax, HeapObject::kMapOffset));
944 __ push(rax); // Duplicate the enumerable object on the stack.
951 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
955 // We got a map in register rax. Get the enumeration cache from it.
957 __ LoadInstanceDescriptors(rax, rcx);
962 __ push(rax); // Map.
964 __ movq(rax, FieldOperand(rdx, FixedArray::kLengthOffset));
965 __ push(rax); // Enumeration cache length (as smi).
969 // We got a fixed array in register rax. Iterate through that.
990 __ push(rax); // Array
991 __ movq(rax, FieldOperand(rax, FixedArray::kLengthOffset));
992 __ push(rax); // Fixed array length (as smi).
998 __ movq(rax, Operand(rsp, 0 * kPointerSize)); // Get the current index.
999 __ cmpq(rax, Operand(rsp, 1 * kPointerSize)); // Compare to the array length.
1004 SmiIndex index = masm()->SmiToIndex(rax, rax, kPointerSizeLog2);
1032 __ Cmp(rax, Smi::FromInt(0));
1034 __ movq(rbx, rax);
1091 context()->Plug(rax);
1152 __ movq(rax, GlobalObjectOperand());
1206 __ movq(rax, ContextSlotOperandCheckExtensions(local, slow));
1210 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1213 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1237 __ movq(rax, GlobalObjectOperand());
1240 context()->Plug(rax);
1286 GetVar(rax, var);
1287 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
1297 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
1300 context()->Plug(rax);
1319 context()->Plug(rax);
1333 // rax = regexp literal clone.
1343 // Result will be in rax.
1349 __ movq(rbx, rax);
1354 __ AllocateInNewSpace(size, rax, rcx, rdx, &runtime_allocate, TAG_OBJECT);
1369 __ movq(FieldOperand(rax, i), rdx);
1370 __ movq(FieldOperand(rax, i + kPointerSize), rcx);
1374 __ movq(FieldOperand(rax, size - kPointerSize), rdx);
1376 context()->Plug(rax);
1415 // result_saved is false the result is in rax.
1431 __ push(rax); // Save result on the stack
1499 context()->Plug(rax);
1562 __ push(rax);
1596 context()->Plug(rax);
1640 __ push(rax);
1670 __ push(rax); // Left operand goes on the stack.
1702 context()->Plug(rax);
1736 // stack (popped into rdx). Right operand is in rax but moved into
1740 __ movq(rcx, rax);
1741 __ or_(rax, rdx);
1743 patch_site.EmitJumpIfSmi(rax, &smi_case, Label::kNear);
1746 __ movq(rax, rcx);
1755 __ SmiShiftArithmeticRight(rax, rdx, rcx);
1758 __ SmiShiftLeft(rax, rdx, rcx);
1761 __ SmiShiftLogicalRight(rax, rdx, rcx, &stub_call);
1764 __ SmiAdd(rax, rdx, rcx, &stub_call);
1767 __ SmiSub(rax, rdx, rcx, &stub_call);
1770 __ SmiMul(rax, rdx, rcx, &stub_call);
1773 __ SmiOr(rax, rdx, rcx);
1776 __ SmiAnd(rax, rdx, rcx);
1779 __ SmiXor(rax, rdx, rcx);
1787 context()->Plug(rax);
1799 context()->Plug(rax);
1830 __ push(rax); // Preserve value.
1832 __ movq(rdx, rax);
1833 __ pop(rax); // Restore value.
1842 __ push(rax); // Preserve value.
1845 __ movq(rcx, rax);
1847 __ pop(rax); // Restore value.
1855 context()->Plug(rax);
1877 __ movq(StackOperand(var), rax);
1886 __ push(rax);
1895 __ push(rax); // Value.
1910 __ movq(location, rax);
1912 __ movq(rdx, rax);
1930 __ movq(location, rax);
1932 __ movq(rdx, rax);
1938 __ push(rax); // Value.
1980 __ push(rax); // Result of assignment, saved even if not needed.
1983 __ pop(rax);
1987 context()->Plug(rax);
2021 __ push(rax); // Result of assignment, saved even if not needed.
2024 __ pop(rax);
2028 context()->Plug(rax);
2039 context()->Plug(rax);
2045 context()->Plug(rax);
2071 context()->Plug(rax);
2083 __ push(rax);
2104 context()->DropAndPlug(1, rax); // Drop the key still on the stack.
2126 context()->DropAndPlug(1, rax);
2184 // The runtime call returns a pair of values in rax (function) and
2187 __ movq(Operand(rsp, (arg_count + 1) * kPointerSize), rax);
2197 context()->DropAndPlug(1, rax);
2213 // Call the runtime to find the function to call (returned in rax) and
2218 __ push(rax); // Function.
2228 __ push(rax);
2291 // Load function and argument count into rdi and rax.
2292 __ Set(rax, arg_count);
2312 context()->Plug(rax);
2330 __ JumpIfSmi(rax, if_true);
2351 Condition non_negative_smi = masm()->CheckNonNegativeSmi(rax);
2371 __ JumpIfSmi(rax, if_false);
2372 __ CompareRoot(rax, Heap::kNullValueRootIndex);
2374 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2403 __ JumpIfSmi(rax, if_false);
2404 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
2425 __ JumpIfSmi(rax, if_false);
2426 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2450 if (FLAG_debug_code) __ AbortIfSmi(rax);
2454 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2460 __ movq(rcx, FieldOperand(rax, JSObject::kPropertiesOffset));
2495 __ movq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
2532 __ JumpIfSmi(rax, if_false);
2533 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
2554 __ JumpIfSmi(rax, if_false);
2555 __ CmpObjectType(rax, JS_ARRAY_TYPE, rbx);
2576 __ JumpIfSmi(rax, if_false);
2577 __ CmpObjectType(rax, JS_REGEXP_TYPE, rbx);
2597 __ movq(rax, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
2601 __ Cmp(Operand(rax, StandardFrameConstants::kContextOffset),
2604 __ movq(rax, Operand(rax, StandardFrameConstants::kCallerFPOffset));
2608 __ Cmp(Operand(rax, StandardFrameConstants::kMarkerOffset),
2633 __ cmpq(rax, rbx);
2646 // parameter count in rax.
2648 __ movq(rdx, rax);
2649 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
2652 context()->Plug(rax);
2661 __ Move(rax, Smi::FromInt(info_->scope()->num_parameters()));
2671 __ movq(rax, Operand(rbx, ArgumentsAdaptorFrameConstants::kLengthOffset));
2674 if (FLAG_debug_code) __ AbortIfNotSmi(rax);
2675 context()->Plug(rax);
2687 __ JumpIfSmi(rax, &null);
2694 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rax);
2695 // Map is now in rax.
2701 __ CmpInstanceType(rax, LAST_SPEC_OBJECT_TYPE);
2709 __ movq(rax, FieldOperand(rax, Map::kConstructorOffset));
2710 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rbx);
2713 // rax now contains the constructor function. Grab the
2715 __ movq(rax, FieldOperand(rax, JSFunction::kSharedFunctionInfoOffset));
2716 __ movq(rax, FieldOperand(rax, SharedFunctionInfo::kInstanceClassNameOffset));
2721 __ Move(rax, isolate()->factory()->function_class_symbol());
2726 __ Move(rax, isolate()->factory()->Object_symbol());
2731 __ LoadRoot(rax, Heap::kNullValueRootIndex);
2736 context()->Plug(rax);
2756 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
2757 context()->Plug(rax);
2773 __ movq(rbx, rax);
2777 // Return a random uint32 number in rax.
2790 // Convert 32 random bits in rax to 0.(32 random bits) in a double
2795 __ movd(xmm0, rax);
2801 __ movq(rax, rbx);
2802 context()->Plug(rax);
2815 context()->Plug(rax);
2829 context()->Plug(rax);
2841 __ JumpIfSmi(rax, &done);
2843 __ CmpObjectType(rax, JS_VALUE_TYPE, rbx);
2845 __ movq(rax, FieldOperand(rax, JSValue::kValueOffset));
2848 context()->Plug(rax);
2861 Register object = rax;
2862 Register result = rax;
2896 context()->Plug(rax);
2908 context()->Plug(rax);
2918 __ pop(rbx); // rax = value. rbx = object.
2929 __ movq(FieldOperand(rbx, JSValue::kValueOffset), rax);
2932 __ movq(rdx, rax);
2936 context()->Plug(rax);
2949 context()->Plug(rax);
2960 StringCharFromCodeGenerator generator(rax, rbx);
2980 Register index = rax;
3026 Register index = rax;
3028 Register result = rax;
3075 context()->Plug(rax);
3088 context()->Plug(rax);
3100 context()->Plug(rax);
3112 context()->Plug(rax);
3124 context()->Plug(rax);
3136 context()->Plug(rax);
3146 context()->Plug(rax);
3162 __ CmpObjectType(rax, JS_FUNCTION_PROXY_TYPE, rbx);
3174 __ push(rax);
3178 context()->Plug(rax);
3190 context()->Plug(rax);
3205 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
3206 context()->Plug(rax);
3212 Register key = rax;
3234 __ movq(rax, FieldOperand(cache,
3247 context()->Plug(rax);
3255 Register right = rax;
3280 __ Move(rax, isolate()->factory()->false_value());
3283 __ Move(rax, isolate()->factory()->true_value());
3286 context()->Plug(rax);
3303 __ testl(FieldOperand(rax, String::kHashFieldOffset),
3319 __ AbortIfNotString(rax);
3322 __ movl(rax, FieldOperand(rax, String::kHashFieldOffset));
3324 __ IndexFromHash(rax, rax);
3326 context()->Plug(rax);
3338 // Load this to rax (= array)
3341 Register array = rax;
3342 Register elements = no_reg; // Will be rax.
3376 __ LoadRoot(rax, Heap::kEmptyStringRootIndex);
3430 __ movq(rax, FieldOperand(elements, FixedArray::kHeaderSize));
3514 __ LoadRoot(rax, Heap::kUndefinedValueRootIndex);
3605 __ movq(rax, result_operand);
3611 context()->Plug(rax);
3628 __ movq(rax, GlobalObjectOperand());
3629 __ push(FieldOperand(rax, GlobalObject::kBuiltinsOffset));
3650 context()->Plug(rax);
3668 context()->Plug(rax);
3679 context()->Plug(rax);
3691 context()->Plug(rax);
3737 __ LoadRoot(rax, Heap::kTrueValueRootIndex);
3745 __ LoadRoot(rax, Heap::kFalseValueRootIndex);
3760 context()->Plug(rax);
3799 // accumulator register rax.
3803 context()->Plug(rax);
3842 __ push(rax); // Copy of receiver, needed for later store.
3848 __ push(rax); // Copy of key, needed for later store.
3863 __ JumpIfSmi(rax, &no_conversion, Label::kNear);
3876 __ push(rax);
3879 __ movq(Operand(rsp, kPointerSize), rax);
3882 __ movq(Operand(rsp, 2 * kPointerSize), rax);
3894 __ SmiAddConstant(rax, rax, Smi::FromInt(1));
3896 __ SmiSubConstant(rax, rax, Smi::FromInt(1));
3901 patch_site.EmitJumpIfSmi(rax, &done, Label::kNear);
3906 __ SmiSubConstant(rax, rax, Smi::FromInt(1));
3908 __ SmiAddConstant(rax, rax, Smi::FromInt(1));
3920 __ movq(rdx, rax);
3921 __ Move(rax, Smi::FromInt(1));
3927 // Store the value returned in rax.
3936 context.Plug(rax);
3948 context()->Plug(rax);
3964 context()->Plug(rax);
3981 context()->Plug(rax);
3997 __ movq(rax, GlobalObjectOperand());
4003 context()->Plug(rax);
4018 context()->Plug(rax);
4042 __ JumpIfSmi(rax, if_true);
4043 __ movq(rax, FieldOperand(rax, HeapObject::kMapOffset));
4044 __ CompareRoot(rax, Heap::kHeapNumberMapRootIndex);
4047 __ JumpIfSmi(rax, if_false);
4049 __ CmpObjectType(rax, FIRST_NONSTRING_TYPE, rdx);
4055 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4057 __ CompareRoot(rax, Heap::kFalseValueRootIndex);
4061 __ CompareRoot(rax, Heap::kNullValueRootIndex);
4064 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
4066 __ JumpIfSmi(rax, if_false);
4068 __ movq(rdx, FieldOperand(rax, HeapObject::kMapOffset));
4073 __ JumpIfSmi(rax, if_false);
4075 __ CmpObjectType(rax, JS_FUNCTION_TYPE, rdx);
4080 __ JumpIfSmi(rax, if_false);
4082 __ CompareRoot(rax, Heap::kNullValueRootIndex);
4085 __ CmpObjectType(rax, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, rdx);
4124 __ CompareRoot(rax, Heap::kTrueValueRootIndex);
4133 __ testq(rax, rax);
4171 __ or_(rcx, rax);
4173 __ cmpq(rdx, rax);
4185 __ testq(rax, rax);
4211 __ CompareRoot(rax, nil_value);
4219 __ CompareRoot(rax, other_nil_value);
4221 __ JumpIfSmi(rax, if_false);
4223 __ movq(rdx, FieldOperand(rax, HeapObject::kMapOffset));
4233 __ movq(rax, Operand(rbp, JavaScriptFrameConstants::kFunctionOffset));
4234 context()->Plug(rax);
4239 return rax;
