Lines Matching defs:eax
28 // eax -- number of arguments
38 descriptor->Initialize(eax, deopt_handler, constant_stack_parameter_count,
48 // eax -- number of arguments
57 descriptor->Initialize(eax, deopt_handler, constant_stack_parameter_count,
113 eax.is(descriptor.GetEnvironmentParameterRegister(param_count - 1)));
172 // operand_1 in eax, operand_2 in edx; falls through on float
180 // either operand is not a number. Operands are in edx and eax.
210 // Since we must use ecx for shifts below, use some other register (eax)
212 Register result_reg = final_result_reg.is(ecx) ? eax : final_result_reg;
216 Register save_reg = final_result_reg.is(ecx) ? eax : ecx;
338 // Load operand in eax into xmm1, or branch to not_numbers.
339 __ JumpIfSmi(eax, &load_smi_eax, Label::kNear);
340 __ cmp(FieldOperand(eax, HeapObject::kMapOffset), factory->heap_number_map());
342 __ jmp(not_numbers); // Argument in eax is not a number.
349 __ SmiUntag(eax); // Untag smi before converting to float.
350 __ Cvtsi2sd(xmm1, eax);
351 __ SmiTag(eax); // Retag smi for heap number overwriting test.
354 __ movsd(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
372 __ JumpIfSmi(eax, &done, Label::kNear);
373 __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));
375 __ j(not_equal, non_float); // argument in eax is not a number -> NaN
385 DCHECK(exponent.is(eax));
555 __ test_b(eax, 0x5F); // We check for all but precision exception.
624 __ AllocateHeapNumber(eax, scratch, base, &call_runtime);
625 __ movsd(FieldOperand(eax, HeapNumber::kValueOffset), double_result);
656 NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(masm, receiver, eax,
670 Register scratch = eax;
695 // The key is in edx and the parameter count is in eax.
697 DCHECK(eax.is(ArgumentsAccessReadDescriptor::parameter_count()));
716 // through register eax. Use unsigned comparison to get negative
718 __ cmp(edx, eax);
724 __ lea(ebx, Operand(ebp, eax, times_2, 0));
726 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
742 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
841 __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
843 // eax = address of new object(s) (tagged)
866 // eax = address of new object (tagged)
874 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
875 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
877 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
884 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
891 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
898 __ lea(edi, Operand(eax, Heap::kSloppyArgumentsObjectSize));
899 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
901 // eax = address of new object (tagged)
909 __ push(eax);
918 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
919 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), eax);
921 __ lea(eax, Operand(edi, ebx, times_2, kParameterMapHeaderSize));
922 __ mov(FieldOperand(edi, FixedArray::kHeaderSize + 1 * kPointerSize), eax);
934 __ mov(eax, Operand(esp, 2 * kPointerSize));
937 __ sub(ebx, eax);
940 __ lea(edi, Operand(edi, eax, times_2, kParameterMapHeaderSize));
941 // eax = loop variable (tagged)
954 __ sub(eax, Immediate(Smi::FromInt(1)));
955 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
956 __ mov(FieldOperand(edi, eax, times_2, FixedArray::kHeaderSize), ecx);
959 __ test(eax, eax);
985 __ mov(eax, Operand(edx, 0));
986 __ mov(FieldOperand(edi, ebx, times_2, FixedArray::kHeaderSize), eax);
994 __ pop(eax); // Address of arguments object.
1002 __ pop(eax); // Remove saved parameter count.
1044 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
1052 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
1053 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
1055 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
1062 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
1076 __ lea(edi, Operand(eax, Heap::kStrictArgumentsObjectSize));
1077 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
1138 __ mov(eax, Operand(esp, kJSRegExpOffset));
1140 __ JumpIfSmi(eax, &runtime);
1141 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
1145 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
1173 __ mov(eax, Operand(esp, kSubjectOffset));
1174 __ JumpIfSmi(eax, &runtime);
1175 __ mov(edx, eax); // Make a copy of the original subject string.
1176 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1179 // eax: subject string
1235 __ cmp(FieldOperand(eax, ConsString::kSecondOffset), factory->empty_string());
1237 __ mov(eax, FieldOperand(eax, ConsString::kFirstOffset));
1239 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1253 // eax: sequential subject string (or look-alike, external string)
1259 // to use edx instead of eax here because it might have been only made to
1276 // eax: subject string
1322 // eax: underlying subject string
1341 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqOneByteString::kHeaderSize));
1343 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqOneByteString::kHeaderSize));
1350 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqTwoByteString::kHeaderSize));
1352 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
1366 __ cmp(eax, 1);
1371 __ cmp(eax, NativeRegExpMacroAssembler::FAILURE);
1373 __ cmp(eax, NativeRegExpMacroAssembler::EXCEPTION);
1383 __ mov(eax, Operand::StaticVariable(pending_exception));
1384 __ cmp(edx, eax);
1393 __ cmp(eax, factory->termination_exception());
1398 __ Throw(eax);
1401 __ ThrowUncatchable(eax);
1405 __ mov(eax, factory->null_value());
1410 __ mov(eax, Operand(esp, kJSRegExpOffset));
1411 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
1421 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1422 __ JumpIfSmi(eax, &runtime);
1423 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
1426 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
1427 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
1428 __ cmp(eax, factory->fixed_array_map());
1432 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
1433 __ SmiUntag(eax);
1434 __ sub(eax, Immediate(RegExpImpl::kLastMatchOverhead));
1435 __ cmp(edx, eax);
1445 __ mov(eax, Operand(esp, kSubjectOffset));
1446 __ mov(ecx, eax);
1447 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
1450 eax,
1453 __ mov(eax, ecx);
1454 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
1457 eax,
1488 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1504 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1512 __ mov(eax, FieldOperand(eax, ExternalString::kResourceDataOffset));
1515 __ sub(eax, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
1521 // eax: sequential subject string (or look-alike, external string)
1527 // to use edx instead of eax here because it might have been only made to
1546 __ mov(edi, FieldOperand(eax, SlicedString::kOffsetOffset));
1547 __ mov(eax, FieldOperand(eax, SlicedString::kParentOffset));
1597 CheckInputType(masm, eax, right(), &miss);
1602 __ or_(ecx, eax);
1604 __ sub(edx, eax); // Return on the result of the subtraction.
1608 __ mov(eax, edx);
1620 __ cmp(eax, edx);
1629 __ Move(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc))));
1641 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1644 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
1665 __ and_(ecx, eax);
1672 // ecx still holds eax & kSmiTag, which is either zero or one.
1675 __ xor_(ebx, eax);
1676 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1677 __ xor_(ebx, eax);
1678 // if eax was smi, ebx is now edx, else eax.
1686 __ mov(eax, ebx);
1698 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1701 // Return non-zero (eax is not zero)
1733 __ mov(eax, 0); // equal
1735 __ cmov(above, eax, ecx);
1737 __ cmov(below, eax, ecx);
1745 __ mov(eax, Immediate(Smi::FromInt(1)));
1747 __ mov(eax, Immediate(Smi::FromInt(-1)));
1757 BranchIfNotInternalizedString(masm, &check_for_strings, eax, ecx);
1761 // are internalized they aren't equal. Register eax already holds a
1768 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1773 StringHelper::GenerateFlatOneByteStringEquals(masm, edx, eax, ecx, ebx);
1775 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
1794 __ lea(ecx, Operand(eax, edx, times_1, 0));
1797 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1812 __ Move(eax, Immediate(EQUAL));
1814 // Return non-equal by returning the non-zero object pointer in eax,
1823 __ push(eax);
1850 // eax : number of arguments to the construct function
1914 __ SmiTag(eax);
1915 __ push(eax);
1926 __ pop(eax);
1927 __ SmiUntag(eax);
1975 __ Move(eax, Immediate(argc + 1));
1987 __ Move(eax, Immediate(argc));
1999 __ push(eax);
2003 __ mov(Operand(esp, (argc + 1) * kPointerSize), eax);
2032 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
2035 __ JumpIfSmi(eax, &wrap);
2037 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
2068 // eax : number of arguments
2115 // eax: number of arguments
2127 // Set expected number of arguments to zero (not changing eax).
2156 __ mov(eax, arg_count());
2206 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
2208 __ JumpIfSmi(eax, &wrap);
2210 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
2290 __ mov(edi, eax);
2326 // eax: number of arguments including receiver
2344 // Result returned in eax, or eax+edx if result size is 2.
2357 // Result is in eax or edx:eax - do not destroy these registers!
2363 __ cmp(eax, isolate()->factory()->the_hole_value());
2371 __ cmp(eax, isolate()->factory()->exception());
2399 __ mov(eax, Operand::StaticVariable(pending_exception_address));
2408 __ cmp(eax, isolate()->factory()->termination_exception());
2412 __ Throw(eax);
2415 __ ThrowUncatchable(eax);
2461 __ mov(Operand::StaticVariable(pending_exception), eax);
2462 __ mov(eax, Immediate(isolate()->factory()->exception()));
2526 // b8 XX XX XX XX mov eax, <the hole, patched to either true or false>
2541 Register object = eax; // Object (lhs).
2578 __ LoadRoot(eax, Heap::kInstanceofCacheAnswerRootIndex);
2628 __ mov(eax, Immediate(0));
2629 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2631 __ mov(eax, factory->true_value());
2635 __ mov(eax, factory->true_value());
2642 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2644 __ Move(eax, Immediate(0));
2651 __ mov(eax, Immediate(Smi::FromInt(1)));
2652 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2654 __ mov(eax, factory->false_value());
2658 __ mov(eax, factory->false_value());
2665 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2667 __ Move(eax, Immediate(Smi::FromInt(1)));
2684 __ mov(eax, factory->false_value());
2686 __ Move(eax, Immediate(Smi::FromInt(1)));
2694 __ mov(eax, factory->false_value());
2696 __ Move(eax, Immediate(Smi::FromInt(1)));
2705 __ mov(eax, factory->false_value());
2707 __ Move(eax, Immediate(Smi::FromInt(1)));
2732 __ test(eax, eax);
2734 __ mov(eax, factory->false_value());
2737 __ mov(eax, factory->true_value());
2801 if (!index_.is(eax)) {
2804 __ mov(index_, eax);
2826 if (!result_.is(eax)) {
2827 __ mov(result_, eax);
2873 if (!result_.is(eax)) {
2874 __ mov(result_, eax);
2926 __ mov(eax, Operand(esp, 3 * kPointerSize));
2928 __ JumpIfSmi(eax, &runtime);
2929 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
2932 // eax: string
2941 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
2957 // eax: string
2975 __ cmp(FieldOperand(eax, ConsString::kSecondOffset),
2978 __ mov(edi, FieldOperand(eax, ConsString::kFirstOffset));
2986 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2987 __ mov(edi, FieldOperand(eax, SlicedString::kParentOffset));
2995 __ mov(edi, eax);
3018 __ AllocateOneByteSlicedString(eax, ebx, no_reg, &runtime);
3021 __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime);
3023 __ mov(FieldOperand(eax, SlicedString::kLengthOffset), ecx);
3024 __ mov(FieldOperand(eax, SlicedString::kHashFieldOffset),
3026 __ mov(FieldOperand(eax, SlicedString::kParentOffset), edi);
3027 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
3066 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
3068 // eax: result string
3071 __ mov(edi, eax);
3079 // eax: result string
3090 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
3092 // eax: result string
3095 __ mov(edi, eax);
3107 // eax: result string
3125 // eax: string
3130 eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
3150 __ Move(eax, Immediate(Smi::FromInt(NOT_EQUAL)));
3159 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3168 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3213 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3226 __ Move(eax, Immediate(Smi::FromInt(LESS)));
3231 __ Move(eax, Immediate(Smi::FromInt(GREATER)));
3271 __ mov(eax, Operand(esp, 1 * kPointerSize)); // right
3274 __ cmp(edx, eax);
3278 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3285 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
3292 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
3305 // -- eax : right
3334 __ or_(ecx, eax);
3339 __ sub(eax, edx);
3342 __ sub(edx, eax);
3347 __ mov(eax, edx);
3367 __ JumpIfNotSmi(eax, &miss);
3372 __ JumpIfSmi(eax, &right_smi, Label::kNear);
3373 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
3376 __ movsd(xmm1, FieldOperand(eax, HeapNumber::kValueOffset));
3379 __ mov(ecx, eax); // Can't clobber eax because we can still jump away.
3404 __ mov(eax, 0); // equal
3406 __ cmov(above, eax, ecx);
3408 __ cmov(below, eax, ecx);
3419 __ cmp(eax, Immediate(isolate()->factory()->undefined_value()));
3444 Register right = eax;
3468 // Make sure eax is non-zero. At this point input operands are
3470 DCHECK(right.is(eax));
3474 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3489 Register right = eax;
3513 // Make sure eax is non-zero. At this point input operands are
3515 DCHECK(right.is(eax));
3519 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3536 Register right = eax;
3565 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3581 // Make sure eax is non-zero. At this point input operands are
3583 DCHECK(right.is(eax));
3622 __ and_(ecx, eax);
3625 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
3631 __ sub(eax, edx);
3642 __ and_(ecx, eax);
3645 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
3652 __ sub(eax, edx);
3666 __ push(edx); // Preserve edx and eax.
3667 __ push(eax);
3669 __ push(eax);
3673 __ lea(edi, FieldOperand(eax, Code::kHeaderSize));
3674 __ pop(eax);
4088 // -- eax : element value to store
4111 __ JumpIfSmi(eax, &smi_element);
4122 __ push(eax);
4139 __ mov(Operand(ecx, 0), eax);
4141 __ RecordWrite(ebx, ecx, eax,
4152 FixedArrayBase::kHeaderSize), eax);
4160 __ StoreNumberToDoubleElements(eax,
4211 __ push(eax);
4216 __ lea(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
4217 __ push(eax);
4221 __ mov(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
4222 __ sub(eax, Immediate(Assembler::kCallInstructionLength));
4223 __ push(eax);
4234 __ pop(eax);
4273 // eax - number of arguments
4396 __ test(eax, eax);
4401 __ cmp(eax, 1);
4421 // -- eax : argc (only if argument_count() == ANY)
4466 __ test(eax, eax);
4472 __ cmp(eax, 1);
4499 // -- eax : argc
4549 // -- eax : callee
4562 Register callee = eax;
