Lines Matching defs:eax
24 // -- eax : number of arguments excluding receiver
56 // JumpToExternalReference expects eax to contain the number of arguments
58 __ add(eax, Immediate(num_extra_args + 1));
86 __ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
87 __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kCodeOffset));
88 __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
89 __ jmp(eax);
94 __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
95 __ jmp(eax);
123 // -- eax: number of arguments
136 __ SmiTag(eax);
137 __ push(eax);
153 __ mov(eax,
156 __ JumpIfSmi(eax, &rt_call);
158 // eax: initial map (if proven valid below)
159 __ CmpObjectType(eax, MAP_TYPE, ebx);
164 __ cmp(edi, FieldOperand(eax, Map::kConstructorOrBackPointerOffset));
171 // eax: initial map
172 __ CmpInstanceType(eax, JS_FUNCTION_TYPE);
177 // eax: initial map
178 __ movzx_b(edi, FieldOperand(eax, Map::kInstanceSizeOffset));
186 // eax: initial map
189 __ mov(Operand(ebx, JSObject::kMapOffset), eax);
211 __ mov(esi, FieldOperand(eax, Map::kBitField3Offset));
216 __ sub(FieldOperand(eax, Map::kBitField3Offset),
220 __ movzx_b(esi, FieldOperand(eax, Map::kUnusedPropertyFieldsOffset));
243 __ push(eax); // initial map
273 __ mov(ebx, eax); // store result in ebx
284 __ mov(eax, Operand(esp, 0));
287 __ SmiUntag(eax);
304 __ mov(ecx, eax);
319 ParameterCount actual(eax);
339 __ JumpIfSmi(eax, &use_receiver);
343 __ CmpObjectType(eax, FIRST_JS_RECEIVER_TYPE, ecx);
349 __ mov(eax, Operand(esp, 0));
402 // eax : the number of items to be pushed to the stack
417 __ mov(edx, eax);
454 __ mov(eax, Operand(ebx, EntryFrameConstants::kArgcOffset));
458 // Expects argument count in eax. Clobbers ecx, edx, edi.
470 __ cmp(ecx, eax);
536 __ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
538 FieldOperand(eax, SharedFunctionInfo::kFunctionDataOffset));
544 eax);
568 __ mov(eax, Immediate(masm->isolate()->factory()->undefined_value()));
572 __ push(eax);
617 __ movzx_b(eax, Operand(kInterpreterBytecodeArrayRegister,
619 __ mov(ebx, Operand(ebx, eax, times_pointer_size, 0));
620 // Restore undefined_value in accumulator (eax)
623 __ mov(eax, Immediate(masm->isolate()->factory()->undefined_value()));
676 // -- eax : the number of arguments (not including the receiver)
687 __ mov(ecx, eax);
704 // -- eax : the number of arguments (not including the receiver)
714 __ mov(ecx, eax);
716 __ mov(Operand(esp, ecx, times_pointer_size, -kPointerSize), eax);
717 __ mov(eax, ecx);
723 __ shl(eax, kPointerSizeLog2);
724 __ add(eax, ebx);
729 Generate_InterpreterPushArgs(masm, eax);
732 __ mov(eax, Operand(esp, -kPointerSize));
737 // Call the constructor with unmodified eax, edi, ebi values.
855 __ mov(eax, Operand(esp, 8 * kPointerSize));
861 __ mov(Operand(esp, 0), eax);
888 __ mov(eax, Operand(esp, 8 * kPointerSize));
889 __ sub(eax, Immediate(Assembler::kCallInstructionLength));
895 __ mov(Operand(esp, 0), eax);
903 __ pop(eax); // Pop return address into scratch register.
908 __ push(eax); // Push return address after frame prologue.
978 __ mov(eax, Operand(esp, 2 * kPointerSize));
981 __ ret(2 * kPointerSize); // Remove state, eax.
1011 // 1. Load receiver into eax and check that it's actually a JSDate object.
1014 __ mov(eax, Operand(esp, kPointerSize));
1015 __ JumpIfSmi(eax, &receiver_not_date);
1016 __ CmpObjectType(eax, JS_DATE_TYPE, ebx);
1022 __ mov(eax, FieldOperand(eax, JSDate::kValueOffset));
1028 __ cmp(edx, FieldOperand(eax, JSDate::kCacheStampOffset));
1030 __ mov(eax, FieldOperand(
1031 eax, JSDate::kValueOffset + field_index * kPointerSize));
1037 __ mov(Operand(esp, 0), eax);
1058 // -- eax : argc
1065 // 1. Load receiver into edi, argArray into eax (if present), remove all
1072 __ mov(edi, Operand(esp, eax, times_pointer_size, kPointerSize));
1073 __ test(eax, eax);
1076 __ mov(edx, Operand(esp, eax, times_pointer_size, 0));
1077 __ cmp(eax, Immediate(1));
1079 __ mov(ebx, Operand(esp, eax, times_pointer_size, -kPointerSize));
1084 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1087 __ Move(eax, ebx);
1091 // -- eax : argArray
1106 __ JumpIfRoot(eax, Heap::kNullValueRootIndex, &no_arguments, Label::kNear);
1107 __ JumpIfRoot(eax, Heap::kUndefinedValueRootIndex, &no_arguments,
1119 __ Set(eax, 0);
1142 // eax contains the number of arguments, n, not counting the receiver.
1147 __ test(eax, eax);
1152 __ inc(eax);
1157 __ mov(edi, Operand(esp, eax, times_pointer_size, kPointerSize));
1164 __ mov(ecx, eax);
1171 __ dec(eax); // One fewer argument (first argument is new receiver).
1181 // -- eax : argc
1189 // 1. Load target into edi (if present), argumentsList into eax (if present),
1197 __ cmp(eax, Immediate(1));
1199 __ mov(edi, Operand(esp, eax, times_pointer_size, -0 * kPointerSize));
1201 __ mov(edx, Operand(esp, eax, times_pointer_size, -1 * kPointerSize));
1202 __ cmp(eax, Immediate(3));
1204 __ mov(ebx, Operand(esp, eax, times_pointer_size, -2 * kPointerSize));
1207 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1210 __ Move(eax, ebx);
1214 // -- eax : argumentsList
1243 // -- eax : argc
1251 // 1. Load target into edi (if present), argumentsList into eax (if present),
1260 __ cmp(eax, Immediate(1));
1262 __ mov(edi, Operand(esp, eax, times_pointer_size, -0 * kPointerSize));
1265 __ mov(ebx, Operand(esp, eax, times_pointer_size, -1 * kPointerSize));
1266 __ cmp(eax, Immediate(3));
1268 __ mov(edx, Operand(esp, eax, times_pointer_size, -2 * kPointerSize));
1271 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1274 __ Move(eax, ebx);
1278 // -- eax : argumentsList
1320 // -- eax : argc
1349 // -- eax : argc
1380 // -- eax : number of arguments
1387 // 1. Load the first argument into eax and get rid of the rest (including the
1391 __ test(eax, eax);
1393 __ mov(ebx, Operand(esp, eax, times_pointer_size, 0));
1395 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1397 __ mov(eax, ebx);
1404 // 2b. No arguments, return +0 (already in eax).
1413 // -- eax : number of arguments
1428 __ test(eax, eax);
1430 __ mov(ebx, Operand(esp, eax, times_pointer_size, 0));
1436 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1451 __ Move(eax, ebx);
1454 __ Move(ebx, eax);
1467 __ AllocateJSValue(eax, edi, ebx, ecx, &new_object);
1478 __ Pop(FieldOperand(eax, JSValue::kValueOffset));
1487 // -- eax : number of arguments
1494 // 1. Load the first argument into eax and get rid of the rest (including the
1498 __ test(eax, eax);
1500 __ mov(ebx, Operand(esp, eax, times_pointer_size, 0));
1502 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1504 __ mov(eax, ebx);
1507 // 2a. At least one argument, return eax if it's a string, otherwise
1511 __ JumpIfSmi(eax, &to_string, Label::kNear);
1513 __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, edx);
1522 __ LoadRoot(eax, Heap::kempty_stringRootIndex);
1526 // 3a. Convert eax to a string.
1533 // 3b. Convert symbol in eax to a string.
1537 __ Push(eax);
1547 // -- eax : number of arguments
1562 __ test(eax, eax);
1564 __ mov(ebx, Operand(esp, eax, times_pointer_size, 0));
1570 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1586 __ Move(eax, ebx);
1588 __ Move(ebx, eax);
1601 __ AllocateJSValue(eax, edi, ebx, ecx, &new_object);
1612 __ Pop(FieldOperand(eax, JSValue::kValueOffset));
1621 // -- eax : actual number of arguments
1655 // Preserve the number of arguments on the stack. Must preserve eax,
1659 __ lea(edi, Operand(eax, eax, times_1, kSmiTag));
1682 // -- eax : argumentsList
1692 __ JumpIfSmi(eax, &create_runtime);
1695 __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
1716 __ Push(eax);
1720 __ mov(ebx, FieldOperand(eax, FixedArray::kLengthOffset));
1728 FieldOperand(eax, JSObject::kHeaderSize +
1730 __ mov(ecx, FieldOperand(eax, JSObject::kElementsOffset));
1734 __ mov(eax, ecx);
1748 __ mov(ebx, FieldOperand(eax, JSArray::kLengthOffset));
1750 __ mov(eax, FieldOperand(eax, JSArray::kElementsOffset));
1777 // -- eax : args (a FixedArray built from argumentsList)
1794 FieldOperand(eax, ecx, times_pointer_size, FixedArray::kHeaderSize));
1800 __ Move(eax, ebx);
1816 // -- eax : the number of arguments (not including the receiver)
1843 // -- eax : the number of arguments (not including the receiver)
1854 __ mov(ecx, Operand(esp, eax, times_pointer_size, kPointerSize));
1878 __ SmiTag(eax);
1879 __ Push(eax);
1881 __ mov(eax, ecx);
1884 __ mov(ecx, eax);
1886 __ Pop(eax);
1887 __ SmiUntag(eax);
1892 __ mov(Operand(esp, eax, times_pointer_size, kPointerSize), ecx);
1897 // -- eax : the number of arguments (not including the receiver)
1906 ParameterCount actual(eax);
1924 // -- eax : the number of arguments (not including the receiver)
1938 // -- eax : the number of arguments (not including the receiver)
1966 __ inc(eax);
1977 __ cmp(ecx, eax);
1991 __ movd(Operand(esp, eax, times_pointer_size, 0), xmm0);
1992 __ lea(eax, Operand(eax, 1));
1996 // Adjust effective number of arguments (eax contains the number of
1999 __ dec(eax);
2010 // -- eax : the number of arguments (not including the receiver)
2017 __ mov(Operand(esp, eax, times_pointer_size, kPointerSize), ebx);
2034 // -- eax : the number of arguments (not including the receiver)
2056 __ add(eax, Immediate(2));
2068 __ mov(Operand(esp, eax, times_pointer_size, kPointerSize), edi);
2088 // -- eax : the number of arguments (not including the receiver)
2110 // -- eax : the number of arguments (not including the receiver)
2140 // -- eax : the number of arguments (not including the receiver)
2152 __ add(eax, Immediate(3));
2162 // -- eax : the number of arguments (not including the receiver)
2195 __ mov(Operand(esp, eax, times_pointer_size, kPointerSize), edi);
2212 // -- eax : actual number of arguments
2222 __ cmp(eax, ebx);
2234 __ lea(edi, Operand(ebp, eax, times_4, offset));
2235 __ mov(eax, -1); // account for receiver
2239 __ inc(eax);
2242 __ cmp(eax, ebx);
2244 // eax now contains the expected number of arguments.
2261 __ cmp(eax, ecx);
2279 __ lea(edi, Operand(ebp, eax, times_4, offset));
2281 __ sub(ebx, eax);
2282 // eax = -actual - 1
2283 __ neg(eax);
2284 __ sub(eax, Immediate(1));
2288 __ inc(eax);
2291 __ test(eax, eax);
2297 __ inc(eax);
2299 __ cmp(eax, ebx);
2303 __ mov(eax, ecx);
2310 // eax : expected number of arguments
2407 // -- eax : number of arguments (not including the receiver)
2413 // -- esp[eax * 4] : first argument
2414 // -- esp[(eax + 1) * 4] : receiver
2423 __ mov(ecx, Operand(esp, eax, times_pointer_size, kPCOnStackSize));
2424 __ Push(eax);
2425 CompatibleReceiverCheck(masm, ecx, ebx, edx, eax, &receiver_check_failed);
2426 __ Pop(eax);
2437 __ Pop(eax);
2439 __ lea(eax, Operand(eax, times_pointer_size, 1 * kPointerSize));
2440 __ add(esp, eax);
2451 __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
2455 __ push(eax);
2461 __ cmp(eax, Immediate(0));
2468 __ mov(ebx, Operand(eax, Code::kDeoptimizationDataOffset - kHeapObjectTag));
2476 __ lea(eax, Operand(eax, ebx, times_1, Code::kHeaderSize - kHeapObjectTag));
2479 __ mov(Operand(esp, 0), eax);
