Lines Matching defs:eax
56 __ test(eax, Immediate(delta_to_patch_site));
161 __ mov(eax, Immediate(isolate()->factory()->undefined_value()));
170 __ push(eax);
178 __ push(eax);
205 // Context is returned in eax. It replaces the context passed to us.
207 __ mov(esi, eax);
208 __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), eax);
218 __ mov(eax, Operand(ebp, parameter_offset));
221 __ mov(Operand(esi, context_offset), eax);
222 // Update the write barrier. This clobbers eax and ebx.
224 __ RecordWriteContextSlot(esi, context_offset, eax, ebx,
228 __ JumpIfInNewSpace(esi, eax, &done, Label::kNear);
267 SetVar(arguments, eax, ebx, edx);
316 __ mov(eax, isolate()->factory()->undefined_value());
323 __ Move(eax, Immediate(Smi::FromInt(0)));
379 __ push(eax);
394 __ push(eax);
397 __ pop(eax);
727 __ cmp(eax, isolate()->factory()->true_value());
868 __ LoadContext(eax, scope_->ContextChainLength(scope_->GlobalScope()));
869 __ mov(eax, ContextOperand(eax, variable->interface()->Index()));
870 __ mov(eax, ContextOperand(eax, Context::EXTENSION_INDEX));
873 __ mov(ContextOperand(esi, variable->index()), eax);
875 __ RecordWriteContextSlot(esi, Context::SlotOffset(variable->index()), eax,
969 __ or_(ecx, eax);
972 __ cmp(edx, eax);
989 __ cmp(eax, isolate()->factory()->true_value());
995 __ test(eax, eax);
1038 __ cmp(eax, isolate()->factory()->undefined_value());
1040 __ cmp(eax, isolate()->factory()->null_value());
1047 __ JumpIfSmi(eax, &convert, Label::kNear);
1048 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
1051 __ push(eax);
1054 __ push(eax);
1059 __ CmpObjectType(eax, LAST_JS_PROXY_TYPE, ecx);
1068 __ mov(eax, FieldOperand(eax, HeapObject::kMapOffset));
1073 __ push(eax);
1075 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
1080 // We got a map in register eax. Get the enumeration cache from it.
1084 __ EnumLength(edx, eax);
1088 __ LoadInstanceDescriptors(eax, ecx);
1093 __ push(eax); // Map.
1103 // We got a fixed array in register eax. Iterate through that.
1120 __ push(eax); // Array
1121 __ mov(eax, FieldOperand(eax, FixedArray::kLengthOffset));
1122 __ push(eax); // Fixed array length (as smi).
1128 __ mov(eax, Operand(esp, 0 * kPointerSize)); // Get the current index.
1129 __ cmp(eax, Operand(esp, 1 * kPointerSize)); // Compare to the array length.
1134 __ mov(ebx, FieldOperand(ebx, eax, times_2, FixedArray::kHeaderSize));
1159 __ test(eax, eax);
1161 __ mov(ebx, eax);
1260 context()->Plug(eax);
1281 __ cmp(eax, isolate()->factory()->undefined_value());
1399 __ mov(eax, ContextSlotOperandCheckExtensions(local, slow));
1402 __ cmp(eax, isolate()->factory()->the_hole_value());
1405 __ mov(eax, isolate()->factory()->undefined_value());
1433 context()->Plug(eax);
1480 GetVar(eax, var);
1481 __ cmp(eax, isolate()->factory()->the_hole_value());
1491 __ mov(eax, isolate()->factory()->undefined_value());
1494 context()->Plug(eax);
1513 context()->Plug(eax);
1527 // eax = regexp literal clone.
1537 // Result will be in eax.
1543 __ mov(ebx, eax);
1548 __ Allocate(size, eax, ecx, edx, &runtime_allocate, TAG_OBJECT);
1563 __ mov(FieldOperand(eax, i), edx);
1564 __ mov(FieldOperand(eax, i + kPointerSize), ecx);
1568 __ mov(FieldOperand(eax, size - kPointerSize), edx);
1570 context()->Plug(eax);
1607 __ mov(eax, FieldOperand(edi, JSFunction::kLiteralsOffset));
1616 // result_saved is false the result is in eax.
1632 __ push(eax); // Save result on the stack
1645 DCHECK(StoreDescriptor::ValueRegister().is(eax));
1705 context()->Plug(eax);
1745 __ mov(eax, FieldOperand(ebx, JSFunction::kLiteralsOffset));
1763 __ push(eax); // array literal.
1794 context()->Plug(eax);
1865 __ push(eax); // Left operand goes on the stack.
1897 context()->Plug(eax);
1932 __ mov(FieldOperand(eax, JSGeneratorObject::kContinuationOffset),
1934 __ mov(FieldOperand(eax, JSGeneratorObject::kContextOffset), esi);
1936 __ RecordWriteField(eax, JSGeneratorObject::kContextOffset, ecx, edx,
1941 __ push(eax); // generator object
1979 __ mov(eax, isolate()->factory()->undefined_value());
1988 __ push(eax); // exception
1995 __ pop(eax); // result
1998 __ push(eax); // result
2004 __ mov(eax, Operand(esp, generator_object_depth));
2005 __ push(eax); // g
2007 __ mov(FieldOperand(eax, JSGeneratorObject::kContinuationOffset),
2009 __ mov(FieldOperand(eax, JSGeneratorObject::kContextOffset), esi);
2011 __ RecordWriteField(eax, JSGeneratorObject::kContextOffset, ecx, edx,
2016 __ pop(eax); // result
2018 __ bind(&l_resume); // received in eax
2027 __ push(eax); // received
2038 __ mov(edi, eax);
2048 __ push(eax); // save result
2049 __ Move(load_receiver, eax); // result
2056 CallLoadIC(NOT_CONTEXTUAL); // result.done in eax
2059 __ test(eax, eax);
2070 CallLoadIC(NOT_CONTEXTUAL); // result.value in eax
2071 context()->DropAndPlug(2, eax); // drop iter and g
2081 // The value stays in eax, and is ultimately read by the resumed generator, as
2175 __ push(eax);
2198 __ Allocate(instance_size, eax, ecx, edx, &gc_required, TAG_OBJECT);
2213 __ mov(FieldOperand(eax, HeapObject::kMapOffset), ebx);
2214 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset),
2216 __ mov(FieldOperand(eax, JSObject::kElementsOffset),
2218 __ mov(FieldOperand(eax, JSGeneratorObject::kResultValuePropertyOffset), ecx);
2219 __ mov(FieldOperand(eax, JSGeneratorObject::kResultDonePropertyOffset), edx);
2223 __ RecordWriteField(eax, JSGeneratorObject::kResultValuePropertyOffset, ecx,
2251 __ push(eax);
2277 // stack. Right operand is in eax.
2280 __ mov(ecx, eax);
2281 __ or_(eax, edx);
2283 patch_site.EmitJumpIfSmi(eax, &smi_case, Label::kNear);
2286 __ mov(eax, ecx);
2294 __ mov(eax, edx); // Copy left operand in case of a stub call.
2299 __ sar_cl(eax); // No checks of result necessary
2300 __ and_(eax, Immediate(~kSmiTagMask));
2304 __ SmiUntag(eax);
2306 __ shl_cl(eax);
2308 __ cmp(eax, 0xc0000000);
2313 __ SmiTag(eax);
2318 __ SmiUntag(eax);
2320 __ shr_cl(eax);
2321 __ test(eax, Immediate(0xc0000000));
2326 __ SmiTag(eax);
2330 __ add(eax, ecx);
2334 __ sub(eax, ecx);
2338 __ SmiUntag(eax);
2339 __ imul(eax, ecx);
2341 __ test(eax, eax);
2349 __ or_(eax, ecx);
2352 __ and_(eax, ecx);
2355 __ xor_(eax, ecx);
2362 context()->Plug(eax);
2374 context()->Plug(eax);
2400 __ push(eax); // Preserve value.
2402 __ Move(StoreDescriptor::ReceiverRegister(), eax);
2410 __ push(eax); // Preserve value.
2413 __ Move(StoreDescriptor::NameRegister(), eax);
2422 context()->Plug(eax);
2428 __ mov(location, eax);
2430 __ mov(edx, eax);
2449 __ push(eax);
2481 __ push(eax); // Value.
2506 // eax : value
2519 context()->Plug(eax);
2525 // eax : value
2531 DCHECK(StoreDescriptor::ValueRegister().is(eax));
2538 context()->Plug(eax);
2555 context()->Plug(eax);
2562 context()->Plug(eax);
2598 __ mov(Operand(esp, kPointerSize), eax);
2617 __ push(eax);
2619 __ push(eax);
2621 __ push(eax);
2632 __ mov(Operand(esp, kPointerSize), eax);
2652 __ mov(LoadDescriptor::NameRegister(), eax);
2658 __ mov(Operand(esp, kPointerSize), eax);
2689 context()->DropAndPlug(1, eax);
2747 // The runtime call returns a pair of values in eax (function) and
2750 __ mov(Operand(esp, (arg_count + 1) * kPointerSize), eax);
2760 context()->DropAndPlug(1, eax);
2775 // Call the runtime to find the function to call (returned in eax) and
2780 __ push(eax); // Function.
2790 __ push(eax);
2858 // Load function and argument count into edi and eax.
2859 __ Move(eax, Immediate(arg_count));
2875 context()->Plug(eax);
2893 __ test(eax, Immediate(kSmiTagMask));
2914 __ test(eax, Immediate(kSmiTagMask | 0x80000000));
2934 __ JumpIfSmi(eax, if_false);
2935 __ cmp(eax, isolate()->factory()->null_value());
2937 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
2966 __ JumpIfSmi(eax, if_false);
2967 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ebx);
2988 __ JumpIfSmi(eax, if_false);
2989 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
3013 __ AssertNotSmi(eax);
3017 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
3023 __ mov(ecx, FieldOperand(eax, JSObject::kPropertiesOffset));
3064 __ mov(ebx, FieldOperand(eax, HeapObject::kMapOffset));
3103 __ JumpIfSmi(eax, if_false);
3104 __ CmpObjectType(eax, JS_FUNCTION_TYPE, ebx);
3126 __ CheckMap(eax, map, if_false, DO_SMI_CHECK);
3129 __ cmp(FieldOperand(eax, HeapNumber::kExponentOffset), Immediate(0x1));
3131 __ cmp(FieldOperand(eax, HeapNumber::kMantissaOffset), Immediate(0x0));
3153 __ JumpIfSmi(eax, if_false);
3154 __ CmpObjectType(eax, JS_ARRAY_TYPE, ebx);
3175 __ JumpIfSmi(eax, if_false);
3176 __ CmpObjectType(eax, JS_REGEXP_TYPE, ebx);
3196 __ mov(eax, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
3200 __ cmp(Operand(eax, StandardFrameConstants::kContextOffset),
3203 __ mov(eax, Operand(eax, StandardFrameConstants::kCallerFPOffset));
3207 __ cmp(Operand(eax, StandardFrameConstants::kMarkerOffset),
3232 __ cmp(eax, ebx);
3245 // parameter count in eax.
3247 __ mov(edx, eax);
3248 __ Move(eax, Immediate(Smi::FromInt(info_->scope()->num_parameters())));
3251 context()->Plug(eax);
3260 __ Move(eax, Immediate(Smi::FromInt(info_->scope()->num_parameters())));
3270 __ mov(eax, Operand(ebx, ArgumentsAdaptorFrameConstants::kLengthOffset));
3273 __ AssertSmi(eax);
3274 context()->Plug(eax);
3286 __ JumpIfSmi(eax, &null);
3293 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, eax);
3294 // Map is now in eax.
3300 __ CmpInstanceType(eax, LAST_SPEC_OBJECT_TYPE);
3308 __ mov(eax, FieldOperand(eax, Map::kConstructorOffset));
3309 __ CmpObjectType(eax, JS_FUNCTION_TYPE, ebx);
3312 // eax now contains the constructor function. Grab the
3314 __ mov(eax, FieldOperand(eax, JSFunction::kSharedFunctionInfoOffset));
3315 __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kInstanceClassNameOffset));
3320 __ mov(eax, isolate()->factory()->Function_string());
3325 __ mov(eax, isolate()->factory()->Object_string());
3330 __ mov(eax, isolate()->factory()->null_value());
3335 context()->Plug(eax);
3348 context()->Plug(eax);
3362 context()->Plug(eax);
3374 __ JumpIfSmi(eax, &done, Label::kNear);
3376 __ CmpObjectType(eax, JS_VALUE_TYPE, ebx);
3378 __ mov(eax, FieldOperand(eax, JSValue::kValueOffset));
3381 context()->Plug(eax);
3394 Register object = eax;
3395 Register result = eax;
3434 Register string = eax;
3470 Register string = eax;
3507 context()->Plug(eax);
3517 __ pop(ebx); // eax = value. ebx = object.
3528 __ mov(FieldOperand(ebx, JSValue::kValueOffset), eax);
3532 __ mov(edx, eax);
3536 context()->Plug(eax);
3544 // Load the argument into eax and call the stub.
3549 context()->Plug(eax);
3560 StringCharFromCodeGenerator generator(eax, ebx);
3580 Register index = eax;
3626 Register index = eax;
3628 Register result = eax;
3675 context()->Plug(eax);
3688 context()->Plug(eax);
3704 __ JumpIfSmi(eax, &runtime);
3705 __ CmpObjectType(eax, JS_FUNCTION_TYPE, ebx);
3716 __ push(eax);
3720 context()->Plug(eax);
3735 context()->Plug(eax);
3750 __ mov(eax, isolate()->factory()->undefined_value());
3751 context()->Plug(eax);
3757 Register key = eax;
3774 __ mov(eax, FixedArrayElementOperand(cache, tmp, 1));
3784 context()->Plug(eax);
3794 __ AssertString(eax);
3803 __ test(FieldOperand(eax, String::kHashFieldOffset),
3817 __ AssertString(eax);
3819 __ mov(eax, FieldOperand(eax, String::kHashFieldOffset));
3820 __ IndexFromHash(eax, eax);
3822 context()->Plug(eax);
3835 // Load this to eax (= array)
3838 Register array = eax;
3839 Register elements = no_reg; // Will be eax.
4081 __ mov(eax, result_operand);
4086 context()->Plug(eax);
4094 __ movzx_b(eax, Operand::StaticVariable(debug_is_active));
4095 __ SmiTag(eax);
4096 context()->Plug(eax);
4113 __ mov(eax, GlobalObjectOperand());
4114 __ push(FieldOperand(eax, GlobalObject::kBuiltinsOffset));
4129 __ mov(Operand(esp, kPointerSize), eax);
4145 context()->DropAndPlug(1, eax);
4157 context()->Plug(eax);
4174 context()->Plug(eax);
4185 context()->Plug(eax);
4197 context()->Plug(eax);
4243 __ mov(eax, isolate()->factory()->true_value());
4251 __ mov(eax, isolate()->factory()->false_value());
4266 context()->Plug(eax);
4332 patch_site.EmitJumpIfNotSmi(eax, &slow, Label::kNear);
4342 __ push(eax);
4345 __ mov(Operand(esp, kPointerSize), eax);
4348 __ mov(Operand(esp, 2 * kPointerSize), eax);
4355 __ add(eax, Immediate(Smi::FromInt(1)));
4357 __ sub(eax, Immediate(Smi::FromInt(1)));
4362 __ sub(eax, Immediate(Smi::FromInt(1)));
4364 __ add(eax, Immediate(Smi::FromInt(1)));
4380 __ push(eax);
4383 __ mov(Operand(esp, kPointerSize), eax);
4386 __ mov(Operand(esp, 2 * kPointerSize), eax);
4397 __ mov(edx, eax);
4398 __ mov(eax, Immediate(Smi::FromInt(1)));
4405 // Store the value returned in eax.
4414 context.Plug(eax);
4426 context()->Plug(eax);
4440 context()->Plug(eax);
4457 context()->Plug(eax);
4482 context()->Plug(eax);
4498 context()->Plug(eax);
4523 __ JumpIfSmi(eax, if_true);
4524 __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
4528 __ JumpIfSmi(eax, if_false);
4529 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, edx);
4536 __ JumpIfSmi(eax, if_false);
4537 __ CmpObjectType(eax, SYMBOL_TYPE, edx);
4540 __ cmp(eax, isolate()->factory()->true_value());
4542 __ cmp(eax, isolate()->factory()->false_value());
4545 __ cmp(eax, isolate()->factory()->undefined_value());
4547 __ JumpIfSmi(eax, if_false);
4549 __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
4554 __ JumpIfSmi(eax, if_false);
4556 __ CmpObjectType(eax, JS_FUNCTION_TYPE, edx);
4561 __ JumpIfSmi(eax, if_false);
4562 __ cmp(eax, isolate()->factory()->null_value());
4564 __ CmpObjectType(eax, FIRST_NONCALLABLE_SPEC_OBJECT_TYPE, edx);
4603 __ cmp(eax, isolate()->factory()->true_value());
4612 __ test(eax, eax);
4628 __ or_(ecx, eax);
4630 __ cmp(edx, eax);
4642 __ test(eax, eax);
4670 __ cmp(eax, nil_value);
4675 __ test(eax, eax);
4683 __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
4684 context()->Plug(eax);
4689 return eax;
