Lines Matching refs:__
18 #define __ ACCESS_MASM(masm)
41 __ pop(scratch); // Save return address.
42 __ push(edi);
43 __ push(scratch); // Restore return address.
50 __ add(eax, Immediate(num_extra_args + 1));
51 __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
59 __ push(edi);
61 __ push(edi);
63 __ CallRuntime(function_id, 1);
65 __ pop(edi);
70 __ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
71 __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kCodeOffset));
72 __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
73 __ jmp(eax);
78 __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
79 __ jmp(eax);
92 __ cmp(esp, Operand::StaticVariable(stack_limit));
93 __ j(above_equal, &ok, Label::kNear);
98 __ bind(&ok);
120 __ AssertUndefinedOrAllocationSite(ebx);
121 __ push(ebx);
125 __ SmiTag(eax);
126 __ push(eax);
129 __ push(edi);
138 __ cmp(Operand::StaticVariable(debug_step_in_fp), Immediate(0));
139 __ j(not_equal, &rt_call);
144 __ mov(eax, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
146 __ JumpIfSmi(eax, &rt_call);
149 __ CmpObjectType(eax, MAP_TYPE, ebx);
150 __ j(not_equal, &rt_call);
157 __ CmpInstanceType(eax, JS_FUNCTION_TYPE);
158 __ j(equal, &rt_call);
167 __ mov(esi, FieldOperand(eax, Map::kBitField3Offset));
168 __ shr(esi, Map::ConstructionCount::kShift);
169 __ j(zero, &allocate); // JSFunction::kNoSlackTracking
171 __ sub(FieldOperand(eax, Map::kBitField3Offset),
174 __ cmp(esi, JSFunction::kFinishSlackTracking);
175 __ j(not_equal, &allocate);
177 __ push(eax);
178 __ push(edi);
180 __ push(edi); // constructor
181 __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
183 __ pop(edi);
184 __ pop(eax);
185 __ xor_(esi, esi); // JSFunction::kNoSlackTracking
187 __ bind(&allocate);
193 __ movzx_b(edi, FieldOperand(eax, Map::kInstanceSizeOffset));
194 __ shl(edi, kPointerSizeLog2);
196 __ add(edi, Immediate(AllocationMemento::kSize));
199 __ Allocate(edi, ebx, edi, no_reg, &rt_call, NO_ALLOCATION_FLAGS);
207 __ mov(Operand(ebx, JSObject::kMapOffset), eax);
208 __ mov(ecx, factory->empty_fixed_array());
209 __ mov(Operand(ebx, JSObject::kPropertiesOffset), ecx);
210 __ mov(Operand(ebx, JSObject::kElementsOffset), ecx);
216 __ mov(edx, factory->undefined_value());
217 __ lea(ecx, Operand(ebx, JSObject::kHeaderSize));
222 __ cmp(esi, JSFunction::kNoSlackTracking);
223 __ j(equal, &no_inobject_slack_tracking);
226 __ movzx_b(esi,
228 __ lea(esi,
232 __ cmp(esi, edi);
233 __ Assert(less_equal,
236 __ InitializeFieldsWithFiller(ecx, esi, edx);
237 __ mov(edx, factory->one_pointer_filler_map());
240 __ bind(&no_inobject_slack_tracking);
244 __ lea(esi, Operand(edi, -AllocationMemento::kSize));
245 __ InitializeFieldsWithFiller(ecx, esi, edx);
249 __ mov(Operand(esi, AllocationMemento::kMapOffset),
252 __ mov(edx, Operand(esp, kPointerSize*2));
253 __ mov(Operand(esi, AllocationMemento::kAllocationSiteOffset),
256 __ InitializeFieldsWithFiller(ecx, edi, edx);
266 __ or_(ebx, Immediate(kHeapObjectTag));
274 __ movzx_b(edx, FieldOperand(eax, Map::kUnusedPropertyFieldsOffset));
275 __ movzx_b(ecx,
277 __ add(edx, ecx);
279 __ movzx_b(ecx, FieldOperand(eax, Map::kInObjectPropertiesOffset));
280 __ sub(edx, ecx);
282 __ j(zero, &allocated);
283 __ Assert(positive, kPropertyAllocationCountFailed);
290 __ Allocate(FixedArray::kHeaderSize,
305 __ mov(eax, factory->fixed_array_map());
306 __ mov(Operand(edi, FixedArray::kMapOffset), eax); // setup the map
307 __ SmiTag(edx);
308 __ mov(Operand(edi, FixedArray::kLengthOffset), edx); // and length
315 __ mov(edx, factory->undefined_value());
316 __ lea(eax, Operand(edi, FixedArray::kHeaderSize));
317 __ jmp(&entry);
318 __ bind(&loop);
319 __ mov(Operand(eax, 0), edx);
320 __ add(eax, Immediate(kPointerSize));
321 __ bind(&entry);
322 __ cmp(eax, ecx);
323 __ j(below, &loop);
330 __ or_(edi, Immediate(kHeapObjectTag)); // add the heap tag
331 __ mov(FieldOperand(ebx, JSObject::kPropertiesOffset), edi);
336 __ jmp(&allocated);
342 __ bind(&undo_allocation);
343 __ UndoAllocationInNewSpace(ebx);
347 __ bind(&rt_call);
351 __ mov(edi, Operand(esp, kPointerSize * 2));
352 __ push(edi);
357 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
358 __ mov(edi, Operand(esp, offset));
360 __ push(edi);
362 __ CallRuntime(Runtime::kNewObjectWithAllocationSite, 2);
364 __ CallRuntime(Runtime::kNewObject, 1);
366 __ mov(ebx, eax); // store result in ebx
373 __ jmp(&count_incremented);
378 __ bind(&allocated);
381 __ mov(ecx, Operand(esp, kPointerSize * 2));
382 __ cmp(ecx, masm->isolate()->factory()->undefined_value());
383 __ j(equal, &count_incremented);
386 __ add(FieldOperand(ecx, AllocationSite::kPretenureCreateCountOffset),
388 __ bind(&count_incremented);
392 __ pop(edi);
395 __ mov(eax, Operand(esp, 0));
396 __ SmiUntag(eax);
401 __ push(ebx);
402 __ push(ebx);
405 __ lea(ebx, Operand(ebp, StandardFrameConstants::kCallerSPOffset));
409 __ mov(ecx, eax);
410 __ jmp(&entry);
411 __ bind(&loop);
412 __ push(Operand(ebx, ecx, times_4, 0));
413 __ bind(&entry);
414 __ dec(ecx);
415 __ j(greater_equal, &loop);
419 __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
422 __ call(code, RelocInfo::CODE_TARGET);
425 __ InvokeFunction(edi, actual, CALL_FUNCTION,
435 __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
443 __ JumpIfSmi(eax, &use_receiver);
447 __ CmpObjectType(eax, FIRST_SPEC_OBJECT_TYPE, ecx);
448 __ j(above_equal, &exit);
452 __ bind(&use_receiver);
453 __ mov(eax, Operand(esp, 0));
456 __ bind(&exit);
457 __ mov(ebx, Operand(esp, kPointerSize)); // Get arguments count.
464 __ pop(ecx);
465 __ lea(esp, Operand(esp, ebx, times_2, 1 * kPointerSize)); // 1 ~ receiver
466 __ push(ecx);
467 __ IncrementCounter(masm->isolate()->counters()->constructed_objects(), 1);
468 __ ret(0);
487 __ Move(esi, Immediate(0));
493 __ mov(ebx, Operand(ebp, 0));
496 __ mov(ecx, Operand(ebx, EntryFrameConstants::kFunctionArgOffset));
497 __ mov(esi, FieldOperand(ecx, JSFunction::kContextOffset));
500 __ push(ecx);
501 __ push(Operand(ebx, EntryFrameConstants::kReceiverArgOffset));
504 __ mov(eax, Operand(ebx, EntryFrameConstants::kArgcOffset));
505 __ mov(ebx, Operand(ebx, EntryFrameConstants::kArgvOffset));
509 __ Move(ecx, Immediate(0));
510 __ jmp(&entry);
511 __ bind(&loop);
512 __ mov(edx, Operand(ebx, ecx, times_4, 0)); // push parameter from argv
513 __ push(Operand(edx, 0)); // dereference handle
514 __ inc(ecx);
515 __ bind(&entry);
516 __ cmp(ecx, eax);
517 __ j(not_equal, &loop);
521 __ mov(edi, Operand(esp, eax, times_4, kPointerSize));
526 __ mov(ebx, masm->isolate()->factory()->undefined_value());
528 __ CallStub(&stub);
531 __ InvokeFunction(edi, actual, CALL_FUNCTION,
539 __ ret(kPointerSize); // Remove receiver.
563 __ push(edi);
565 __ push(edi);
567 __ Push(masm->isolate()->factory()->ToBoolean(concurrent));
569 __ CallRuntime(Runtime::kCompileOptimized, 2);
571 __ pop(edi);
596 __ sub(Operand(esp, 0), Immediate(5));
597 __ pushad();
598 __ mov(eax, Operand(esp, 8 * kPointerSize));
601 __ PrepareCallCFunction(2, ebx);
602 __ mov(Operand(esp, 1 * kPointerSize),
604 __ mov(Operand(esp, 0), eax);
605 __ CallCFunction(
608 __ popad();
609 __ ret(0);
630 __ pushad();
631 __ mov(eax, Operand(esp, 8 * kPointerSize));
632 __ sub(eax, Immediate(Assembler::kCallInstructionLength));
635 __ PrepareCallCFunction(2, ebx);
636 __ mov(Operand(esp, 1 * kPointerSize),
638 __ mov(Operand(esp, 0), eax);
639 __ CallCFunction(
643 __ popad();
646 __ pop(eax); // Pop return address into scratch register.
647 __ push(ebp); // Caller's frame pointer.
648 __ mov(ebp, esp);
649 __ push(esi); // Callee's context.
650 __ push(edi); // Callee's JS Function.
651 __ push(eax); // Push return address after frame prologue.
654 __ ret(0);
672 __ pushad();
673 __ CallRuntime(Runtime::kNotifyStubFailure, 0, save_doubles);
674 __ popad();
678 __ pop(MemOperand(esp, 0)); // Ignore state offset
679 __ ret(0); // Return to IC Miss stub, continuation still on stack.
699 __ push(Immediate(Smi::FromInt(static_cast<int>(type))));
700 __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
706 __ mov(ecx, Operand(esp, 1 * kPointerSize));
707 __ SmiUntag(ecx);
711 __ cmp(ecx, FullCodeGenerator::NO_REGISTERS);
712 __ j(not_equal, ¬_no_registers, Label::kNear);
713 __ ret(1 * kPointerSize); // Remove state.
715 __ bind(¬_no_registers);
716 __ mov(eax, Operand(esp, 2 * kPointerSize));
717 __ cmp(ecx, FullCodeGenerator::TOS_REG);
718 __ j(not_equal, ¬_tos_eax, Label::kNear);
719 __ ret(2 * kPointerSize); // Remove state, eax.
721 __ bind(¬_tos_eax);
722 __ Abort(kNoCasesLeft);
746 __ test(eax, eax);
747 __ j(not_zero, &done);
748 __ pop(ebx);
749 __ push(Immediate(factory->undefined_value()));
750 __ push(ebx);
751 __ inc(eax);
752 __ bind(&done);
759 __ mov(edi, Operand(esp, eax, times_4, 1 * kPointerSize));
760 __ JumpIfSmi(edi, &non_function);
761 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
762 __ j(not_equal, &slow);
767 __ Move(edx, Immediate(0)); // indicate regular JS_FUNCTION
770 __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
773 __ mov(ebx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
774 __ test_b(FieldOperand(ebx, SharedFunctionInfo::kStrictModeByteOffset),
776 __ j(not_equal, &shift_arguments);
779 __ test_b(FieldOperand(ebx, SharedFunctionInfo::kNativeByteOffset),
781 __ j(not_equal, &shift_arguments);
784 __ mov(ebx, Operand(esp, eax, times_4, 0)); // First argument.
788 __ JumpIfSmi(ebx, &convert_to_object);
789 __ cmp(ebx, factory->null_value());
790 __ j(equal, &use_global_proxy);
791 __ cmp(ebx, factory->undefined_value());
792 __ j(equal, &use_global_proxy);
794 __ CmpObjectType(ebx, FIRST_SPEC_OBJECT_TYPE, ecx);
795 __ j(above_equal, &shift_arguments);
797 __ bind(&convert_to_object);
801 __ SmiTag(eax);
802 __ push(eax);
804 __ push(ebx);
805 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
806 __ mov(ebx, eax);
807 __ Move(edx, Immediate(0)); // restore
809 __ pop(eax);
810 __ SmiUntag(eax);
814 __ mov(edi, Operand(esp, eax, times_4, 1 * kPointerSize));
815 __ jmp(&patch_receiver);
817 __ bind(&use_global_proxy);
818 __ mov(ebx,
820 __ mov(ebx, FieldOperand(ebx, GlobalObject::kGlobalProxyOffset));
822 __ bind(&patch_receiver);
823 __ mov(Operand(esp, eax, times_4, 0), ebx);
825 __ jmp(&shift_arguments);
829 __ bind(&slow);
830 __ Move(edx, Immediate(1)); // indicate function proxy
831 __ CmpInstanceType(ecx, JS_FUNCTION_PROXY_TYPE);
832 __ j(equal, &shift_arguments);
833 __ bind(&non_function);
834 __ Move(edx, Immediate(2)); // indicate non-function
840 __ mov(Operand(esp, eax, times_4, 0), edi);
845 __ bind(&shift_arguments);
847 __ mov(ecx, eax);
848 __ bind(&loop);
849 __ mov(ebx, Operand(esp, ecx, times_4, 0));
850 __ mov(Operand(esp, ecx, times_4, kPointerSize), ebx);
851 __ dec(ecx);
852 __ j(not_sign, &loop); // While non-negative (to copy return address).
853 __ pop(ebx); // Discard copy of return address.
854 __ dec(eax); // One fewer argument (first argument is new receiver).
860 __ test(edx, edx);
861 __ j(zero, &function);
862 __ Move(ebx, Immediate(0));
863 __ cmp(edx, Immediate(1));
864 __ j(not_equal, &non_proxy);
866 __ pop(edx); // return address
867 __ push(edi); // re-add proxy object as additional argument
868 __ push(edx);
869 __ inc(eax);
870 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY);
871 __ jmp(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
874 __ bind(&non_proxy);
875 __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
876 __ jmp(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
878 __ bind(&function);
884 __ mov(edx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
885 __ mov(ebx,
887 __ mov(edx, FieldOperand(edi, JSFunction::kCodeEntryOffset));
888 __ SmiUntag(ebx);
889 __ cmp(eax, ebx);
890 __ j(not_equal,
894 __ InvokeCode(edx, expected, expected, JUMP_FUNCTION, NullCallWrapper());
905 __ push(Operand(ebp, kFunctionOffset)); // push this
906 __ push(Operand(ebp, kArgumentsOffset)); // push arguments
907 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
915 __ mov(edi, Operand::StaticVariable(real_stack_limit));
918 __ mov(ecx, esp);
919 __ sub(ecx, edi);
922 __ mov(edx, eax);
923 __ shl(edx, kPointerSizeLog2 - kSmiTagSize);
925 __ cmp(ecx, edx);
926 __ j(greater, &okay); // Signed comparison.
929 __ push(Operand(ebp, 4 * kPointerSize)); // push this
930 __ push(eax);
931 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
932 __ bind(&okay);
939 __ push(eax); // limit
940 __ push(Immediate(0)); // index
943 __ mov(ebx, Operand(ebp, kReceiverOffset));
947 __ mov(edi, Operand(ebp, kFunctionOffset));
948 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
949 __ j(not_equal, &push_receiver);
952 __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));
957 __ mov(ecx, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
958 __ test_b(FieldOperand(ecx, SharedFunctionInfo::kStrictModeByteOffset),
960 __ j(not_equal, &push_receiver);
965 __ test_b(FieldOperand(ecx, SharedFunctionInfo::kNativeByteOffset),
967 __ j(not_equal, &push_receiver);
972 __ JumpIfSmi(ebx, &call_to_object);
973 __ cmp(ebx, factory->null_value());
974 __ j(equal, &use_global_proxy);
975 __ cmp(ebx, factory->undefined_value());
976 __ j(equal, &use_global_proxy);
978 __ CmpObjectType(ebx, FIRST_SPEC_OBJECT_TYPE, ecx);
979 __ j(above_equal, &push_receiver);
981 __ bind(&call_to_object);
982 __ push(ebx);
983 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
984 __ mov(ebx, eax);
985 __ jmp(&push_receiver);
987 __ bind(&use_global_proxy);
988 __ mov(ebx,
990 __ mov(ebx, FieldOperand(ebx, GlobalObject::kGlobalProxyOffset));
993 __ bind(&push_receiver);
994 __ push(ebx);
1000 __ mov(key, Operand(ebp, kIndexOffset));
1001 __ jmp(&entry);
1002 __ bind(&loop);
1003 __ mov(receiver, Operand(ebp, kArgumentsOffset)); // load arguments
1007 __ mov(VectorLoadICDescriptor::SlotRegister(),
1011 __ call(ic, RelocInfo::CODE_TARGET);
1018 __ push(eax);
1021 __ mov(key, Operand(ebp, kIndexOffset));
1022 __ add(key, Immediate(1 << kSmiTagSize));
1023 __ mov(Operand(ebp, kIndexOffset), key);
1025 __ bind(&entry);
1026 __ cmp(key, Operand(ebp, kLimitOffset));
1027 __ j(not_equal, &loop);
1032 __ Move(eax, key);
1033 __ SmiUntag(eax);
1034 __ mov(edi, Operand(ebp, kFunctionOffset));
1035 __ CmpObjectType(edi, JS_FUNCTION_TYPE, ecx);
1036 __ j(not_equal, &call_proxy);
1037 __ InvokeFunction(edi, actual, CALL_FUNCTION, NullCallWrapper());
1040 __ ret(3 * kPointerSize); // remove this, receiver, and arguments
1043 __ bind(&call_proxy);
1044 __ push(edi); // add function proxy as last argument
1045 __ inc(eax);
1046 __ Move(ebx, Immediate(0));
1047 __ GetBuiltinEntry(edx, Builtins::CALL_FUNCTION_PROXY);
1048 __ call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1053 __ ret(3 * kPointerSize); // remove this, receiver, and arguments
1066 __ LoadGlobalFunction(Context::INTERNAL_ARRAY_FUNCTION_INDEX, edi);
1070 __ mov(ebx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
1072 __ test(ebx, Immediate(kSmiTagMask));
1073 __ Assert(not_zero, kUnexpectedInitialMapForInternalArrayFunction);
1074 __ CmpObjectType(ebx, MAP_TYPE, ecx);
1075 __ Assert(equal, kUnexpectedInitialMapForInternalArrayFunction);
1082 __ TailCallStub(&stub);
1095 __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, edi);
1099 __ mov(ebx, FieldOperand(edi, JSFunction::kPrototypeOrInitialMapOffset));
1101 __ test(ebx, Immediate(kSmiTagMask));
1102 __ Assert(not_zero, kUnexpectedInitialMapForArrayFunction);
1103 __ CmpObjectType(ebx, MAP_TYPE, ecx);
1104 __ Assert(equal, kUnexpectedInitialMapForArrayFunction);
1109 __ mov(ebx, masm->isolate()->factory()->undefined_value());
1111 __ TailCallStub(&stub);
1124 __ IncrementCounter(counters->string_ctor_calls(), 1);
1127 __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, ecx);
1128 __ cmp(edi, ecx);
1129 __ Assert(equal, kUnexpectedStringFunction);
1135 __ test(eax, eax);
1136 __ j(zero, &no_arguments);
1137 __ mov(ebx, Operand(esp, eax, times_pointer_size, 0));
1138 __ pop(ecx);
1139 __ lea(esp, Operand(esp, eax, times_pointer_size, kPointerSize));
1140 __ push(ecx);
1141 __ mov(eax, ebx);
1145 __ LookupNumberStringCache(eax, // Input.
1150 __ IncrementCounter(counters->string_ctor_cached_number(), 1);
1151 __ bind(&argument_is_string);
1160 __ Allocate(JSValue::kSize,
1168 __ LoadGlobalFunctionInitialMap(edi, ecx);
1170 __ cmpb(FieldOperand(ecx, Map::kInstanceSizeOffset),
1172 __ Assert(equal, kUnexpectedStringWrapperInstanceSize);
1173 __ cmpb(FieldOperand(ecx, Map::kUnusedPropertyFieldsOffset), 0);
1174 __ Assert(equal, kUnexpectedUnusedPropertiesOfStringWrapper);
1176 __ mov(FieldOperand(eax, HeapObject::kMapOffset), ecx);
1180 __ Move(ecx, Immediate(factory->empty_fixed_array()));
1181 __ mov(FieldOperand(eax, JSObject::kPropertiesOffset), ecx);
1182 __ mov(FieldOperand(eax, JSObject::kElementsOffset), ecx);
1185 __ mov(FieldOperand(eax, JSValue::kValueOffset), ebx);
1191 __ ret(0);
1196 __ bind(¬_cached);
1198 __ JumpIfSmi(eax, &convert_argument);
1200 __ j(NegateCondition(is_string), &convert_argument);
1201 __ mov(ebx, eax);
1202 __ IncrementCounter(counters->string_ctor_string_value(), 1);
1203 __ jmp(&argument_is_string);
1206 __ bind(&convert_argument);
1207 __ IncrementCounter(counters->string_ctor_conversions(), 1);
1210 __ push(edi); // Preserve the function.
1211 __ push(eax);
1212 __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
1213 __ pop(edi);
1215 __ mov(ebx, eax);
1216 __ jmp(&argument_is_string);
1220 __ bind(&no_arguments);
1221 __ Move(ebx, Immediate(factory->empty_string()));
1222 __ pop(ecx);
1223 __ lea(esp, Operand(esp, kPointerSize));
1224 __ push(ecx);
1225 __ jmp(&argument_is_string);
1229 __ bind(&gc_required);
1230 __ IncrementCounter(counters->string_ctor_gc_required(), 1);
1233 __ push(ebx);
1234 __ CallRuntime(Runtime::kNewStringWrapper, 1);
1236 __ ret(0);
1252 __ mov(edx, Operand::StaticVariable(real_stack_limit));
1255 __ mov(ecx, esp);
1256 __ sub(ecx, edx);
1259 __ mov(edx, ebx);
1260 __ shl(edx, kPointerSizeLog2);
1262 __ cmp(ecx, edx);
1263 __ j(less_equal, stack_overflow); // Signed comparison.
1268 __ push(ebp);
1269 __ mov(ebp, esp);
1272 __ push(Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1275 __ push(edi);
1281 __ lea(edi, Operand(eax, eax, times_1, kSmiTag));
1282 __ push(edi);
1288 __ mov(ebx, Operand(ebp, ArgumentsAdaptorFrameConstants::kLengthOffset));
1291 __ leave();
1295 __ pop(ecx);
1296 __ lea(esp, Operand(esp, ebx, times_2, 1 * kPointerSize)); // 1 ~ receiver
1297 __ push(ecx);
1309 __ IncrementCounter(masm->isolate()->counters()->arguments_adaptors(), 1);
1315 __ mov(edx, FieldOperand(edi, JSFunction::kCodeEntryOffset));
1316 __ cmp(eax, ebx);
1317 __ j(less, &too_few);
1318 __ cmp(ebx, SharedFunctionInfo::kDontAdaptArgumentsSentinel);
1319 __ j(equal, &dont_adapt_arguments);
1322 __ bind(&enough);
1327 __ lea(eax, Operand(ebp, eax, times_4, offset));
1328 __ mov(edi, -1); // account for receiver
1331 __ bind(©);
1332 __ inc(edi);
1333 __ push(Operand(eax, 0));
1334 __ sub(eax, Immediate(kPointerSize));
1335 __ cmp(edi, ebx);
1336 __ j(less, ©);
1337 __ jmp(&invoke);
1341 __ bind(&too_few);
1346 __ lea(edi, Operand(ebp, eax, times_4, offset));
1348 __ sub(ebx, eax);
1350 __ neg(eax);
1351 __ sub(eax, Immediate(1));
1354 __ bind(©);
1355 __ inc(eax);
1356 __ push(Operand(edi, 0));
1357 __ sub(edi, Immediate(kPointerSize));
1358 __ test(eax, eax);
1359 __ j(not_zero, ©);
1363 __ bind(&fill);
1364 __ inc(eax);
1365 __ push(Immediate(masm->isolate()->factory()->undefined_value()));
1366 __ cmp(eax, ebx);
1367 __ j(less, &fill);
1371 __ bind(&invoke);
1373 __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
1374 __ call(edx);
1381 __ ret(0);
1386 __ bind(&dont_adapt_arguments);
1387 __ jmp(edx);
1389 __ bind(&stack_overflow);
1393 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
1394 __ int3();
1401 __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
1405 __ push(eax);
1406 __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
1411 __ cmp(eax, Immediate(0));
1412 __ j(not_equal, &skip, Label::kNear);
1413 __ ret(0);
1415 __ bind(&skip);
1418 __ mov(ebx, Operand(eax, Code::kDeoptimizationDataOffset - kHeapObjectTag));
1421 __ mov(ebx, Operand(ebx, FixedArray::OffsetOfElementAt(
1423 __ SmiUntag(ebx);
1426 __ lea(eax, Operand(eax, ebx, times_1, Code::kHeaderSize - kHeapObjectTag));
1429 __ mov(Operand(esp, 0), eax);
1432 __ ret(0);
1441 __ cmp(esp, Operand::StaticVariable(stack_limit));
1442 __ j(above_equal, &ok, Label::kNear);
1445 __ CallRuntime(Runtime::kStackGuard, 0);
1447 __ jmp(masm->isolate()->builtins()->OnStackReplacement(),
1450 __ bind(&ok);
1451 __ ret(0);
1454 #undef __