Lines Matching full:eax
44 // The ToNumber stub takes one argument in eax.
46 __ test(eax, Immediate(kSmiTagMask));
51 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
59 __ push(eax);
69 __ AllocateInNewSpace(JSFunction::kSize, eax, ebx, ecx, &gc, TAG_OBJECT);
83 __ mov(FieldOperand(eax, JSObject::kMapOffset), ecx);
89 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ebx);
90 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx);
91 __ mov(FieldOperand(eax, JSFunction::kPrototypeOrInitialMapOffset),
93 __ mov(FieldOperand(eax, JSFunction::kSharedFunctionInfoOffset), edx);
94 __ mov(FieldOperand(eax, JSFunction::kContextOffset), esi);
95 __ mov(FieldOperand(eax, JSFunction::kLiteralsOffset), ebx);
96 __ mov(FieldOperand(eax, JSFunction::kNextFunctionLinkOffset),
103 __ mov(FieldOperand(eax, JSFunction::kCodeEntryOffset), edx);
125 eax, ebx, ecx, &gc, TAG_OBJECT);
132 __ mov(FieldOperand(eax, HeapObject::kMapOffset), factory->context_map());
133 __ mov(FieldOperand(eax, Context::kLengthOffset),
138 __ mov(Operand(eax, Context::SlotOffset(Context::CLOSURE_INDEX)), ecx);
139 __ mov(Operand(eax, Context::SlotOffset(Context::FCONTEXT_INDEX)), eax);
140 __ mov(Operand(eax, Context::SlotOffset(Context::PREVIOUS_INDEX)), ebx);
141 __ mov(Operand(eax, Context::SlotOffset(Context::EXTENSION_INDEX)), ebx);
148 __ mov(Operand(eax, Context::SlotOffset(Context::GLOBAL_INDEX)), ebx);
153 __ mov(Operand(eax, Context::SlotOffset(i)), ebx);
157 __ mov(esi, Operand(eax));
181 __ mov(eax, Operand(esp, 2 * kPointerSize));
185 __ mov(ecx, FieldOperand(ecx, eax, times_half_pointer_size,
211 __ AllocateInNewSpace(size, eax, ebx, edx, &slow_case, TAG_OBJECT);
217 __ mov(FieldOperand(eax, i), ebx);
225 __ lea(edx, Operand(eax, JSArray::kSize));
226 __ mov(FieldOperand(eax, JSArray::kElementsOffset), edx);
246 __ mov(eax, Operand(esp, 1 * kPointerSize));
250 __ cmp(eax, factory->null_value());
254 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
270 __ cmp(FieldOperand(eax, String::kLengthOffset), Immediate(0));
279 __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset));
284 // Return 1/0 for true/false in eax.
286 __ mov(eax, 1);
289 __ mov(eax, 0);
310 // operand_1 on TOS+1 or in edx, operand_2 on TOS+2 or in eax.
317 // Expects operands in edx, eax.
321 // operand_1 in eax, operand_2 in edx; falls through on float
332 // Takes the operands in edx and eax and loads them as integers in eax
348 // are in eax and ecx. Checks that the original numbers were in the int32
355 // into xmm0 and xmm1. Operands are in edx and eax.
361 // either operand is not a number. Operands are in edx and eax.
366 // Expects operands in edx, eax.
388 __ push(eax);
488 // 1. Move arguments into edx, eax except for DIV and MOD, which need the
489 // dividend in eax and edx free for the division. Use eax, ebx for those.
492 Register right = eax;
494 left = eax;
496 __ mov(ebx, eax);
497 __ mov(eax, edx);
508 // Perform the operation into eax and smi check the result. Preserve
509 // eax in case the result is not a smi.
530 // Move the right operand into ecx for the shift operation, use eax
548 // eax and check the result if necessary.
557 ASSERT(right.is(eax));
562 ASSERT(right.is(eax));
575 // Tag the result and store it in register eax.
577 __ mov(eax, left);
586 // Tag the result and store it in register eax.
588 __ mov(eax, left);
605 // Tag the result and store it in register eax.
607 __ mov(eax, left);
611 ASSERT(right.is(eax));
619 __ mov(eax, left);
644 // Sign extend left into edx:eax.
645 ASSERT(left.is(eax));
647 // Divide edx:eax by right.
653 __ cmp(eax, 0x40000000);
656 __ NegativeZeroTest(eax, combined, &use_fp_on_smis);
660 // Tag the result and store it in register eax.
661 __ SmiTag(eax);
669 // Sign extend left into edx:eax.
670 ASSERT(left.is(eax));
672 // Divide edx:eax by right.
676 // Move remainder to register eax.
677 __ mov(eax, edx);
684 // 5. Emit return of result in eax. Some operations have registers pushed.
729 // division. They should be in eax, ebx for jump to not_smi.
730 __ mov(eax, edi);
744 // number in eax.
745 __ AllocateHeapNumber(eax, ecx, ebx, slow);
750 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
756 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
768 // Restore arguments to edx, eax.
786 __ mov(eax, right);
814 __ mov(eax, ecx);
825 // edx and eax.
833 // Right operand is saved in ecx and eax was destroyed by the smi
835 __ mov(eax, ecx);
840 // Operands are in eax, ebx at this point.
841 __ mov(edx, eax);
842 __ mov(eax, ebx);
944 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
962 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1000 case Token::BIT_OR: __ or_(eax, Operand(ecx)); break;
1001 case Token::BIT_AND: __ and_(eax, Operand(ecx)); break;
1002 case Token::BIT_XOR: __ xor_(eax, Operand(ecx)); break;
1003 case Token::SAR: __ sar_cl(eax); break;
1004 case Token::SHL: __ shl_cl(eax); break;
1005 case Token::SHR: __ shr_cl(eax); break;
1010 __ test(eax, Immediate(0xc0000000));
1014 __ cmp(eax, 0xc0000000);
1018 __ SmiTag(eax);
1026 __ mov(ebx, Operand(eax)); // ebx: result
1033 __ mov(eax, Operand(esp, mode_ == OVERWRITE_RIGHT ?
1035 __ test(eax, Immediate(kSmiTagMask));
1039 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1048 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
1052 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1134 __ cmp(eax, FACTORY->undefined_value());
1137 __ xor_(eax, Operand(eax));
1139 __ mov(eax, Immediate(FACTORY->nan_value()));
1169 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
1186 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1215 case Token::BIT_OR: __ or_(eax, Operand(ecx)); break;
1216 case Token::BIT_AND: __ and_(eax, Operand(ecx)); break;
1217 case Token::BIT_XOR: __ xor_(eax, Operand(ecx)); break;
1218 case Token::SAR: __ sar_cl(eax); break;
1219 case Token::SHL: __ shl_cl(eax); break;
1220 case Token::SHR: __ shr_cl(eax); break;
1225 __ test(eax, Immediate(0xc0000000));
1229 __ cmp(eax, 0xc0000000);
1233 __ SmiTag(eax);
1241 __ mov(ebx, Operand(eax)); // ebx: result
1248 __ mov(eax, Operand(esp, mode_ == OVERWRITE_RIGHT ?
1250 __ test(eax, Immediate(kSmiTagMask));
1254 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1263 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
1267 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1374 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
1391 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1415 case Token::BIT_OR: __ or_(eax, Operand(ecx)); break;
1416 case Token::BIT_AND: __ and_(eax, Operand(ecx)); break;
1417 case Token::BIT_XOR: __ xor_(eax, Operand(ecx)); break;
1418 case Token::SAR: __ sar_cl(eax); break;
1419 case Token::SHL: __ shl_cl(eax); break;
1420 case Token::SHR: __ shr_cl(eax); break;
1425 __ test(eax, Immediate(0xc0000000));
1429 __ cmp(eax, 0xc0000000);
1433 __ SmiTag(eax);
1441 __ mov(ebx, Operand(eax
1448 __ mov(eax, Operand(esp, mode_ == OVERWRITE_RIGHT ?
1450 __ test(eax, Immediate(kSmiTagMask));
1454 __ AllocateHeapNumber(eax, ecx, edx, &call_runtime);
1463 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
1467 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1531 Register right = eax;
1570 // Allocate a heap number for the result. Keep eax and edx intact
1578 __ mov(eax, Operand(edx));
1582 // If the argument in eax is already an object, we skip the
1584 __ test(eax, Immediate(kSmiTagMask));
1588 // Allocate a heap number for the result. Keep eax and edx intact
1591 // Now eax can be overwritten losing one of the arguments as we are
1593 __ mov(eax, ebx);
1604 __ push(eax);
1615 // eax: tagged double result.
1628 // Test that eax is a number.
1631 __ mov(eax, Operand(esp, kPointerSize));
1632 __ test(eax, Immediate(kSmiTagMask));
1637 __ sar(eax, 1);
1639 __ mov(Operand(esp, 0), eax);
1647 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1653 __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset));
1654 __ mov(edx, FieldOperand(eax, HeapNumber::kExponentOffset));
1655 __ mov(ebx, FieldOperand(eax, HeapNumber::kMantissaOffset));
1676 __ mov(eax, ecx);
1677 __ sar(eax, 16);
1678 __ xor_(ecx, Operand(eax));
1679 __ mov(eax, ecx);
1680 __ sar(eax, 8);
1681 __ xor_(ecx, Operand(eax));
1692 __ mov(eax, Immediate(cache_array));
1695 __ mov(eax, Operand(eax, cache_array_index));
1696 // Eax points to the cache for the type type_.
1698 __ test(eax, Operand(eax));
1714 // Find the address of the ecx'th entry in the cache, i.e., &eax[ecx*12].
1716 __ lea(ecx, Operand(eax, ecx, times_4, 0));
1724 __ mov(eax, Operand(ecx, 2 * kIntSize));
1729 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
1738 __ AllocateHeapNumber(eax, edi, no_reg, &runtime_call_clear_stack);
1740 __ AllocateHeapNumber(eax, edi, no_reg, &skip_cache);
1749 __ mov(Operand(ecx, 2 * kIntSize), eax);
1750 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
1754 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
1787 __ AllocateHeapNumber(eax, edi, no_reg, &skip_cache);
1788 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm1);
1790 __ push(eax);
1793 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
1815 // Address of result (a newly allocated HeapNumber) may be in eax.
1845 __ mov(edi, eax); // Save eax before using fnstsw_ax.
1855 __ test(Operand(eax), Immediate(5));
1868 __ test(Operand(eax), Immediate(0x400 /* C2 */));
1876 __ mov(eax, edi); // Restore eax (allocated HeapNumber pointer).
2045 // Input: edx, eax are the left and right objects of a bit op.
2046 // Output: eax, ecx are left and right integers for a bit op.
2073 // Here edx has the untagged integer, eax has a Smi or a heap number.
2078 __ test(eax, Immediate(kSmiTagMask));
2081 if (FLAG_debug_code) __ AbortIfNotSmi(eax);
2083 __ SmiUntag(eax);
2084 __ mov(ecx, eax);
2090 // Get the untagged integer version of the eax heap number in ecx.
2091 IntegerConvert(masm, eax, type_info, use_sse3, conversion_failure);
2093 __ mov(eax, edx);
2097 // Input: edx, eax are the left and right objects of a bit op.
2098 // Output: eax, ecx are left and right integers for a bit op.
2135 // Here edx has the untagged integer, eax has a Smi or a heap number.
2139 __ test(eax, Immediate(kSmiTagMask));
2142 __ SmiUntag(eax);
2143 __ mov(ecx, eax);
2148 __ cmp(eax, factory->undefined_value());
2154 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2158 // Get the untagged integer version of the eax heap number in ecx.
2160 eax,
2165 __ mov(eax, edx);
2215 // Load operand in eax into xmm1.
2216 __ test(eax, Immediate(kSmiTagMask));
2217 __ j(zero, &load_smi_eax, not_taken); // Argument in eax is a smi.
2218 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
2228 __ SmiUntag(eax); // Untag smi before converting to float.
2229 __ cvtsi2sd(xmm1, Operand(eax));
2230 __ SmiTag(eax); // Retag smi for heap number overwriting test.
2247 // Load operand in eax into xmm1, or branch to not_numbers.
2248 __ test(eax, Immediate(kSmiTagMask));
2249 __ j(zero, &load_smi_eax, not_taken); // Argument in eax is a smi.
2250 __ cmp(FieldOperand(eax, HeapObject::kMapOffset), factory->heap_number_map());
2252 __ jmp(not_numbers); // Argument in eax is not a number.
2259 __ SmiUntag(eax); // Untag smi before converting to float.
2260 __ cvtsi2sd(xmm1, Operand(eax));
2261 __ SmiTag(eax); // Retag smi for heap number overwriting test.
2264 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
2272 const Register right = eax;
2315 __ mov(scratch, eax);
2344 const Register right = eax;
2373 __ test(eax, Immediate(kSmiTagMask));
2374 __ j(zero, &done); // argument in eax is OK
2375 __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));
2377 __ j(not_equal, non_float); // argument in eax is not a number -> NaN
2397 __ test(eax, Immediate(kSmiTagMask));
2403 __ test(eax, Operand(eax));
2409 __ mov(edx, Operand(eax));
2410 __ Set(eax, Immediate(0));
2411 __ sub(eax, Operand(edx));
2418 __ AbortIfSmi(eax);
2421 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
2425 __ mov(edx, FieldOperand(eax, HeapNumber::kExponentOffset));
2427 __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), edx);
2429 __ mov(edx, Operand(eax));
2431 __ AllocateHeapNumber(eax, ebx, ecx, &undo);
2432 // eax: allocated 'empty' number
2435 __ mov(FieldOperand(eax, HeapNumber::kExponentOffset), ecx);
2437 __ mov(FieldOperand(eax, HeapNumber::kMantissaOffset), ecx);
2442 __ test(eax, Immediate(kSmiTagMask));
2444 __ not_(eax);
2445 __ and_(eax, ~kSmiTagMask); // Remove inverted smi-tag.
2449 __ AbortIfSmi(eax);
2453 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
2457 // Convert the heap number in eax to an untagged integer in ecx.
2459 eax,
2472 __ lea(eax, Operand(ecx, times_2, kSmiTag));
2478 // Allocate a fresh heap number, but don't overwrite eax until
2480 // that needs the value in eax.
2482 __ mov(eax, Operand(ebx));
2487 __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
2492 __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
2502 // Restore eax and go slow case.
2504 __ mov(eax, Operand(edx));
2509 __ push(eax);
2527 // eax = exponent
2535 __ mov(eax, Operand(esp, 1 * kPointerSize));
2544 __ test(eax, Immediate(kSmiTagMask));
2566 __ SmiUntag(eax);
2570 __ mov(edx, eax);
2574 __ cmp(eax, 0);
2576 __ neg(eax);
2585 __ shr(eax, 1);
2609 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
2612 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
2672 __ AllocateHeapNumber(ecx, eax, edx, &call_runtime);
2674 __ mov(eax, ecx);
2683 // The key is in edx and the parameter count is in eax.
2703 // through register eax. Use unsigned comparison to get negative
2705 __ cmp(edx, Operand(eax));
2711 __ lea(ebx, Operand(ebp, eax, times_2, 0));
2713 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
2729 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
2782 __ AllocateInNewSpace(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
2793 __ mov(FieldOperand(eax, i), ebx);
2800 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
2808 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
2822 __ lea(edi, Operand(eax, GetArgumentsObjectSize()));
2823 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
2888 __ mov(eax, Operand(esp, kJSRegExpOffset));
2890 __ test(eax, Immediate(kSmiTagMask));
2892 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
2895 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
2924 __ mov(eax, Operand(esp, kSubjectOffset));
2925 __ test(eax, Immediate(kSmiTagMask));
2927 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
2930 __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
2937 __ mov(eax, Operand(esp, kPreviousIndexOffset));
2938 __ test(eax, Immediate(kSmiTagMask));
2940 __ cmp(eax, Operand(ebx));
2946 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
2947 __ test(eax, Immediate(kSmiTagMask));
2949 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
2952 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
2953 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
2955 __ cmp(eax, factory->fixed_array_map());
2959 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
2960 __ SmiUntag(eax);
2962 __ cmp(edx, Operand(eax));
2968 __ mov(eax, Operand(esp, kSubjectOffset));
2969 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2992 __ mov(edx, FieldOperand(eax, ConsString::kSecondOffset));
2995 __ mov(eax, FieldOperand(eax, ConsString::kFirstOffset));
2996 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2998 // eax: first part of cons string.
3011 // eax: subject string (flat ascii)
3018 // eax: subject string (flat two byte)
3030 // eax: subject string
3038 // eax: subject string
3071 __ mov(edi, FieldOperand(eax, String::kLengthOffset));
3074 __ lea(ecx, FieldOperand(eax, edi, times_1, SeqAsciiString::kHeaderSize));
3076 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqAsciiString::kHeaderSize));
3083 __ lea(ecx, FieldOperand(eax, edi, times_1, SeqTwoByteString::kHeaderSize));
3085 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
3094 __ mov(Operand(esp, 0 * kPointerSize), eax);
3105 __ cmp(eax, NativeRegExpMacroAssembler::SUCCESS);
3108 __ cmp(eax, NativeRegExpMacroAssembler::FAILURE);
3110 __ cmp(eax, NativeRegExpMacroAssembler::EXCEPTION);
3122 __ mov(eax, Operand::StaticVariable(pending_exception));
3123 __ cmp(edx, Operand(eax));
3132 __ cmp(eax, factory->termination_exception());
3137 __ Throw(eax);
3140 __ ThrowUncatchable(TERMINATION, eax);
3144 __ mov(Operand(eax), factory->null_value());
3149 __ mov(eax, Operand(esp, kJSRegExpOffset));
3150 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
3159 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
3160 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
3169 __ mov(eax, Operand(esp, kSubjectOffset));
3170 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
3172 __ RecordWrite(ecx, RegExpImpl::kLastSubjectOffset, eax, edi);
3173 __ mov(eax, Operand(esp, kSubjectOffset));
3174 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
3176 __ RecordWrite(ecx, RegExpImpl::kLastInputOffset, eax, edi);
3205 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
3233 eax, // Out: Start of allocation (tagged).
3238 // eax: Start of allocated area, object-tagged.
3247 __ lea(ebx, Operand(eax, JSRegExpResult::kSize));
3249 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ebx);
3250 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ecx);
3252 __ mov(FieldOperand(eax, HeapObject::kMapOffset), edx);
3256 __ mov(FieldOperand(eax, JSRegExpResult::kInputOffset), ecx);
3258 __ mov(FieldOperand(eax, JSRegExpResult::kIndexOffset), ecx);
3260 __ mov(FieldOperand(eax, JSArray::kLengthOffset), ecx);
3263 // eax: JSArray.
3277 // eax: JSArray.
3401 GenerateLookupNumberStringCache(masm, ebx, eax, ecx, edx, false, &runtime);
3426 __ or_(ecx, Operand(eax));
3429 __ sub(edx, Operand(eax)); // Return on the result of the subtraction.
3433 __ mov(eax, edx);
3438 __ or_(ecx, Operand(eax));
3450 __ cmp(eax, Operand(edx));
3459 __ Set(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc_))));
3468 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
3477 __ CmpObjectType(eax, FIRST_JS_OBJECT_TYPE, ecx);
3480 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
3496 __ Set(eax, Immediate(0));
3503 __ setcc(above_equal, eax);
3508 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
3511 __ Set(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc_))));
3533 __ and_(ecx, Operand(eax));
3540 // ecx still holds eax & kSmiTag, which is either zero or one.
3543 __ xor_(ebx, Operand(eax));
3544 __ and_(ebx, Operand(ecx)); // ebx holds either 0 or eax ^ edx.
3545 __ xor_(ebx, Operand(eax));
3546 // if eax was smi, ebx is now edx, else eax.
3554 __ mov(eax, ebx);
3566 __ CmpObjectType(eax, FIRST_JS_OBJECT_TYPE, ecx);
3569 // Return non-zero (eax is not zero)
3605 __ mov(eax, 0); // equal
3607 __ cmov(above, eax, Operand(ecx));
3609 __ cmov(below, eax, Operand(ecx));
3614 FloatingPointHelper::LoadFloatOperand(masm, eax);
3626 __ Set(eax, Immediate(0));
3630 __ mov(eax, Immediate(Smi::FromInt(-1)));
3634 __ mov(eax, Immediate(Smi::FromInt(1)));
3643 __ mov(eax, Immediate(Smi::FromInt(1)));
3645 __ mov(eax, Immediate(Smi::FromInt(-1)));
3656 BranchIfNonSymbol(masm, &check_for_strings, eax, ecx);
3660 // are symbols they aren't equal. Register eax already holds a
3667 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx,
3673 eax,
3693 __ lea(ecx, Operand(eax, edx, times_1, 0));
3696 __ CmpObjectType(eax, FIRST_JS_OBJECT_TYPE, ecx);
3711 __ Set(eax, Immediate(EQUAL));
3713 // Return non-equal by returning the non-zero object pointer in eax,
3722 __ push(eax);
3770 __ mov(eax, Operand(esp, (argc_ + 1) * kPointerSize));
3773 __ test(eax, Immediate(kSmiTagMask));
3777 __ CmpObjectType(eax, FIRST_JS_OBJECT_TYPE, edi);
3783 __ push(eax);
3786 __ mov(Operand(esp, (argc_ + 1) * kPointerSize), eax);
3811 __ Set(eax, Immediate(argc_));
3826 __ Throw(eax);
3836 // eax: result parameter for PerformGC, if any
3843 // Result returned in eax, or eax+edx if result_size_ is 2.
3856 __ mov(Operand(esp, 0 * kPointerSize), eax); // Result.
3872 // Result is in eax or edx:eax - do not destroy these registers!
3882 __ cmp(eax, masm->isolate()->factory()->the_hole_value());
3891 __ lea(ecx, Operand(eax, 1));
3892 // Lower 2 bits of ecx are 0 iff eax has failure tag.
3924 __ test(eax, Immediate(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
3928 __ cmp(eax, reinterpret_cast<int32_t>(Failure::OutOfMemoryException()));
3934 __ mov(eax, Operand::StaticVariable(pending_exception_address));
3940 __ cmp(eax, masm->isolate()->factory()->termination_exception());
3953 __ ThrowUncatchable(type, eax);
3958 // eax: number of arguments including receiver
3972 // eax: result parameter for PerformGC, if any (setup below)
4001 __ mov(eax, Immediate(reinterpret_cast<int32_t>(failure)));
4065 __ mov(Operand::StaticVariable(pending_exception), eax);
4066 __ mov(eax, reinterpret_cast<int32_t>(Failure::Exception()));
4137 // b8 XX XX XX XX mov eax, <the hole, patched to either true or false>
4152 Register object = eax; // Object (lhs).
4198 __ mov(eax, Operand::StaticArray(
4252 __ Set(eax, Immediate(0));
4255 times_pointer_size, roots_address), eax);
4258 __ mov(eax, factory->true_value());
4265 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
4267 __ Set(eax, Immediate(0));
4274 __ Set(eax, Immediate(Smi::FromInt(1)));
4277 scratch, times_pointer_size, roots_address), eax);
4280 __ mov(eax, factory->false_value());
4287 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
4289 __ Set(eax, Immediate(Smi::FromInt(1)));
4306 __ Set(eax, Immediate(Smi::FromInt(1)));
4313 __ Set(eax, Immediate(Smi::FromInt(1)));
4320 __ Set(eax, Immediate(Smi::FromInt(1)));
4343 __ test(eax, Operand(eax));
4345 __ mov(eax, factory->false_value());
4348 __ mov(eax, factory->true_value());
4355 Register InstanceofStub::left() { return eax; }
4537 if (!scratch_.is(eax)) {
4540 __ mov(scratch_, eax);
4563 if (!result_.is(eax)) {
4564 __ mov(result_, eax);
4609 if (!result_.is(eax)) {
4610 __ mov(result_, eax);
4640 __ mov(eax, Operand(esp, 2 * kPointerSize)); // First argument.
4645 __ test(eax, Immediate(kSmiTagMask));
4647 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ebx);
4660 GenerateConvertArgument(masm, 2 * kPointerSize, eax, ebx, ecx, edi,
4672 // eax: first string
4680 // Second string is empty, result is first string which is already in eax.
4685 __ mov(ebx, FieldOperand(eax, String::kLengthOffset));
4690 __ mov(eax, edx);
4695 // eax: first string
4712 __ JumpIfNotBothSequentialAsciiStrings(eax, edx, ebx, ecx,
4716 __ movzx_b(ebx, FieldOperand(eax, SeqAsciiString::kHeaderSize));
4723 masm, ebx, ecx, eax, edx, edi,
4731 __ mov(eax, Operand(esp, 2 * kPointerSize)); // First argument.
4734 __ movzx_b(ebx, FieldOperand(eax, SeqAsciiString::kHeaderSize));
4738 __ AllocateAsciiString(eax, // Result.
4747 __ mov_w(FieldOperand(eax, SeqAsciiString::kHeaderSize), ebx);
4759 __ mov(edi, FieldOperand(eax, HeapObject::kMapOffset));
4776 __ mov(FieldOperand(ecx, ConsString::kFirstOffset), eax);
4778 __ mov(eax, ecx);
4788 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
4801 // eax: first string
4805 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
4816 // eax: first string
4821 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
4831 __ AllocateAsciiString(eax, ebx, ecx, edx, edi, &string_add_runtime);
4832 // eax: result string
4833 __ mov(ecx, eax);
4841 // eax: result string
4851 // eax: result string
4860 // eax: first string - known to be two byte
4870 __ AllocateTwoByteString(eax, ebx, ecx, edx, edi, &string_add_runtime);
4871 // eax: result string
4872 __ mov(ecx, eax);
4882 // eax: result string
4892 // eax: result string
5162 if (!result.is(eax)) {
5163 __ mov(eax, result);
5235 __ mov(eax, Operand(esp, 3 * kPointerSize));
5237 __ test(eax, Immediate(kSmiTagMask));
5239 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
5242 // eax: string
5254 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
5266 // eax: string
5274 __ movzx_b(ebx, FieldOperand(eax, edx, times_1, SeqAsciiString::kHeaderSize));
5276 FieldOperand(eax, edx, times_1, SeqAsciiString::kHeaderSize + 1));
5281 masm, ebx, ecx, eax, edx, edi,
5287 __ mov(eax, Operand(esp, 3 * kPointerSize));
5288 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
5293 // eax: string
5301 __ AllocateAsciiString(eax, ecx, ebx, edx, edi, &runtime);
5303 // eax: result string
5307 __ mov(edi, eax);
5316 // eax: result string
5328 // eax: string
5336 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime);
5338 // eax: result string
5342 __ mov(edi, eax);
5356 // eax: result string
5442 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
5449 __ Set(eax, Immediate(Smi::FromInt(LESS)));
5454 __ Set(eax, Immediate(Smi::FromInt(GREATER)));
5468 __ mov(eax, Operand(esp, 1 * kPointerSize)); // right
5471 __ cmp(edx, Operand(eax));
5475 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
5482 __ JumpIfNotBothSequentialAsciiStrings(edx, eax, ecx, ebx, &runtime);
5489 GenerateCompareFlatAsciiStrings(masm, edx, eax, ecx, ebx, edi);
5502 __ or_(ecx, Operand(eax));
5508 __ sub(eax, Operand(edx));
5511 __ sub(edx, Operand(eax));
5516 __ mov(eax, edx);
5532 __ and_(ecx, Operand(eax));
5536 __ CmpObjectType(eax, HEAP_NUMBER_TYPE, ecx);
5549 __ movdbl(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
5559 __ mov(eax, 0); // equal
5561 __ cmov(above, eax, Operand(ecx));
5563 __ cmov(below, eax, Operand(ecx));
5582 __ and_(ecx, Operand(eax));
5586 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
5592 __ sub(eax, Operand(edx));
5604 __ push(eax);
5612 __ push(eax);
5618 __ lea(edi, FieldOperand(eax, Code::kHeaderSize));
5622 __ pop(eax);
