Lines Matching refs:__
19 #define __ ACCESS_MASM(masm)
40 __ push(r1);
47 __ add(r0, r0, Operand(num_extra_args + 1));
48 __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
57 __ ldr(result,
59 __ ldr(result,
62 __ ldr(result,
73 __ ldr(result,
75 __ ldr(result,
78 __ ldr(result,
97 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset));
98 __ SmiTst(r2);
99 __ Assert(ne, kUnexpectedInitialMapForInternalArrayFunction);
100 __ CompareObjectType(r2, r3, r4, MAP_TYPE);
101 __ Assert(eq, kUnexpectedInitialMapForInternalArrayFunction);
108 __ TailCallStub(&stub);
125 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset));
126 __ SmiTst(r2);
127 __ Assert(ne, kUnexpectedInitialMapForArrayFunction);
128 __ CompareObjectType(r2, r3, r4, MAP_TYPE);
129 __ Assert(eq, kUnexpectedInitialMapForArrayFunction);
134 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
136 __ TailCallStub(&stub);
149 __ IncrementCounter(counters->string_ctor_calls(), 1, r2, r3);
153 __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, r2);
154 __ cmp(function, Operand(r2));
155 __ Assert(eq, kUnexpectedStringFunction);
160 __ cmp(r0, Operand::Zero());
161 __ b(eq, &no_arguments);
163 __ sub(r0, r0, Operand(1));
164 __ ldr(r0, MemOperand(sp, r0, LSL, kPointerSizeLog2, PreIndex));
166 __ Drop(2);
170 __ LookupNumberStringCache(r0, // Input.
176 __ IncrementCounter(counters->string_ctor_cached_number(), 1, r3, r4);
177 __ bind(&argument_is_string);
186 __ Allocate(JSValue::kSize,
195 __ LoadGlobalFunctionInitialMap(function, map, r4);
197 __ ldrb(r4, FieldMemOperand(map, Map::kInstanceSizeOffset));
198 __ cmp(r4, Operand(JSValue::kSize >> kPointerSizeLog2));
199 __ Assert(eq, kUnexpectedStringWrapperInstanceSize);
200 __ ldrb(r4, FieldMemOperand(map, Map::kUnusedPropertyFieldsOffset));
201 __ cmp(r4, Operand::Zero());
202 __ Assert(eq, kUnexpectedUnusedPropertiesOfStringWrapper);
204 __ str(map, FieldMemOperand(r0, HeapObject::kMapOffset));
206 __ LoadRoot(r3, Heap::kEmptyFixedArrayRootIndex);
207 __ str(r3, FieldMemOperand(r0, JSObject::kPropertiesOffset));
208 __ str(r3, FieldMemOperand(r0, JSObject::kElementsOffset));
210 __ str(argument, FieldMemOperand(r0, JSValue::kValueOffset));
215 __ Ret();
220 __ bind(¬_cached);
221 __ JumpIfSmi(r0, &convert_argument);
224 __ ldr(r2, FieldMemOperand(r0, HeapObject::kMapOffset));
225 __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceTypeOffset));
227 __ tst(r3, Operand(kIsNotStringMask));
228 __ b(ne, &convert_argument);
229 __ mov(argument, r0);
230 __ IncrementCounter(counters->string_ctor_conversions(), 1, r3, r4);
231 __ b(&argument_is_string);
234 __ bind(&convert_argument);
235 __ push(function); // Preserve the function.
236 __ IncrementCounter(counters->string_ctor_conversions(), 1, r3, r4);
239 __ push(r0);
240 __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
242 __ pop(function);
243 __ mov(argument, r0);
244 __ b(&argument_is_string);
248 __ bind(&no_arguments);
249 __ LoadRoot(argument, Heap::kempty_stringRootIndex);
250 __ Drop(1);
251 __ b(&argument_is_string);
255 __ bind(&gc_required);
256 __ IncrementCounter(counters->string_ctor_gc_required(), 1, r3, r4);
259 __ push(argument);
260 __ CallRuntime(Runtime::kNewStringWrapper, 1);
262 __ Ret();
270 __ push(r1);
272 __ Push(r1);
274 __ CallRuntime(function_id, 1);
276 __ pop(r1);
281 __ ldr(r2, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
282 __ ldr(r2, FieldMemOperand(r2, SharedFunctionInfo::kCodeOffset));
283 __ add(r2, r2, Operand(Code::kHeaderSize - kHeapObjectTag));
284 __ Jump(r2);
289 __ add(r0, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
290 __ Jump(r0);
301 __ LoadRoot(ip, Heap::kStackLimitRootIndex);
302 __ cmp(sp, Operand(ip));
303 __ b(hs, &ok);
308 __ bind(&ok);
334 __ AssertUndefinedOrAllocationSite(r2, r3);
335 __ push(r2);
339 __ SmiTag(r0);
340 __ push(r0); // Smi-tagged arguments count.
341 __ push(r1); // Constructor function.
350 __ mov(r2, Operand(debug_step_in_fp));
351 __ ldr(r2, MemOperand(r2));
352 __ tst(r2, r2);
353 __ b(ne, &rt_call);
357 __ ldr(r2, FieldMemOperand(r1, JSFunction::kPrototypeOrInitialMapOffset));
358 __ JumpIfSmi(r2, &rt_call);
359 __ CompareObjectType(r2, r3, r4, MAP_TYPE);
360 __ b(ne, &rt_call);
367 __ CompareInstanceType(r2, r3, JS_FUNCTION_TYPE);
368 __ b(eq, &rt_call);
374 __ ldr(r4, bit_field3);
375 __ DecodeField<Map::ConstructionCount>(r3, r4);
376 __ cmp(r3, Operand(JSFunction::kNoSlackTracking));
377 __ b(eq, &allocate);
379 __ sub(r4, r4, Operand(1 << Map::ConstructionCount::kShift));
380 __ str(r4, bit_field3);
381 __ cmp(r3, Operand(JSFunction::kFinishSlackTracking));
382 __ b(ne, &allocate);
384 __ push(r1);
386 __ Push(r2, r1); // r1 = constructor
387 __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
389 __ pop(r2);
390 __ pop(r1);
392 __ bind(&allocate);
398 __ ldrb(r3, FieldMemOperand(r2, Map::kInstanceSizeOffset));
400 __ add(r3, r3, Operand(AllocationMemento::kSize / kPointerSize));
403 __ Allocate(r3, r4, r5, r6, &rt_call, SIZE_IN_WORDS);
411 __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
412 __ mov(r5, r4);
414 __ str(r2, MemOperand(r5, kPointerSize, PostIndex));
416 __ str(r6, MemOperand(r5, kPointerSize, PostIndex));
418 __ str(r6, MemOperand(r5, kPointerSize, PostIndex));
427 __ LoadRoot(r6, Heap::kUndefinedValueRootIndex);
433 __ ldr(ip, FieldMemOperand(r2, Map::kBitField3Offset));
434 __ DecodeField<Map::ConstructionCount>(ip);
435 __ cmp(ip, Operand(JSFunction::kNoSlackTracking));
436 __ b(eq, &no_inobject_slack_tracking);
439 __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset));
440 __ Ubfx(r0, r0, Map::kPreAllocatedPropertyFieldsByte * kBitsPerByte,
442 __ add(r0, r5, Operand(r0, LSL, kPointerSizeLog2));
445 __ add(ip, r4, Operand(r3, LSL, kPointerSizeLog2)); // End of object.
446 __ cmp(r0, ip);
447 __ Assert(le, kUnexpectedNumberOfPreAllocatedPropertyFields);
449 __ InitializeFieldsWithFiller(r5, r0, r6);
451 __ LoadRoot(r6, Heap::kOnePointerFillerMapRootIndex);
454 __ bind(&no_inobject_slack_tracking);
458 __ sub(ip, r3, Operand(AllocationMemento::kSize / kPointerSize));
459 __ add(r0, r4, Operand(ip, LSL, kPointerSizeLog2)); // End of object.
460 __ InitializeFieldsWithFiller(r5, r0, r6);
464 __ LoadRoot(r6, Heap::kAllocationMementoMapRootIndex);
466 __ str(r6, MemOperand(r5, kPointerSize, PostIndex));
468 __ ldr(r6, MemOperand(sp, 2 * kPointerSize));
470 __ str(r6, MemOperand(r5, kPointerSize, PostIndex));
472 __ add(r0, r4, Operand(r3, LSL, kPointerSizeLog2)); // End of object.
473 __ InitializeFieldsWithFiller(r5, r0, r6);
480 __ add(r4, r4, Operand(kHeapObjectTag));
487 __ ldrb(r3, FieldMemOperand(r2, Map::kUnusedPropertyFieldsOffset));
490 __ ldr(r0, FieldMemOperand(r2, Map::kInstanceSizesOffset));
491 __ Ubfx(r6, r0, Map::kPreAllocatedPropertyFieldsByte * kBitsPerByte,
493 __ add(r3, r3, Operand(r6));
494 __ Ubfx(r6, r0, Map::kInObjectPropertiesByte * kBitsPerByte,
496 __ sub(r3, r3, Operand(r6), SetCC);
499 __ b(eq, &allocated);
500 __ Assert(pl, kPropertyAllocationCountFailed);
508 __ add(r0, r3, Operand(FixedArray::kHeaderSize / kPointerSize));
509 __ Allocate(
522 __ LoadRoot(r6, Heap::kFixedArrayMapRootIndex);
523 __ mov(r2, r5);
525 __ str(r6, MemOperand(r2, kPointerSize, PostIndex));
527 __ SmiTag(r0, r3);
528 __ str(r0, MemOperand(r2, kPointerSize, PostIndex));
536 __ add(r6, r2, Operand(r3, LSL, kPointerSizeLog2)); // End of object.
539 __ LoadRoot(r0, Heap::kUndefinedValueRootIndex);
540 __ b(&entry);
541 __ bind(&loop);
542 __ str(r0, MemOperand(r2, kPointerSize, PostIndex));
543 __ bind(&entry);
544 __ cmp(r2, r6);
545 __ b(lt, &loop);
553 __ add(r5, r5, Operand(kHeapObjectTag)); // Add the heap tag.
554 __ str(r5, FieldMemOperand(r4, JSObject::kPropertiesOffset));
559 __ jmp(&allocated);
565 __ bind(&undo_allocation);
566 __ UndoAllocationInNewSpace(r4, r5);
571 __ bind(&rt_call);
574 __ ldr(r2, MemOperand(sp, 2 * kPointerSize));
575 __ push(r2);
578 __ push(r1); // argument for Runtime_NewObject
580 __ CallRuntime(Runtime::kNewObjectWithAllocationSite, 2);
582 __ CallRuntime(Runtime::kNewObject, 1);
584 __ mov(r4, r0);
591 __ jmp(&count_incremented);
596 __ bind(&allocated);
599 __ ldr(r2, MemOperand(sp, kPointerSize * 2));
600 __ LoadRoot(r5, Heap::kUndefinedValueRootIndex);
601 __ cmp(r2, r5);
602 __ b(eq, &count_incremented);
605 __ ldr(r3, FieldMemOperand(r2,
607 __ add(r3, r3, Operand(Smi::FromInt(1)));
608 __ str(r3, FieldMemOperand(r2,
610 __ bind(&count_incremented);
613 __ push(r4);
614 __ push(r4);
621 __ ldr(r1, MemOperand(sp, 2 * kPointerSize));
622 __ ldr(r3, MemOperand(sp, 3 * kPointerSize));
625 __ add(r2, fp, Operand(StandardFrameConstants::kCallerSPOffset));
628 __ SmiUntag(r0, r3);
640 __ b(&entry);
641 __ bind(&loop);
642 __ ldr(ip, MemOperand(r2, r3, LSL, kPointerSizeLog2 - 1));
643 __ push(ip);
644 __ bind(&entry);
645 __ sub(r3, r3, Operand(2), SetCC);
646 __ b(ge, &loop);
652 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset));
655 __ Call(code, RelocInfo::CODE_TARGET);
658 __ InvokeFunction(r1, actual, CALL_FUNCTION, NullCallWrapper());
671 __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
683 __ JumpIfSmi(r0, &use_receiver);
687 __ CompareObjectType(r0, r1, r3, FIRST_SPEC_OBJECT_TYPE);
688 __ b(ge, &exit);
692 __ bind(&use_receiver);
693 __ ldr(r0, MemOperand(sp));
697 __ bind(&exit);
702 __ ldr(r1, MemOperand(sp, 2 * kPointerSize));
707 __ add(sp, sp, Operand(r1, LSL, kPointerSizeLog2 - 1));
708 __ add(sp, sp, Operand(kPointerSize));
709 __ IncrementCounter(isolate->counters()->constructed_objects(), 1, r1, r2);
710 __ Jump(lr);
736 __ mov(cp, Operand::Zero());
743 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset));
745 __ InitializeRootRegister();
748 __ push(r1);
749 __ push(r2);
756 __ add(r2, r4, Operand(r3, LSL, kPointerSizeLog2));
758 __ b(&entry);
759 __ bind(&loop);
760 __ ldr(r0, MemOperand(r4, kPointerSize, PostIndex)); // read next parameter
761 __ ldr(r0, MemOperand(r0)); // dereference handle
762 __ push(r0); // push parameter
763 __ bind(&entry);
764 __ cmp(r4, r2);
765 __ b(ne, &loop);
769 __ LoadRoot(r4, Heap::kUndefinedValueRootIndex);
770 __ mov(r5, Operand(r4));
771 __ mov(r6, Operand(r4));
773 __ mov(r8, Operand(r4));
776 __ mov(r9, Operand(r4));
780 __ mov(r0, Operand(r3));
783 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
785 __ CallStub(&stub);
788 __ InvokeFunction(r1, actual, CALL_FUNCTION, NullCallWrapper());
794 __ Jump(lr);
819 __ push(r1);
821 __ Push(r1);
823 __ Push(masm->isolate()->factory()->ToBoolean(concurrent));
825 __ CallRuntime(Runtime::kCompileOptimized, 2);
827 __ pop(r1);
855 __ stm(db_w, sp, r0.bit() | r1.bit() | fp.bit() | lr.bit());
856 __ PrepareCallCFunction(2, 0, r2);
857 __ mov(r1, Operand(ExternalReference::isolate_address(masm->isolate())));
858 __ CallCFunction(
860 __ ldm(ia_w, sp, r0.bit() | r1.bit() | fp.bit() | lr.bit());
861 __ mov(pc, r0);
888 __ stm(db_w, sp, r0.bit() | r1.bit() | fp.bit() | lr.bit());
889 __ PrepareCallCFunction(2, 0, r2);
890 __ mov(r1, Operand(ExternalReference::isolate_address(masm->isolate())));
891 __ CallCFunction(ExternalReference::get_mark_code_as_executed_function(
893 __ ldm(ia_w, sp, r0.bit() | r1.bit() | fp.bit() | lr.bit());
896 __ PushFixedFrame(r1);
897 __ add(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
900 __ add(r0, r0, Operand(kNoCodeAgeSequenceLength));
901 __ mov(pc, r0);
918 __ stm(db_w, sp, kJSCallerSaved | kCalleeSaved);
920 __ CallRuntime(Runtime::kNotifyStubFailure, 0, save_doubles);
921 __ ldm(ia_w, sp, kJSCallerSaved | kCalleeSaved);
924 __ add(sp, sp, Operand(kPointerSize)); // Ignore state
925 __ mov(pc, lr); // Jump to miss handler
944 __ mov(r0, Operand(Smi::FromInt(static_cast<int>(type))));
945 __ push(r0);
946 __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
950 __ ldr(r6, MemOperand(sp, 0 * kPointerSize));
951 __ SmiUntag(r6);
954 __ cmp(r6, Operand(FullCodeGenerator::NO_REGISTERS));
955 __ b(ne, &with_tos_register);
956 __ add(sp, sp, Operand(1 * kPointerSize)); // Remove state.
957 __ Ret();
959 __ bind(&with_tos_register);
960 __ ldr(r0, MemOperand(sp, 1 * kPointerSize));
961 __ cmp(r6, Operand(FullCodeGenerator::TOS_REG));
962 __ b(ne, &unknown_state);
963 __ add(sp, sp, Operand(2 * kPointerSize)); // Remove state.
964 __ Ret();
966 __ bind(&unknown_state);
967 __ stop("no cases left");
988 __ ldr(r0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
992 __ push(r0);
993 __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
998 __ cmp(r0, Operand(Smi::FromInt(0)));
999 __ b(ne, &skip);
1000 __ Ret();
1002 __ bind(&skip);
1006 __ ldr(r1, FieldMemOperand(r0, Code::kDeoptimizationDataOffset));
1010 __ ldr(pp, FieldMemOperand(r0, Code::kConstantPoolOffset));
1015 __ ldr(r1, FieldMemOperand(r1, FixedArray::OffsetOfElementAt(
1020 __ add(r0, r0, Operand::SmiUntag(r1));
1021 __ add(lr, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
1024 __ Ret();
1032 __ LoadRoot(ip, Heap::kStackLimitRootIndex);
1033 __ cmp(sp, Operand(ip));
1034 __ b(hs, &ok);
1037 __ CallRuntime(Runtime::kStackGuard, 0);
1039 __ Jump(masm->isolate()->builtins()->OnStackReplacement(),
1042 __ bind(&ok);
1043 __ Ret();
1051 __ cmp(r0, Operand::Zero());
1052 __ b(ne, &done);
1053 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
1054 __ push(r2);
1055 __ add(r0, r0, Operand(1));
1056 __ bind(&done);
1063 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2));
1064 __ JumpIfSmi(r1, &non_function);
1065 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE);
1066 __ b(ne, &slow);
1072 __ mov(r4, Operand::Zero()); // indicate regular JS_FUNCTION
1075 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset));
1078 __ ldr(r2, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
1079 __ ldr(r3, FieldMemOperand(r2, SharedFunctionInfo::kCompilerHintsOffset));
1080 __ tst(r3, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1082 __ b(ne, &shift_arguments);
1085 __ tst(r3, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1086 __ b(ne, &shift_arguments);
1089 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2));
1090 __ ldr(r2, MemOperand(r2, -kPointerSize));
1094 __ JumpIfSmi(r2, &convert_to_object);
1096 __ LoadRoot(r3, Heap::kUndefinedValueRootIndex);
1097 __ cmp(r2, r3);
1098 __ b(eq, &use_global_proxy);
1099 __ LoadRoot(r3, Heap::kNullValueRootIndex);
1100 __ cmp(r2, r3);
1101 __ b(eq, &use_global_proxy);
1104 __ CompareObjectType(r2, r3, r3, FIRST_SPEC_OBJECT_TYPE);
1105 __ b(ge, &shift_arguments);
1107 __ bind(&convert_to_object);
1112 __ SmiTag(r0);
1113 __ push(r0);
1115 __ push(r2);
1116 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1117 __ mov(r2, r0);
1119 __ pop(r0);
1120 __ SmiUntag(r0);
1126 __ ldr(r1, MemOperand(sp, r0, LSL, kPointerSizeLog2));
1127 __ mov(r4, Operand::Zero());
1128 __ jmp(&patch_receiver);
1130 __ bind(&use_global_proxy);
1131 __ ldr(r2, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
1132 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalProxyOffset));
1134 __ bind(&patch_receiver);
1135 __ add(r3, sp, Operand(r0, LSL, kPointerSizeLog2));
1136 __ str(r2, MemOperand(r3, -kPointerSize));
1138 __ jmp(&shift_arguments);
1142 __ bind(&slow);
1143 __ mov(r4, Operand(1, RelocInfo::NONE32)); // indicate function proxy
1144 __ cmp(r2, Operand(JS_FUNCTION_PROXY_TYPE));
1145 __ b(eq, &shift_arguments);
1146 __ bind(&non_function);
1147 __ mov(r4, Operand(2, RelocInfo::NONE32)); // indicate non-function
1156 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2));
1157 __ str(r1, MemOperand(r2, -kPointerSize));
1165 __ bind(&shift_arguments);
1168 __ add(r2, sp, Operand(r0, LSL, kPointerSizeLog2));
1170 __ bind(&loop);
1171 __ ldr(ip, MemOperand(r2, -kPointerSize));
1172 __ str(ip, MemOperand(r2));
1173 __ sub(r2, r2, Operand(kPointerSize));
1174 __ cmp(r2, sp);
1175 __ b(ne, &loop);
1178 __ sub(r0, r0, Operand(1));
1179 __ pop();
1188 __ tst(r4, r4);
1189 __ b(eq, &function);
1191 __ mov(r2, Operand::Zero());
1192 __ cmp(r4, Operand(1));
1193 __ b(ne, &non_proxy);
1195 __ push(r1); // re-add proxy object as additional argument
1196 __ add(r0, r0, Operand(1));
1197 __ GetBuiltinFunction(r1, Builtins::CALL_FUNCTION_PROXY);
1198 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1201 __ bind(&non_proxy);
1202 __ GetBuiltinFunction(r1, Builtins::CALL_NON_FUNCTION);
1203 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1205 __ bind(&function);
1213 __ ldr(r3, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
1214 __ ldr(r2,
1216 __ SmiUntag(r2);
1217 __ cmp(r2, r0); // Check formal and actual parameter counts.
1218 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1222 __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeEntryOffset));
1224 __ InvokeCode(r3, expected, expected, JUMP_FUNCTION, NullCallWrapper());
1240 __ ldr(r0, MemOperand(fp, kFunctionOffset)); // get the function
1241 __ push(r0);
1242 __ ldr(r0, MemOperand(fp, kArgsOffset)); // get the args array
1243 __ push(r0);
1244 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
1250 __ LoadRoot(r2, Heap::kRealStackLimitRootIndex);
1253 __ sub(r2, sp, r2);
1255 __ cmp(r2, Operand::PointerOffsetFromSmiKey(r0));
1256 __ b(gt, &okay); // Signed comparison.
1259 __ ldr(r1, MemOperand(fp, kFunctionOffset));
1260 __ Push(r1, r0);
1261 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
1265 __ bind(&okay);
1266 __ push(r0); // limit
1267 __ mov(r1, Operand::Zero()); // initial index
1268 __ push(r1);
1271 __ ldr(r0, MemOperand(fp, kRecvOffset));
1275 __ ldr(r1, MemOperand(fp, kFunctionOffset));
1276 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE);
1277 __ b(ne, &push_receiver);
1280 __ ldr(cp, FieldMemOperand(r1, JSFunction::kContextOffset));
1282 __ ldr(r2, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
1287 __ ldr(r2, FieldMemOperand(r2, SharedFunctionInfo::kCompilerHintsOffset));
1288 __ tst(r2, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1290 __ b(ne, &push_receiver);
1293 __ tst(r2, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1294 __ b(ne, &push_receiver);
1297 __ JumpIfSmi(r0, &call_to_object);
1298 __ LoadRoot(r1, Heap::kNullValueRootIndex);
1299 __ cmp(r0, r1);
1300 __ b(eq, &use_global_proxy);
1301 __ LoadRoot(r1, Heap::kUndefinedValueRootIndex);
1302 __ cmp(r0, r1);
1303 __ b(eq, &use_global_proxy);
1308 __ CompareObjectType(r0, r1, r1, FIRST_SPEC_OBJECT_TYPE);
1309 __ b(ge, &push_receiver);
1313 __ bind(&call_to_object);
1314 __ push(r0);
1315 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1316 __ b(&push_receiver);
1318 __ bind(&use_global_proxy);
1319 __ ldr(r0, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
1320 __ ldr(r0, FieldMemOperand(r0, GlobalObject::kGlobalProxyOffset));
1324 __ bind(&push_receiver);
1325 __ push(r0);
1329 __ ldr(r0, MemOperand(fp, kIndexOffset));
1330 __ b(&entry);
1335 __ bind(&loop);
1336 __ ldr(r1, MemOperand(fp, kArgsOffset));
1337 __ Push(r1, r0);
1340 __ CallRuntime(Runtime::kGetProperty, 2);
1341 __ push(r0);
1344 __ ldr(r0, MemOperand(fp, kIndexOffset));
1345 __ add(r0, r0, Operand(1 << kSmiTagSize));
1346 __ str(r0, MemOperand(fp, kIndexOffset));
1350 __ bind(&entry);
1351 __ ldr(r1, MemOperand(fp, kLimitOffset));
1352 __ cmp(r0, r1);
1353 __ b(ne, &loop);
1358 __ SmiUntag(r0);
1359 __ ldr(r1, MemOperand(fp, kFunctionOffset));
1360 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE);
1361 __ b(ne, &call_proxy);
1362 __ InvokeFunction(r1, actual, CALL_FUNCTION, NullCallWrapper());
1365 __ add(sp, sp, Operand(3 * kPointerSize));
1366 __ Jump(lr);
1369 __ bind(&call_proxy);
1370 __ push(r1); // add function proxy as last argument
1371 __ add(r0, r0, Operand(1));
1372 __ mov(r2, Operand::Zero());
1373 __ GetBuiltinFunction(r1, Builtins::CALL_FUNCTION_PROXY);
1374 __ Call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1379 __ add(sp, sp, Operand(3 * kPointerSize));
1380 __ Jump(lr);
1394 __ LoadRoot(r5, Heap::kRealStackLimitRootIndex);
1397 __ sub(r5, sp, r5);
1399 __ cmp(r5, Operand(r2, LSL, kPointerSizeLog2));
1400 __ b(le, stack_overflow); // Signed comparison.
1405 __ SmiTag(r0);
1406 __ mov(r4, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1407 __ stm(db_w, sp, r0.bit() | r1.bit() | r4.bit() |
1410 __ add(fp, sp,
1421 __ ldr(r1, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
1424 __ LeaveFrame(StackFrame::ARGUMENTS_ADAPTOR);
1425 __ add(sp, sp, Operand::PointerOffsetFromSmiKey(r1));
1426 __ add(sp, sp, Operand(kPointerSize)); // adjust for receiver
1442 __ ldr(r3, FieldMemOperand(r1, JSFunction::kCodeEntryOffset));
1443 __ cmp(r0, r2);
1444 __ b(lt, &too_few);
1445 __ cmp(r2, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel));
1446 __ b(eq, &dont_adapt_arguments);
1449 __ bind(&enough);
1457 __ add(r0, fp, Operand::PointerOffsetFromSmiKey(r0));
1459 __ add(r0, r0, Operand(2 * kPointerSize));
1460 __ sub(r2, r0, Operand(r2, LSL, kPointerSizeLog2));
1469 __ bind(©);
1470 __ ldr(ip, MemOperand(r0, 0));
1471 __ push(ip);
1472 __ cmp(r0, r2); // Compare before moving to next argument.
1473 __ sub(r0, r0, Operand(kPointerSize));
1474 __ b(ne, ©);
1476 __ b(&invoke);
1480 __ bind(&too_few);
1488 __ add(r0, fp, Operand::PointerOffsetFromSmiKey(r0));
1496 __ bind(©);
1498 __ ldr(ip, MemOperand(r0, 2 * kPointerSize));
1499 __ push(ip);
1500 __ cmp(r0, fp); // Compare before moving to next argument.
1501 __ sub(r0, r0, Operand(kPointerSize));
1502 __ b(ne, ©);
1508 __ LoadRoot(ip, Heap::kUndefinedValueRootIndex);
1509 __ sub(r2, fp, Operand(r2, LSL, kPointerSizeLog2));
1511 __ sub(r2, r2, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
1515 __ bind(&fill);
1516 __ push(ip);
1517 __ cmp(sp, r2);
1518 __ b(ne, &fill);
1522 __ bind(&invoke);
1523 __ Call(r3);
1530 __ Jump(lr);
1536 __ bind(&dont_adapt_arguments);
1537 __ Jump(r3);
1539 __ bind(&stack_overflow);
1543 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
1544 __ bkpt(0);
1549 #undef __