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)));
168 // operand_1 in eax, operand_2 in edx; falls through on float
200 // Since we must use ecx for shifts below, use some other register (eax)
202 Register result_reg = final_result_reg.is(ecx) ? eax : final_result_reg;
206 Register save_reg = final_result_reg.is(ecx) ? eax : ecx;
316 __ JumpIfSmi(eax, &done, Label::kNear);
317 __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));
319 __ j(not_equal, non_float); // argument in eax is not a number -> NaN
336 NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(masm, receiver, eax,
350 Register scratch = eax;
375 // The key is in edx and the parameter count is in eax.
377 DCHECK(eax.is(ArgumentsAccessReadDescriptor::parameter_count()));
396 // through register eax. Use unsigned comparison to get negative
398 __ cmp(edx, eax);
404 __ lea(ebx, Operand(ebp, eax, times_2, 0));
406 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
422 __ mov(eax, Operand(ebx, edx, times_2, kDisplacement));
521 __ Allocate(ebx, eax, edx, edi, &runtime, TAG_OBJECT);
523 // eax = address of new object(s) (tagged)
546 // eax = address of new object (tagged)
554 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
555 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
557 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
564 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
571 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
578 __ lea(edi, Operand(eax, Heap::kSloppyArgumentsObjectSize));
579 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
581 // eax = address of new object (tagged)
589 __ push(eax);
598 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
599 __ mov(FieldOperand(edi, FixedArray::kLengthOffset), eax);
601 __ lea(eax, Operand(edi, ebx, times_2, kParameterMapHeaderSize));
602 __ mov(FieldOperand(edi, FixedArray::kHeaderSize + 1 * kPointerSize), eax);
614 __ mov(eax, Operand(esp, 2 * kPointerSize));
617 __ sub(ebx, eax);
620 __ lea(edi, Operand(edi, eax, times_2, kParameterMapHeaderSize));
621 // eax = loop variable (tagged)
634 __ sub(eax, Immediate(Smi::FromInt(1)));
635 __ mov(FieldOperand(edx, eax, times_2, kParameterMapHeaderSize), ebx);
636 __ mov(FieldOperand(edi, eax, times_2, FixedArray::kHeaderSize), ecx);
639 __ test(eax, eax);
665 __ mov(eax, Operand(edx, 0));
666 __ mov(FieldOperand(edi, ebx, times_2, FixedArray::kHeaderSize), eax);
674 __ pop(eax); // Address of arguments object.
682 __ pop(eax); // Remove saved parameter count.
724 __ Allocate(ecx, eax, edx, ebx, &runtime, TAG_OBJECT);
732 __ mov(FieldOperand(eax, JSObject::kMapOffset), edi);
733 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
735 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
742 __ mov(FieldOperand(eax, JSObject::kHeaderSize +
756 __ lea(edi, Operand(eax, Heap::kStrictArgumentsObjectSize));
757 __ mov(FieldOperand(eax, JSObject::kElementsOffset), edi);
818 __ mov(eax, Operand(esp, kJSRegExpOffset));
820 __ JumpIfSmi(eax, &runtime);
821 __ CmpObjectType(eax, JS_REGEXP_TYPE, ecx);
825 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
853 __ mov(eax, Operand(esp, kSubjectOffset));
854 __ JumpIfSmi(eax, &runtime);
855 __ mov(edx, eax); // Make a copy of the original subject string.
856 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
859 // eax: subject string
915 __ cmp(FieldOperand(eax, ConsString::kSecondOffset), factory->empty_string());
917 __ mov(eax, FieldOperand(eax, ConsString::kFirstOffset));
919 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
933 // eax: sequential subject string (or look-alike, external string)
939 // to use edx instead of eax here because it might have been only made to
956 // eax: subject string
1002 // eax: underlying subject string
1021 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqOneByteString::kHeaderSize));
1023 __ lea(ecx, FieldOperand(eax, ebx, times_1, SeqOneByteString::kHeaderSize));
1030 __ lea(ecx, FieldOperand(eax, esi, times_1, SeqTwoByteString::kHeaderSize));
1032 __ lea(ecx, FieldOperand(eax, ebx, times_2, SeqTwoByteString::kHeaderSize));
1046 __ cmp(eax, 1);
1051 __ cmp(eax, NativeRegExpMacroAssembler::FAILURE);
1053 __ cmp(eax, NativeRegExpMacroAssembler::EXCEPTION);
1063 __ mov(eax, Operand::StaticVariable(pending_exception));
1064 __ cmp(edx, eax);
1073 __ cmp(eax, factory->termination_exception());
1078 __ Throw(eax);
1081 __ ThrowUncatchable(eax);
1085 __ mov(eax, factory->null_value());
1090 __ mov(eax, Operand(esp, kJSRegExpOffset));
1091 __ mov(ecx, FieldOperand(eax, JSRegExp::kDataOffset));
1101 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1102 __ JumpIfSmi(eax, &runtime);
1103 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
1106 __ mov(ebx, FieldOperand(eax, JSArray::kElementsOffset));
1107 __ mov(eax, FieldOperand(ebx, HeapObject::kMapOffset));
1108 __ cmp(eax, factory->fixed_array_map());
1112 __ mov(eax, FieldOperand(ebx, FixedArray::kLengthOffset));
1113 __ SmiUntag(eax);
1114 __ sub(eax, Immediate(RegExpImpl::kLastMatchOverhead));
1115 __ cmp(edx, eax);
1125 __ mov(eax, Operand(esp, kSubjectOffset));
1126 __ mov(ecx, eax);
1127 __ mov(FieldOperand(ebx, RegExpImpl::kLastSubjectOffset), eax);
1128 __ RecordWriteField(ebx, RegExpImpl::kLastSubjectOffset, eax, edi,
1130 __ mov(eax, ecx);
1131 __ mov(FieldOperand(ebx, RegExpImpl::kLastInputOffset), eax);
1132 __ RecordWriteField(ebx, RegExpImpl::kLastInputOffset, eax, edi,
1162 __ mov(eax, Operand(esp, kLastMatchInfoOffset));
1178 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
1186 __ mov(eax, FieldOperand(eax, ExternalString::kResourceDataOffset));
1189 __ sub(eax, Immediate(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
1195 // eax: sequential subject string (or look-alike, external string)
1201 // to use edx instead of eax here because it might have been only made to
1220 __ mov(edi, FieldOperand(eax, SlicedString::kOffsetOffset));
1221 __ mov(eax, FieldOperand(eax, SlicedString::kParentOffset));
1271 CheckInputType(masm, eax, right(), &miss);
1276 __ or_(ecx, eax);
1278 __ sub(edx, eax); // Return on the result of the subtraction.
1282 __ mov(eax, edx);
1294 __ cmp(eax, edx);
1303 __ Move(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc))));
1315 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1318 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
1339 __ and_(ecx, eax);
1346 // ecx still holds eax & kSmiTag, which is either zero or one.
1349 __ xor_(ebx, eax);
1350 __ and_(ebx, ecx); // ebx holds either 0 or eax ^ edx.
1351 __ xor_(ebx, eax);
1352 // if eax was smi, ebx is now edx, else eax.
1360 __ mov(eax, ebx);
1372 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1375 // Return non-zero (eax is not zero)
1403 FloatingPointHelper::LoadFloatOperand(masm, eax);
1415 __ Move(eax, Immediate(0));
1419 __ mov(eax, Immediate(Smi::FromInt(-1)));
1423 __ mov(eax, Immediate(Smi::FromInt(1)));
1431 __ mov(eax, Immediate(Smi::FromInt(1)));
1433 __ mov(eax, Immediate(Smi::FromInt(-1)));
1443 BranchIfNotInternalizedString(masm, &check_for_strings, eax, ecx);
1447 // are internalized they aren't equal. Register eax already holds a
1454 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx,
1459 StringHelper::GenerateFlatOneByteStringEquals(masm, edx, eax, ecx, ebx);
1461 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
1480 __ lea(ecx, Operand(eax, edx, times_1, 0));
1483 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1498 __ Move(eax, Immediate(EQUAL));
1500 // Return non-equal by returning the non-zero object pointer in eax,
1509 __ push(eax);
1536 // eax : number of arguments to the construct function
1600 __ SmiTag(eax);
1601 __ push(eax);
1612 __ pop(eax);
1613 __ SmiUntag(eax);
1661 __ Move(eax, Immediate(argc + 1));
1673 __ Move(eax, Immediate(argc));
1685 __ push(eax);
1689 __ mov(Operand(esp, (argc + 1) * kPointerSize), eax);
1718 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
1721 __ JumpIfSmi(eax, &wrap);
1723 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1754 // eax : number of arguments
1801 // eax: number of arguments
1813 // Set expected number of arguments to zero (not changing eax).
1842 __ mov(eax, arg_count());
1892 __ mov(eax, Operand(esp, (argc + 1) * kPointerSize));
1894 __ JumpIfSmi(eax, &wrap);
1896 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1976 __ mov(edi, eax);
2017 // eax: number of arguments including receiver
2035 // Result returned in eax, or eax+edx if result size is 2.
2048 // Result is in eax or edx:eax - do not destroy these registers!
2054 __ cmp(eax, isolate()->factory()->the_hole_value());
2062 __ cmp(eax, isolate()->factory()->exception());
2090 __ mov(eax, Operand::StaticVariable(pending_exception_address));
2099 __ cmp(eax, isolate()->factory()->termination_exception());
2103 __ Throw(eax);
2106 __ ThrowUncatchable(eax);
2152 __ mov(Operand::StaticVariable(pending_exception), eax);
2153 __ mov(eax, Immediate(isolate()->factory()->exception()));
2217 // b8 XX XX XX XX mov eax, <the hole, patched to either true or false>
2232 Register object = eax; // Object (lhs).
2269 __ LoadRoot(eax, Heap::kInstanceofCacheAnswerRootIndex);
2319 __ mov(eax, Immediate(0));
2320 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2322 __ mov(eax, factory->true_value());
2326 __ mov(eax, factory->true_value());
2333 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2335 __ Move(eax, Immediate(0));
2342 __ mov(eax, Immediate(Smi::FromInt(1)));
2343 __ StoreRoot(eax, scratch, Heap::kInstanceofCacheAnswerRootIndex);
2345 __ mov(eax, factory->false_value());
2349 __ mov(eax, factory->false_value());
2356 __ mov(Operand(scratch, kDeltaToMovImmediate), eax);
2358 __ Move(eax, Immediate(Smi::FromInt(1)));
2375 __ mov(eax, factory->false_value());
2377 __ Move(eax, Immediate(Smi::FromInt(1)));
2385 __ mov(eax, factory->false_value());
2387 __ Move(eax, Immediate(Smi::FromInt(1)));
2396 __ mov(eax, factory->false_value());
2398 __ Move(eax, Immediate(Smi::FromInt(1)));
2423 __ test(eax, eax);
2425 __ mov(eax, factory->false_value());
2428 __ mov(eax, factory->true_value());
2492 if (!index_.is(eax)) {
2495 __ mov(index_, eax);
2517 if (!result_.is(eax)) {
2518 __ mov(result_, eax);
2564 if (!result_.is(eax)) {
2565 __ mov(result_, eax);
2617 __ mov(eax, Operand(esp, 3 * kPointerSize));
2619 __ JumpIfSmi(eax, &runtime);
2620 Condition is_string = masm->IsObjectStringType(eax, ebx, ebx);
2623 // eax: string
2632 __ cmp(ecx, FieldOperand(eax, String::kLengthOffset));
2648 // eax: string
2666 __ cmp(FieldOperand(eax, ConsString::kSecondOffset),
2669 __ mov(edi, FieldOperand(eax, ConsString::kFirstOffset));
2677 __ add(edx, FieldOperand(eax, SlicedString::kOffsetOffset));
2678 __ mov(edi, FieldOperand(eax, SlicedString::kParentOffset));
2686 __ mov(edi, eax);
2709 __ AllocateOneByteSlicedString(eax, ebx, no_reg, &runtime);
2712 __ AllocateTwoByteSlicedString(eax, ebx, no_reg, &runtime);
2714 __ mov(FieldOperand(eax, SlicedString::kLengthOffset), ecx);
2715 __ mov(FieldOperand(eax, SlicedString::kHashFieldOffset),
2717 __ mov(FieldOperand(eax, SlicedString::kParentOffset), edi);
2718 __ mov(FieldOperand(eax, SlicedString::kOffsetOffset), edx);
2757 __ AllocateOneByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2759 // eax: result string
2762 __ mov(edi, eax);
2770 // eax: result string
2781 __ AllocateTwoByteString(eax, ecx, ebx, edx, edi, &runtime_drop_two);
2783 // eax: result string
2786 __ mov(edi, eax);
2798 // eax: result string
2816 // eax: string
2821 eax, edx, ecx, eax, &runtime, &runtime, &runtime, STRING_INDEX_IS_NUMBER);
2841 __ Move(eax, Immediate(Smi::FromInt(NOT_EQUAL)));
2850 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
2859 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
2904 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
2917 __ Move(eax, Immediate(Smi::FromInt(LESS)));
2922 __ Move(eax, Immediate(Smi::FromInt(GREATER)));
2962 __ mov(eax, Operand(esp, 1 * kPointerSize)); // right
2965 __ cmp(edx, eax);
2969 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
2976 __ JumpIfNotBothSequentialOneByteStrings(edx, eax, ecx, ebx, &runtime);
2983 StringHelper::GenerateCompareFlatOneByteStrings(masm, edx, eax, ecx, ebx,
2996 // -- eax : right
3025 __ or_(ecx, eax);
3030 __ sub(eax, edx);
3033 __ sub(edx, eax);
3038 __ mov(eax, edx);
3058 __ JumpIfNotSmi(eax, &miss);
3064 __ and_(ecx, eax);
3067 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
3082 __ cmp(eax, Immediate(isolate()->factory()->undefined_value()));
3107 Register right = eax;
3131 // Make sure eax is non-zero. At this point input operands are
3133 DCHECK(right.is(eax));
3137 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3152 Register right = eax;
3176 // Make sure eax is non-zero. At this point input operands are
3178 DCHECK(right.is(eax));
3182 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3199 Register right = eax;
3228 __ Move(eax, Immediate(Smi::FromInt(EQUAL)));
3244 // Make sure eax is non-zero. At this point input operands are
3246 DCHECK(right.is(eax));
3285 __ and_(ecx, eax);
3288 __ CmpObjectType(eax, JS_OBJECT_TYPE, ecx);
3294 __ sub(eax, edx);
3305 __ and_(ecx, eax);
3308 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
3315 __ sub(eax, edx);
3329 __ push(edx); // Preserve edx and eax.
3330 __ push(eax);
3332 __ push(eax);
3336 __ lea(edi, FieldOperand(eax, Code::kHeaderSize));
3337 __ pop(eax);
3751 // -- eax : element value to store
3774 __ JumpIfSmi(eax, &smi_element);
3785 __ push(eax);
3802 __ mov(Operand(ecx, 0), eax);
3804 __ RecordWrite(ebx, ecx, eax, kDontSaveFPRegs, EMIT_REMEMBERED_SET,
3813 FixedArrayBase::kHeaderSize), eax);
3821 __ StoreNumberToDoubleElements(eax,
3872 __ push(eax);
3877 __ lea(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
3878 __ push(eax);
3882 __ mov(eax, Operand(esp, (kNumSavedRegisters + 1) * kPointerSize));
3883 __ sub(eax, Immediate(Assembler::kCallInstructionLength));
3884 __ push(eax);
3895 __ pop(eax);
3934 // eax - number of arguments
4057 __ test(eax, eax);
4062 __ cmp(eax, 1);
4082 // -- eax : argc (only if argument_count() == ANY)
4127 __ test(eax, eax);
4133 __ cmp(eax, 1);
4160 // -- eax : argc
4210 // -- eax : callee
4223 Register callee = eax;
