Lines Matching defs:rax
44 __ SmiTest(rax);
49 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
56 __ push(rax);
66 __ AllocateInNewSpace(JSFunction::kSize, rax, rbx, rcx, &gc, TAG_OBJECT);
80 __ movq(FieldOperand(rax, JSObject::kMapOffset), rcx);
87 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), rbx);
88 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rbx);
89 __ movq(FieldOperand(rax, JSFunction::kPrototypeOrInitialMapOffset), rcx);
90 __ movq(FieldOperand(rax, JSFunction::kSharedFunctionInfoOffset), rdx);
91 __ movq(FieldOperand(rax, JSFunction::kContextOffset), rsi);
92 __ movq(FieldOperand(rax, JSFunction::kLiteralsOffset), rbx);
93 __ movq(FieldOperand(rax, JSFunction::kNextFunctionLinkOffset), rdi);
99 __ movq(FieldOperand(rax, JSFunction::kCodeEntryOffset), rdx);
122 rax, rbx, rcx, &gc, TAG_OBJECT);
129 __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);
130 __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));
134 __ movq(Operand(rax, Context::SlotOffset(Context::CLOSURE_INDEX)), rcx);
135 __ movq(Operand(rax, Context::SlotOffset(Context::PREVIOUS_INDEX)), rsi);
136 __ movq(Operand(rax, Context::SlotOffset(Context::EXTENSION_INDEX)), rbx);
140 __ movq(Operand(rax, Context::SlotOffset(Context::GLOBAL_INDEX)), rbx);
145 __ movq(Operand(rax, Context::SlotOffset(i)), rbx);
149 __ movq(rsi, rax);
168 rax, rbx, rcx, &gc, TAG_OBJECT);
178 __ movq(FieldOperand(rax, HeapObject::kMapOffset), kScratchRegister);
179 __ Move(FieldOperand(rax, FixedArray::kLengthOffset), Smi::FromInt(length));
198 __ movq(ContextOperand(rax, Context::CLOSURE_INDEX), rcx);
199 __ movq(ContextOperand(rax, Context::PREVIOUS_INDEX), rsi);
200 __ movq(ContextOperand(rax, Context::EXTENSION_INDEX), rbx);
204 __ movq(ContextOperand(rax, Context::GLOBAL_INDEX), rbx);
209 __ movq(ContextOperand(rax, i + Context::MIN_CONTEXT_SLOTS), rbx);
213 __ movq(rsi, rax);
243 __ AllocateInNewSpace(size, rax, rbx, rdx, fail, TAG_OBJECT);
249 __ movq(FieldOperand(rax, i), rbx);
257 __ lea(rdx, Operand(rax, JSArray::kSize));
258 __ movq(FieldOperand(rax, JSArray::kElementsOffset), rdx);
293 __ movq(rax, Operand(rsp, 2 * kPointerSize));
294 SmiIndex index = masm->SmiToIndex(rax, rax, kPointerSizeLog2);
369 __ movq(rax, Operand(rsp, 3 * kPointerSize));
370 SmiIndex index = masm->SmiToIndex(rax, rax, kPointerSizeLog2);
379 __ movq(rax, FieldOperand(rcx, HeapObject::kMapOffset));
380 __ movzxbq(rax, FieldOperand(rax, Map::kInstanceSizeOffset));
381 __ cmpq(rax, Immediate(size >> kPointerSizeLog2));
386 __ AllocateInNewSpace(size, rax, rbx, rdx, &slow_case, TAG_OBJECT);
389 __ movq(FieldOperand(rax, i), rbx);
406 const Register argument = rax;
523 const Register argument = rax;
559 // Load the operands from rdx and rax into xmm0 and xmm1, as doubles.
561 // Leaves rdx and rax unchanged. SmiOperands assumes both are smis.
568 // Takes the operands in rdx and rax and loads them as integers in rax
687 __ push(rax); // the operand
738 __ JumpIfNotSmi(rax, non_smi, non_smi_near);
739 __ SmiNeg(rax, rax, &done, Label::kNear);
749 __ JumpIfNotSmi(rax, non_smi, non_smi_near);
750 __ SmiNot(rax, rax);
796 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
804 __ xor_(FieldOperand(rax, HeapNumber::kValueOffset), kScratchRegister);
815 __ push(rax);
817 __ movq(rcx, rax);
818 __ pop(rax);
824 __ movq(rdx, FieldOperand(rax, HeapNumber::kValueOffset));
829 __ movq(rax, rcx);
838 __ CompareRoot(FieldOperand(rax, HeapObject::kMapOffset),
842 // Convert the heap number in rax to an untagged integer in rcx.
843 IntegerConvert(masm, rax, rax);
846 __ notl(rax);
847 __ Integer32ToSmi(rax, rax);
890 __ push(rax);
922 __ push(rax);
1001 // Arguments to BinaryOpStub are in rdx and rax.
1003 Register right = rax;
1029 ASSERT(right.is(rax));
1035 __ movq(rax, left);
1039 ASSERT(right.is(rax));
1044 // SmiDiv will not accept left in rdx or right in rax.
1047 __ movq(rbx, rax);
1049 __ SmiDiv(rax, left, right, &use_fp_on_smis);
1053 // SmiMod will not accept left in rdx or right in rax.
1056 __ movq(rbx, rax);
1058 __ SmiMod(rax, left, right, &use_fp_on_smis);
1062 ASSERT(right.is(rax));
1067 ASSERT(right.is(rax));
1072 ASSERT(right.is(rax));
1078 __ movq(rax, left);
1083 __ movq(rax, left);
1088 __ movq(rax, left);
1095 // 5. Emit return of result in rax. Some operations have registers pushed.
1104 // Restore left and right to rdx and rax.
1106 __ movq(rax, rbx);
1126 __ movq(rax, rcx);
1135 // with the operands in rdx and rax.
1165 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
1186 case Token::BIT_OR: __ orl(rax, rcx); break;
1187 case Token::BIT_AND: __ andl(rax, rcx); break;
1188 case Token::BIT_XOR: __ xorl(rax, rcx); break;
1189 case Token::SAR: __ sarl_cl(rax); break;
1190 case Token::SHL: __ shll_cl(rax); break;
1192 __ shrl_cl(rax);
1195 __ testl(rax, rax);
1203 __ Integer32ToSmi(rax, rax);
1212 __ movl(rbx, rax); // rbx holds result value (uint32 value as int64).
1217 rax,
1228 __ movq(FieldOperand(rax, HeapObject::kMapOffset),
1231 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm0);
1235 // We need tagged values in rdx and rax for the following code,
1236 // not int32 in rax and rcx.
1237 __ Integer32ToSmi(rax, rcx);
1259 Register right = rax;
1368 Register right = rax;
1409 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1412 __ xor_(rax, rax);
1414 __ LoadRoot(rax, Heap::kNanValueRootIndex);
1468 __ movq(rax, rdx);
1472 // If the argument in rax is already an object, we skip the
1474 __ JumpIfNotSmi(rax, &skip_allocation);
1477 // Allocate a heap number for the result. Keep rax and rdx intact
1480 // Now rax can be overwritten losing one of the arguments as we are
1482 __ movq(rax, rbx);
1493 __ push(rax);
1504 // rax: tagged double result.
1518 // Test that rax is a number.
1519 __ movq(rax, Operand(rsp, kPointerSize));
1520 __ JumpIfNotSmi(rax, &input_not_smi, Label::kNear);
1523 __ SmiToInteger32(rax, rax);
1525 __ cvtlsi2sd(xmm1, rax);
1536 __ cmpq(rbx, FieldOperand(rax, HeapObject::kMapOffset));
1540 __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));
1541 __ movq(rbx, FieldOperand(rax, HeapNumber::kValueOffset));
1562 __ movl(rax, rdx);
1566 __ sarl(rax, Immediate(24));
1568 __ xorl(rax, rdi);
1569 __ xorl(rcx, rax);
1578 __ movq(rax, cache_array);
1581 __ movq(rax, Operand(rax, cache_array_index));
1582 // rax points to the cache for the type type_.
1584 __ testq(rax, rax);
1602 // Find the address of the rcx'th entry in the cache, i.e., &rax[rcx*16].
1604 __ lea(rcx, Operand(rax, rcx, times_8, 0));
1612 __ movq(rax, Operand(rcx, 2 * kIntSize));
1617 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1625 __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);
1627 __ AllocateHeapNumber(rax, rdi, &skip_cache);
1628 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);
1629 __ fld_d(FieldOperand(rax, HeapNumber::kValueOffset));
1633 __ movq(Operand(rcx, 2 * kIntSize), rax);
1634 __ fstp_d(FieldOperand(rax, HeapNumber::kValueOffset));
1638 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1671 __ AllocateHeapNumber(rax, rdi, &skip_cache);
1672 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), xmm1);
1675 __ push(rax);
1678 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1701 // rax: Newly allocated HeapNumber, which must be preserved.
1740 __ movq(rdi, rax); // Save rax before using fnstsw_ax.
1750 __ testl(rax, Immediate(5)); // #IO and #ZD flags of FPU status word.
1763 __ testl(rax, Immediate(0x400)); // Check C2 bit of FPU status word.
1773 __ movq(rax, rdi); // Restore rax, pointer to the new HeapNumber.
1801 // Input: rdx, rax are the left and right objects of a bit op.
1802 // Output: rax, rcx are left and right integers for a bit op.
1812 __ JumpIfSmi(rax, &rax_is_smi);
1815 IntegerConvert(masm, rcx, rax); // Uses rdi, rcx and rbx.
1820 __ JumpIfNotSmi(rax, &rax_is_object);
1822 __ SmiToInteger32(rcx, rax);
1825 __ movl(rax, rdx);
1829 // Input: rdx, rax are the left and right objects of a bit op.
1830 // Output: rax, rcx are left and right integers for a bit op.
1831 // Jump to conversion_failure: rdx and rax are unchanged.
1857 // Here r8 has the untagged integer, rax has a Smi or a heap number.
1860 __ JumpIfNotSmi(rax, &arg2_is_object);
1861 __ SmiToInteger32(rcx, rax);
1866 __ CompareRoot(rax, Heap::kUndefinedValueRootIndex);
1872 __ cmpq(FieldOperand(rax, HeapObject::kMapOffset), heap_number_map);
1874 // Get the untagged integer version of the rax heap number in rcx.
1875 IntegerConvert(masm, rcx, rax);
1877 __ movl(rax, r8);
1884 __ SmiToInteger32(kScratchRegister, rax);
1894 // Load operand in rax into xmm1.
1895 __ JumpIfSmi(rax, &load_smi_rax);
1897 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1903 __ JumpIfNotSmi(rax, &load_nonsmi_rax);
1906 __ SmiToInteger32(kScratchRegister, rax);
1922 // Load operand in rax into xmm1, or branch to not_numbers.
1923 __ JumpIfSmi(rax, &load_smi_rax);
1926 __ cmpq(FieldOperand(rax, HeapObject::kMapOffset), rcx);
1928 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
1934 __ JumpIfNotSmi(rax, &load_nonsmi_rax);
1937 rax);
2005 const Register base = rax;
2166 __ testb(rax, Immediate(0x5F)); // Check for all but precision exception.
2228 __ AllocateHeapNumber(rax, rcx, &call_runtime);
2229 __ movsd(FieldOperand(rax, HeapNumber::kValueOffset), double_result);
2256 // The key is in rdx and the parameter count is in rax.
2278 // through register rax. Use unsigned comparison to get negative
2280 __ cmpq(rdx, rax);
2284 SmiIndex index = masm->SmiToIndex(rax, rax, kPointerSizeLog2);
2287 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2299 index = masm->SmiToIndex(rax, rcx, kPointerSizeLog2);
2302 __ movq(rax, Operand(rbx, index.reg, index.scale, kDisplacement));
2323 // rax: the allocated object (tagged).
2378 __ AllocateInNewSpace(r8, rax, rdx, rdi, &runtime, TAG_OBJECT);
2380 // rax = address of new object(s) (tagged)
2398 // rax = address of new object (tagged)
2405 __ movq(FieldOperand(rax, i), rdx);
2411 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2419 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2426 __ lea(rdi, Operand(rax, Heap::kArgumentsObjectSize));
2427 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rdi);
2429 // rax = address of new object (tagged)
2596 __ AllocateInNewSpace(rcx, rax, rdx, rbx, &runtime, TAG_OBJECT);
2608 __ movq(FieldOperand(rax, i), rbx);
2614 __ movq(FieldOperand(rax, JSObject::kHeaderSize +
2628 __ lea(rdi, Operand(rax, Heap::kArgumentsObjectSizeStrict));
2629 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rdi);
2690 __ movq(rax, Operand(rsp, kJSRegExpOffset));
2691 __ JumpIfSmi(rax, &runtime);
2692 __ CmpObjectType(rax, JS_REGEXP_TYPE, kScratchRegister);
2695 __ movq(rax, FieldOperand(rax, JSRegExp::kDataOffset));
2697 Condition is_smi = masm->CheckSmi(rax);
2700 __ CmpObjectType(rax, FIXED_ARRAY_TYPE, kScratchRegister);
2704 // rax: RegExp data (FixedArray)
2706 __ SmiToInteger32(rbx, FieldOperand(rax, JSRegExp::kDataTagOffset));
2710 // rax: RegExp data (FixedArray)
2713 FieldOperand(rax, JSRegExp::kIrregexpCaptureCountOffset));
2720 // rax: RegExp data (FixedArray)
2729 // rax: RegExp data (FixedArray).
2738 // rax: RegExp data (FixedArray)
2761 // rax: RegExp data (FixedArray)
2834 // rax: RegExp data (FixedArray)
2835 __ movq(r11, FieldOperand(rax, JSRegExp::kDataAsciiCodeOffset));
2841 // rax: RegExp data (FixedArray)
2842 __ movq(r11, FieldOperand(rax, JSRegExp::kDataUC16CodeOffset));
2963 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::SUCCESS));
2965 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::EXCEPTION));
2967 __ cmpl(rax, Immediate(NativeRegExpMacroAssembler::FAILURE));
2973 __ LoadRoot(rax, Heap::kNullValueRootIndex);
2978 __ movq(rax, Operand(rsp, kJSRegExpOffset));
2979 __ movq(rcx, FieldOperand(rax, JSRegExp::kDataOffset));
2980 __ SmiToInteger32(rax,
2983 __ leal(rdx, Operand(rax, rax, times_1, 2));
2987 __ movq(rax, Operand(rsp, kLastMatchInfoOffset));
2988 __ movq(rbx, FieldOperand(rax, JSArray::kElementsOffset));
2997 __ movq(rax, Operand(rsp, kSubjectOffset));
2998 __ movq(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
3001 rax,
3004 __ movq(rax, Operand(rsp, kSubjectOffset));
3005 __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
3008 rax,
3038 __ movq(rax, Operand(rsp, kLastMatchInfoOffset));
3050 __ movq(rax, pending_exception_operand);
3052 __ cmpq(rax, rdx);
3056 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
3059 __ Throw(rax);
3062 __ ThrowUncatchable(rax);
3110 rax, // Out: Start of allocation (tagged).
3115 // rax: Start of allocated area, object-tagged.
3123 __ movq(FieldOperand(rax, HeapObject::kMapOffset), rdx);
3127 __ movq(FieldOperand(rax, JSObject::kPropertiesOffset), kScratchRegister);
3130 __ lea(rcx, Operand(rax, JSRegExpResult::kSize));
3131 __ movq(FieldOperand(rax, JSObject::kElementsOffset), rcx);
3135 __ movq(FieldOperand(rax, JSRegExpResult::kInputOffset), r8);
3137 __ movq(FieldOperand(rax, JSRegExpResult::kIndexOffset), r8);
3139 __ movq(FieldOperand(rax, JSArray::kLengthOffset), r8);
3142 // rax: JSArray.
3156 // rax: JSArray.
3276 GenerateLookupNumberStringCache(masm, rbx, rax, r8, r9, false, &runtime);
3302 __ JumpIfNotBothSmi(rax, rdx, &non_smi);
3303 __ subq(rdx, rax);
3307 __ movq(rax, rdx);
3313 __ JumpIfNotSmi(rax, &ok);
3319 // value in rax, corresponding to result of comparing the two inputs.
3326 __ cmpq(rax, rdx);
3335 __ Set(rax, NegativeComparisonResult(cc_));
3343 // We cannot set rax to EQUAL until just before return because
3344 // rax must be unchanged on jump to not_identical.
3346 __ Set(rax, EQUAL);
3356 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
3359 __ Set(rax, EQUAL);
3367 __ Set(rax, EQUAL);
3370 __ setcc(parity_even, rax);
3371 // rax is 0 for equal non-NaN heapnumbers, 1 for NaNs.
3373 __ neg(rax);
3393 __ SelectNonSmi(rbx, rax, rdx, ¬_smis);
3401 __ movq(rax, rbx);
3414 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rcx);
3416 // Return non-zero (eax (not rax) is not zero)
3444 __ xorl(rax, rax);
3451 __ setcc(above, rax);
3453 __ subq(rax, rcx);
3461 __ Set(rax, 1);
3463 __ Set(rax, -1);
3474 BranchIfNonSymbol(masm, &check_for_strings, rax, kScratchRegister);
3478 // are symbols they aren't equal. Register eax (not rax) already holds a
3486 rdx, rax, rcx, rbx, &check_unequal_objects);
3492 rax,
3498 rax,
3520 __ lea(rcx, Operand(rax, rdx, times_1, 0));
3523 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rbx);
3535 __ Set(rax, EQUAL);
3537 // Return non-equal by returning the non-zero object pointer in rax,
3546 __ push(rax);
3642 __ movq(rax, Operand(rsp, (argc_ + 1) * kPointerSize));
3644 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
3664 __ CompareRoot(rax, Heap::kTheHoleValueRootIndex);
3687 __ Set(rax, argc_ + 1);
3701 __ Set(rax, argc_);
3712 // rax : number of arguments
3734 // rax: number of arguments
3746 // Set expected number of arguments to zero (not changing rax).
3794 // rax: result parameter for PerformGC, if any.
3803 // Simple results returned in rax (both AMD64 and Win64 calling conventions).
3805 // AMD64 calling convention: a struct of two pointers in rax+rdx
3818 __ movq(rcx, rax);
3820 __ movq(rdi, rax);
3843 // Return result in single register (rax).
3862 // Result is in rax - do not destroy this register!
3879 __ movq(rax, Operand(rsp, 6 * kPointerSize));
3883 __ lea(rcx, Operand(rax, 1));
3884 // Lower 2 bits of rcx are 0 iff rax has failure tag.
3898 __ testl(rax, Immediate(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
3903 __ cmpq(rax, kScratchRegister);
3911 __ movq(rax, pending_exception_operand);
3917 __ CompareRoot(rax, Heap::kTerminationExceptionRootIndex);
3929 // rax: number of arguments including receiver
3948 // rax: Holds the context at this point, but should not be used.
3953 // of rax is then passed to Runtime::PerformGC.
3982 __ movq(rax, failure, RelocInfo::NONE);
3995 __ Set(rax, static_cast<int64_t>(false));
3996 __ Store(external_caught, rax);
3998 // Set pending exception and rax to out of memory exception.
4001 __ movq(rax, Failure::OutOfMemoryException(), RelocInfo::NONE);
4002 __ Store(pending_exception, rax);
4006 __ ThrowUncatchable(rax);
4009 __ Throw(rax);
4062 __ Load(rax, js_entry_sp);
4063 __ testq(rax, rax);
4066 __ movq(rax, rbp);
4067 __ Store(js_entry_sp, rax);
4083 __ Store(pending_exception, rax);
4084 __ movq(rax, Failure::Exception(), RelocInfo::NONE);
4093 __ LoadRoot(rax, Heap::kTheHoleValueRootIndex);
4094 __ Store(pending_exception, rax);
4107 __ Load(rax, construct_entry);
4110 __ Load(rax, entry);
4112 __ lea(kScratchRegister, FieldOperand(rax, Code::kHeaderSize));
4169 // movq(rdi, FieldOperand(rax, HeapObject::kMapOffset))
4185 __ movq(rax, Operand(rsp, 2 * kPointerSize + extra_stack_space));
4186 __ JumpIfSmi(rax, &slow);
4188 // Check that the left hand is a JS object. Leave its map in rax.
4189 __ CmpObjectType(rax, FIRST_SPEC_OBJECT_TYPE, rax);
4191 __ CmpInstanceType(rax, LAST_SPEC_OBJECT_TYPE);
4196 // rdx is function, rax is map.
4205 __ CompareRoot(rax, Heap::kInstanceofCacheMapRootIndex);
4207 __ LoadRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
4222 // rax is object map.
4227 __ StoreRoot(rax, Heap::kInstanceofCacheMapRootIndex);
4239 __ movq(Operand(kScratchRegister, 0), rax);
4242 __ movq(rcx, FieldOperand(rax, Map::kPrototypeOffset));
4260 __ xorl(rax, rax);
4263 __ StoreRoot(rax, Heap::kInstanceofCacheAnswerRootIndex);
4270 __ movl(rax, Immediate(true_offset));
4273 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
4275 __ movl(rax, Immediate(kWordBeforeResultValue));
4276 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
4279 __ Set(rax, 0);
4293 __ movl(rax, Immediate(false_offset));
4296 __ movb(Operand(kScratchRegister, kOffsetToResultValue), rax);
4298 __ movl(rax, Immediate(kWordBeforeResultValue));
4299 __ cmpl(Operand(kScratchRegister, kOffsetToResultValue - 4), rax);
4310 __ pop(rax);
4422 if (!index_.is(rax)) {
4425 __ movq(index_, rax);
4446 if (!result_.is(rax)) {
4447 __ movq(result_, rax);
4484 if (!result_.is(rax)) {
4485 __ movq(result_, rax);
4516 __ movq(rax, Operand(rsp, 2 * kPointerSize)); // First argument (left).
4521 __ JumpIfSmi(rax, &call_runtime);
4522 __ CmpObjectType(rax, FIRST_NONSTRING_TYPE, r8);
4534 GenerateConvertArgument(masm, 2 * kPointerSize, rax, rbx, rcx, rdi,
4546 // rax: first string
4553 // Second string is empty, result is first string which is already in rax.
4558 __ movq(rbx, FieldOperand(rax, String::kLengthOffset));
4562 __ movq(rax, rdx);
4567 // rax: first string
4579 __ movq(r8, FieldOperand(rax, HeapObject::kMapOffset));
4599 __ movzxbq(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4612 __ AllocateAsciiString(rax, rdi, r8, r9, r11, &call_runtime);
4620 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
4635 // rax: first string
4655 __ movq(FieldOperand(rcx, ConsString::kFirstOffset), rax);
4657 __ movq(rax, rcx);
4681 // rax: first string
4690 __ SmiToInteger32(r14, FieldOperand(rax, SeqString::kLengthOffset));
4699 __ movq(rcx, FieldOperand(rax, ExternalString::kResourceDataOffset));
4703 __ lea(rcx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4737 __ AllocateAsciiString(rax, rbx, rdi, r8, r9, &call_runtime);
4738 // rax: result string
4740 __ lea(rbx, FieldOperand(rax, SeqAsciiString::kHeaderSize));
4754 __ AllocateTwoByteString(rax, rbx, rdi, r8, r9, &call_runtime);
4755 // rax: result string
4757 __ lea(rbx, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
5026 if (!result.is(rax)) {
5027 __ movq(rax, result);
5105 __ movq(rax, Operand(rsp, kStringOffset));
5107 __ testl(rax, Immediate(kSmiTagMask));
5109 Condition is_string = masm->IsObjectStringType(rax, rbx, rbx);
5112 // rax: string
5121 __ cmpq(FieldOperand(rax, String::kLengthOffset), rcx);
5137 // rax: string
5145 __ movzxbq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5147 FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize + 1));
5158 __ movzxwq(rbx, FieldOperand(rax, rdx, times_1, SeqAsciiString::kHeaderSize));
5159 __ AllocateAsciiString(rax, rcx, r11, r14, r15, &runtime);
5160 __ movw(FieldOperand(rax, SeqAsciiString::kHeaderSize), rbx);
5165 // rax: string
5182 __ CompareRoot(FieldOperand(rax, ConsString::kSecondOffset),
5185 __ movq(rdi, FieldOperand(rax, ConsString::kFirstOffset));
5193 __ addq(rdx, FieldOperand(rax, SlicedString::kOffsetOffset));
5194 __ movq(rdi, FieldOperand(rax, SlicedString::kParentOffset));
5202 __ movq(rdi, rax);
5227 __ AllocateAsciiSlicedString(rax, rbx, r14, &runtime);
5230 __ AllocateTwoByteSlicedString(rax, rbx, r14, &runtime);
5233 __ movq(FieldOperand(rax, SlicedString::kLengthOffset), rcx);
5234 __ movq(FieldOperand(rax, SlicedString::kHashFieldOffset),
5236 __ movq(FieldOperand(rax, SlicedString::kParentOffset), rdi);
5237 __ movq(FieldOperand(rax, SlicedString::kOffsetOffset), rdx);
5272 __ AllocateAsciiString(rax, rcx, r11, r14, r15, &runtime);
5274 // rax: result string
5283 __ lea(rdi, FieldOperand(rax, SeqAsciiString::kHeaderSize));
5285 // rax: result string
5297 __ AllocateTwoByteString(rax, rcx, r11, r14, r15, &runtime);
5299 // rax: result string
5308 __ lea(rdi, FieldOperand(rax, SeqTwoByteString::kHeaderSize));
5310 // rax: result string
5338 __ Move(rax, Smi::FromInt(NOT_EQUAL));
5347 __ Move(rax, Smi::FromInt(EQUAL));
5357 __ Move(rax, Smi::FromInt(EQUAL));
5362 __ Move(rax, Smi::FromInt(NOT_EQUAL));
5413 __ Move(rax, Smi::FromInt(EQUAL));
5422 __ Move(rax, Smi::FromInt(LESS));
5427 __ Move(rax, Smi::FromInt(GREATER));
5471 __ movq(rax, Operand(rsp, 1 * kPointerSize)); // right
5475 __ cmpq(rdx, rax);
5477 __ Move(rax, Smi::FromInt(EQUAL));
5485 __ JumpIfNotBothSequentialAsciiStrings(rdx, rax, rcx, rbx, &runtime);
5493 GenerateCompareFlatAsciiStrings(masm, rdx, rax, rcx, rbx, rdi, r8);
5505 __ JumpIfNotBothSmi(rdx, rax, &miss, Label::kNear);
5509 __ subq(rax, rdx);
5512 __ subq(rdx, rax);
5517 __ movq(rax, rdx);
5532 Condition either_smi = masm->CheckEitherSmi(rax, rdx);
5535 __ CmpObjectType(rax, HEAP_NUMBER_TYPE, rcx);
5542 __ movsd(xmm1, FieldOperand(rax, HeapNumber::kValueOffset));
5552 __ movl(rax, Immediate(0));
5554 __ setcc(above, rax); // Add one to zero if carry clear and not equal.
5555 __ sbbq(rax, rcx); // Subtract one if below (aka. carry set).
5565 __ Cmp(rax, masm->isolate()->factory()->undefined_value());
5589 Register right = rax;
5611 // Make sure rax is non-zero. At this point input operands are
5613 ASSERT(right.is(rax));
5617 __ Move(rax, Smi::FromInt(EQUAL));
5634 Register right = rax;
5661 __ Move(rax, Smi::FromInt(EQUAL));
5675 // Make sure rax is non-zero. At this point input operands are
5677 ASSERT(right.is(rax));
5715 Condition either_smi = masm->CheckEitherSmi(rdx, rax);
5718 __ CmpObjectType(rax, JS_OBJECT_TYPE, rcx);
5724 __ subq(rax, rdx);
5734 Condition either_smi = masm->CheckEitherSmi(rdx, rax);
5737 __ movq(rcx, FieldOperand(rax, HeapObject::kMapOffset));
5744 __ subq(rax, rdx);
5760 __ push(rax);
5762 __ push(rax);
5767 __ lea(rdi, FieldOperand(rax, Code::kHeaderSize));
5768 __ pop(rax);
5998 { REG(rbx), REG(rax), REG(rdi), EMIT_REMEMBERED_SET },
6025 { REG(r11), REG(rax), REG(r15), EMIT_REMEMBERED_SET},
6027 { REG(rbx), REG(rax), REG(rcx), EMIT_REMEMBERED_SET},
6279 // -- rax : element value to store
6296 __ JumpIfSmi(rax, &smi_element);
6307 __ push(rax);
6321 __ movq(Operand(rcx, 0), rax);
6323 __ RecordWrite(rbx, rcx, rax,
6335 FixedArrayBase::kHeaderSize), rax);
6343 __ StoreNumberToDoubleElements(rax,
