Lines Matching refs:__
22 #define __ ACCESS_MASM(masm)
43 __ push(a1);
50 __ Addu(s0, a0, num_extra_args + 1);
51 __ sll(s1, s0, kPointerSizeLog2);
52 __ Subu(s1, s1, kPointerSize);
53 __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
62 __ lw(result,
64 __ lw(result,
67 __ lw(result,
78 __ lw(result,
80 __ lw(result,
83 __ lw(result,
102 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
103 __ SmiTst(a2, t0);
104 __ Assert(ne, kUnexpectedInitialMapForInternalArrayFunction,
106 __ GetObjectType(a2, a3, t0);
107 __ Assert(eq, kUnexpectedInitialMapForInternalArrayFunction,
115 __ TailCallStub(&stub);
132 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
133 __ SmiTst(a2, t0);
134 __ Assert(ne, kUnexpectedInitialMapForArrayFunction1,
136 __ GetObjectType(a2, a3, t0);
137 __ Assert(eq, kUnexpectedInitialMapForArrayFunction2,
143 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
145 __ TailCallStub(&stub);
158 __ IncrementCounter(counters->string_ctor_calls(), 1, a2, a3);
162 __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, a2);
163 __ Assert(eq, kUnexpectedStringFunction, function, Operand(a2));
168 __ Branch(&no_arguments, eq, a0, Operand(zero_reg));
170 __ Subu(a0, a0, Operand(1));
171 __ sll(a0, a0, kPointerSizeLog2);
172 __ Addu(sp, a0, sp);
173 __ lw(a0, MemOperand(sp));
175 __ Drop(2);
179 __ LookupNumberStringCache(a0, // Input.
185 __ IncrementCounter(counters->string_ctor_cached_number(), 1, a3, t0);
186 __ bind(&argument_is_string);
195 __ Allocate(JSValue::kSize,
204 __ LoadGlobalFunctionInitialMap(function, map, t0);
206 __ lbu(t0, FieldMemOperand(map, Map::kInstanceSizeOffset));
207 __ Assert(eq, kUnexpectedStringWrapperInstanceSize,
209 __ lbu(t0, FieldMemOperand(map, Map::kUnusedPropertyFieldsOffset));
210 __ Assert(eq, kUnexpectedUnusedPropertiesOfStringWrapper,
213 __ sw(map, FieldMemOperand(v0, HeapObject::kMapOffset));
215 __ LoadRoot(a3, Heap::kEmptyFixedArrayRootIndex);
216 __ sw(a3, FieldMemOperand(v0, JSObject::kPropertiesOffset));
217 __ sw(a3, FieldMemOperand(v0, JSObject::kElementsOffset));
219 __ sw(argument, FieldMemOperand(v0, JSValue::kValueOffset));
224 __ Ret();
229 __ bind(¬_cached);
230 __ JumpIfSmi(a0, &convert_argument);
233 __ lw(a2, FieldMemOperand(a0, HeapObject::kMapOffset));
234 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
236 __ And(t0, a3, Operand(kIsNotStringMask));
237 __ Branch(&convert_argument, ne, t0, Operand(zero_reg));
238 __ mov(argument, a0);
239 __ IncrementCounter(counters->string_ctor_conversions(), 1, a3, t0);
240 __ Branch(&argument_is_string);
243 __ bind(&convert_argument);
244 __ push(function); // Preserve the function.
245 __ IncrementCounter(counters->string_ctor_conversions(), 1, a3, t0);
248 __ push(a0);
249 __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
251 __ pop(function);
252 __ mov(argument, v0);
253 __ Branch(&argument_is_string);
257 __ bind(&no_arguments);
258 __ LoadRoot(argument, Heap::kempty_stringRootIndex);
259 __ Drop(1);
260 __ Branch(&argument_is_string);
264 __ bind(&gc_required);
265 __ IncrementCounter(counters->string_ctor_gc_required(), 1, a3, t0);
268 __ push(argument);
269 __ CallRuntime(Runtime::kNewStringWrapper, 1);
271 __ Ret();
280 __ Push(a1, a1);
282 __ CallRuntime(function_id, 1);
284 __ Pop(a1);
289 __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
290 __ lw(a2, FieldMemOperand(a2, SharedFunctionInfo::kCodeOffset));
291 __ Addu(at, a2, Operand(Code::kHeaderSize - kHeapObjectTag));
292 __ Jump(at);
297 __ Addu(at, v0, Operand(Code::kHeaderSize - kHeapObjectTag));
298 __ Jump(at);
309 __ LoadRoot(t0, Heap::kStackLimitRootIndex);
310 __ Branch(&ok, hs, sp, Operand(t0));
315 __ bind(&ok);
348 __ AssertUndefinedOrAllocationSite(a2, a3);
349 __ push(a2);
353 __ sll(a0, a0, kSmiTagSize); // Tag arguments count.
354 __ MultiPushReversed(a0.bit() | a1.bit());
363 __ li(a2, Operand(debug_step_in_fp));
364 __ lw(a2, MemOperand(a2));
365 __ Branch(&rt_call, ne, a2, Operand(zero_reg));
369 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
370 __ JumpIfSmi(a2, &rt_call);
371 __ GetObjectType(a2, a3, t4);
372 __ Branch(&rt_call, ne, t4, Operand(MAP_TYPE));
379 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
380 __ Branch(&rt_call, eq, a3, Operand(JS_FUNCTION_TYPE));
386 __ lw(t0, bit_field3);
387 __ DecodeField<Map::ConstructionCount>(t2, t0);
388 __ Branch(&allocate, eq, t2, Operand(JSFunction::kNoSlackTracking));
390 __ Subu(t0, t0, Operand(1 << Map::ConstructionCount::kShift));
391 __ Branch(USE_DELAY_SLOT,
393 __ sw(t0, bit_field3); // In delay slot.
395 __ Push(a1, a2, a1); // a1 = Constructor.
396 __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
398 __ Pop(a1, a2);
401 __ mov(t2, zero_reg);
403 __ bind(&allocate);
409 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceSizeOffset));
411 __ Addu(a3, a3, Operand(AllocationMemento::kSize / kPointerSize));
414 __ Allocate(a3, t4, t5, t6, &rt_call, SIZE_IN_WORDS);
422 __ LoadRoot(t6, Heap::kEmptyFixedArrayRootIndex);
423 __ mov(t5, t4);
424 __ sw(a2, MemOperand(t5, JSObject::kMapOffset));
425 __ sw(t6, MemOperand(t5, JSObject::kPropertiesOffset));
426 __ sw(t6, MemOperand(t5, JSObject::kElementsOffset));
427 __ Addu(t5, t5, Operand(3*kPointerSize));
442 __ LoadRoot(t7, Heap::kUndefinedValueRootIndex);
448 __ Branch(&no_inobject_slack_tracking,
452 __ lbu(a0, FieldMemOperand(a2, Map::kPreAllocatedPropertyFieldsOffset));
453 __ sll(at, a0, kPointerSizeLog2);
454 __ addu(a0, t5, at);
457 __ sll(at, a3, kPointerSizeLog2);
458 __ Addu(t6, t4, Operand(at)); // End of object.
459 __ Assert(le, kUnexpectedNumberOfPreAllocatedPropertyFields,
462 __ InitializeFieldsWithFiller(t5, a0, t7);
464 __ LoadRoot(t7, Heap::kOnePointerFillerMapRootIndex);
467 __ bind(&no_inobject_slack_tracking);
471 __ Subu(a0, a3, Operand(AllocationMemento::kSize / kPointerSize));
472 __ sll(a0, a0, kPointerSizeLog2);
473 __ Addu(a0, t4, Operand(a0)); // End of object.
474 __ InitializeFieldsWithFiller(t5, a0, t7);
478 __ LoadRoot(t7, Heap::kAllocationMementoMapRootIndex);
480 __ sw(t7, MemOperand(t5));
481 __ Addu(t5, t5, kPointerSize);
483 __ lw(t7, MemOperand(sp, 2 * kPointerSize));
485 __ sw(t7, MemOperand(t5));
486 __ Addu(t5, t5, kPointerSize);
488 __ sll(at, a3, kPointerSizeLog2);
489 __ Addu(a0, t4, Operand(at)); // End of object.
490 __ InitializeFieldsWithFiller(t5, a0, t7);
497 __ Addu(t4, t4, Operand(kHeapObjectTag));
504 __ lbu(a3, FieldMemOperand(a2, Map::kUnusedPropertyFieldsOffset));
507 __ lbu(t6, FieldMemOperand(a2, Map::kPreAllocatedPropertyFieldsOffset));
508 __ Addu(a3, a3, Operand(t6));
509 __ lbu(t6, FieldMemOperand(a2, Map::kInObjectPropertiesOffset));
510 __ subu(a3, a3, t6);
513 __ Branch(&allocated, eq, a3, Operand(zero_reg));
514 __ Assert(greater_equal, kPropertyAllocationCountFailed,
523 __ Addu(a0, a3, Operand(FixedArray::kHeaderSize / kPointerSize));
524 __ Allocate(
537 __ LoadRoot(t6, Heap::kFixedArrayMapRootIndex);
538 __ mov(a2, t5);
539 __ sw(t6, MemOperand(a2, JSObject::kMapOffset));
540 __ sll(a0, a3, kSmiTagSize);
541 __ sw(a0, MemOperand(a2, FixedArray::kLengthOffset));
542 __ Addu(a2, a2, Operand(2 * kPointerSize));
553 __ sll(t3, a3, kPointerSizeLog2);
554 __ addu(t6, a2, t3); // End of object.
558 __ LoadRoot(t7, Heap::kUndefinedValueRootIndex);
560 __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
561 __ Assert(eq, kUndefinedValueNotLoaded, t7, Operand(t2));
563 __ jmp(&entry);
564 __ bind(&loop);
565 __ sw(t7, MemOperand(a2));
566 __ addiu(a2, a2, kPointerSize);
567 __ bind(&entry);
568 __ Branch(&loop, less, a2, Operand(t6));
576 __ Addu(t5, t5, Operand(kHeapObjectTag)); // Add the heap tag.
577 __ sw(t5, FieldMemOperand(t4, JSObject::kPropertiesOffset));
582 __ jmp(&allocated);
588 __ bind(&undo_allocation);
589 __ UndoAllocationInNewSpace(t4, t5);
594 __ bind(&rt_call);
597 __ lw(a2, MemOperand(sp, 2 * kPointerSize));
598 __ push(a2);
601 __ push(a1); // Argument for Runtime_NewObject.
603 __ CallRuntime(Runtime::kNewObjectWithAllocationSite, 2);
605 __ CallRuntime(Runtime::kNewObject, 1);
607 __ mov(t4, v0);
614 __ jmp(&count_incremented);
619 __ bind(&allocated);
622 __ lw(a2, MemOperand(sp, kPointerSize * 2));
623 __ LoadRoot(t5, Heap::kUndefinedValueRootIndex);
624 __ Branch(&count_incremented, eq, a2, Operand(t5));
627 __ lw(a3, FieldMemOperand(a2,
629 __ Addu(a3, a3, Operand(Smi::FromInt(1)));
630 __ sw(a3, FieldMemOperand(a2,
632 __ bind(&count_incremented);
635 __ Push(t4, t4);
642 __ lw(a1, MemOperand(sp, 2 * kPointerSize));
643 __ lw(a3, MemOperand(sp, 3 * kPointerSize));
646 __ Addu(a2, fp, Operand(StandardFrameConstants::kCallerSPOffset));
649 __ srl(a0, a3, kSmiTagSize);
661 __ jmp(&entry);
662 __ bind(&loop);
663 __ sll(t0, a3, kPointerSizeLog2 - kSmiTagSize);
664 __ Addu(t0, a2, Operand(t0));
665 __ lw(t1, MemOperand(t0));
666 __ push(t1);
667 __ bind(&entry);
668 __ Addu(a3, a3, Operand(-2));
669 __ Branch(&loop, greater_equal, a3, Operand(zero_reg));
675 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
678 __ Call(code, RelocInfo::CODE_TARGET);
681 __ InvokeFunction(a1, actual, CALL_FUNCTION, NullCallWrapper());
690 __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
702 __ JumpIfSmi(v0, &use_receiver);
706 __ GetObjectType(v0, a1, a3);
707 __ Branch(&exit, greater_equal, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
711 __ bind(&use_receiver);
712 __ lw(v0, MemOperand(sp));
716 __ bind(&exit);
721 __ lw(a1, MemOperand(sp, 2 * kPointerSize));
726 __ sll(t0, a1, kPointerSizeLog2 - 1);
727 __ Addu(sp, sp, t0);
728 __ Addu(sp, sp, kPointerSize);
729 __ IncrementCounter(isolate->counters()->constructed_objects(), 1, a1, a2);
730 __ Ret();
758 __ mov(cp, zero_reg);
765 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
768 __ Push(a1, a2);
774 __ sll(t0, a3, kPointerSizeLog2);
775 __ addu(t2, s0, t0);
776 __ b(&entry);
777 __ nop(); // Branch delay slot nop.
779 __ bind(&loop);
780 __ lw(t0, MemOperand(s0)); // Read next parameter.
781 __ addiu(s0, s0, kPointerSize);
782 __ lw(t0, MemOperand(t0)); // Dereference handle.
783 __ push(t0); // Push parameter.
784 __ bind(&entry);
785 __ Branch(&loop, ne, s0, Operand(t2));
789 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
790 __ mov(s1, t0);
791 __ mov(s2, t0);
792 __ mov(s3, t0);
793 __ mov(s4, t0);
794 __ mov(s5, t0);
799 __ mov(a0, a3);
802 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
804 __ CallStub(&stub);
807 __ InvokeFunction(a1, actual, CALL_FUNCTION, NullCallWrapper());
813 __ Jump(ra);
837 __ Push(a1, a1);
839 __ Push(masm->isolate()->factory()->ToBoolean(concurrent));
841 __ CallRuntime(Runtime::kCompileOptimized, 2);
843 __ Pop(a1);
868 __ Subu(a0, a0,
878 __ MultiPush(saved_regs);
879 __ PrepareCallCFunction(2, 0, a2);
880 __ li(a1, Operand(ExternalReference::isolate_address(masm->isolate())));
881 __ CallCFunction(
883 __ MultiPop(saved_regs);
884 __ Jump(a0);
907 __ Subu(a0, a0,
917 __ MultiPush(saved_regs);
918 __ PrepareCallCFunction(2, 0, a2);
919 __ li(a1, Operand(ExternalReference::isolate_address(masm->isolate())));
920 __ CallCFunction(
923 __ MultiPop(saved_regs);
926 __ Push(ra, fp, cp, a1);
927 __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
930 __ Addu(a0, a0, Operand(kNoCodeAgeSequenceLength));
931 __ Jump(a0);
948 __ MultiPush(kJSCallerSaved | kCalleeSaved);
950 __ CallRuntime(Runtime::kNotifyStubFailure, 0, save_doubles);
951 __ MultiPop(kJSCallerSaved | kCalleeSaved);
954 __ Addu(sp, sp, Operand(kPointerSize)); // Ignore state
955 __ Jump(ra); // Jump to miss handler
974 __ li(a0, Operand(Smi::FromInt(static_cast<int>(type))));
975 __ push(a0);
976 __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
980 __ lw(t2, MemOperand(sp, 0 * kPointerSize));
981 __ SmiUntag(t2);
984 __ Branch(&with_tos_register,
986 __ Ret(USE_DELAY_SLOT);
988 __ Addu(sp, sp, Operand(1 * kPointerSize)); // Remove state.
990 __ bind(&with_tos_register);
991 __ lw(v0, MemOperand(sp, 1 * kPointerSize));
992 __ Branch(&unknown_state, ne, t2, Operand(FullCodeGenerator::TOS_REG));
994 __ Ret(USE_DELAY_SLOT);
996 __ Addu(sp, sp, Operand(2 * kPointerSize)); // Remove state.
998 __ bind(&unknown_state);
999 __ stop("no cases left");
1020 __ lw(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
1024 __ push(a0);
1025 __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
1029 __ Ret(eq, v0, Operand(Smi::FromInt(0)));
1033 __ lw(a1, MemOperand(v0, Code::kDeoptimizationDataOffset - kHeapObjectTag));
1037 __ lw(a1, MemOperand(a1, FixedArray::OffsetOfElementAt(
1039 __ SmiUntag(a1);
1043 __ addu(v0, v0, a1);
1044 __ addiu(ra, v0, Code::kHeaderSize - kHeapObjectTag);
1047 __ Ret();
1054 __ LoadRoot(at, Heap::kStackLimitRootIndex);
1055 __ Branch(&ok, hs, sp, Operand(at));
1058 __ CallRuntime(Runtime::kStackGuard, 0);
1060 __ Jump(masm->isolate()->builtins()->OnStackReplacement(),
1063 __ bind(&ok);
1064 __ Ret();
1072 __ Branch(&done, ne, a0, Operand(zero_reg));
1073 __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
1074 __ push(t2);
1075 __ Addu(a0, a0, Operand(1));
1076 __ bind(&done);
1083 __ sll(at, a0, kPointerSizeLog2);
1084 __ addu(at, sp, at);
1085 __ lw(a1, MemOperand(at));
1086 __ JumpIfSmi(a1, &non_function);
1087 __ GetObjectType(a1, a2, a2);
1088 __ Branch(&slow, ne, a2, Operand(JS_FUNCTION_TYPE));
1094 __ li(t0, Operand(0, RelocInfo::NONE32)); // Indicate regular JS_FUNCTION.
1097 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1100 __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1101 __ lw(a3, FieldMemOperand(a2, SharedFunctionInfo::kCompilerHintsOffset));
1102 __ And(t3, a3, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1104 __ Branch(&shift_arguments, ne, t3, Operand(zero_reg));
1107 __ And(t3, a3, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1108 __ Branch(&shift_arguments, ne, t3, Operand(zero_reg));
1112 __ sll(at, a0, kPointerSizeLog2);
1113 __ addu(a2, sp, at);
1114 __ lw(a2, MemOperand(a2, -kPointerSize));
1118 __ JumpIfSmi(a2, &convert_to_object, t2);
1120 __ LoadRoot(a3, Heap::kUndefinedValueRootIndex);
1121 __ Branch(&use_global_proxy, eq, a2, Operand(a3));
1122 __ LoadRoot(a3, Heap::kNullValueRootIndex);
1123 __ Branch(&use_global_proxy, eq, a2, Operand(a3));
1126 __ GetObjectType(a2, a3, a3);
1127 __ Branch(&shift_arguments, ge, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
1129 __ bind(&convert_to_object);
1133 __ sll(a0, a0, kSmiTagSize); // Smi tagged.
1134 __ Push(a0, a2);
1135 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1136 __ mov(a2, v0);
1138 __ pop(a0);
1139 __ sra(a0, a0, kSmiTagSize); // Un-tag.
1144 __ sll(at, a0, kPointerSizeLog2);
1145 __ addu(at, sp, at);
1146 __ lw(a1, MemOperand(at));
1147 __ Branch(USE_DELAY_SLOT, &patch_receiver);
1148 __ li(t0, Operand(0, RelocInfo::NONE32)); // In delay slot.
1150 __ bind(&use_global_proxy);
1151 __ lw(a2, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
1152 __ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalProxyOffset));
1154 __ bind(&patch_receiver);
1155 __ sll(at, a0, kPointerSizeLog2);
1156 __ addu(a3, sp, at);
1157 __ sw(a2, MemOperand(a3, -kPointerSize));
1159 __ Branch(&shift_arguments);
1163 __ bind(&slow);
1164 __ li(t0, Operand(1, RelocInfo::NONE32)); // Indicate function proxy.
1165 __ Branch(&shift_arguments, eq, a2, Operand(JS_FUNCTION_PROXY_TYPE));
1167 __ bind(&non_function);
1168 __ li(t0, Operand(2, RelocInfo::NONE32)); // Indicate non-function.
1177 __ sll(at, a0, kPointerSizeLog2);
1178 __ addu(a2, sp, at);
1179 __ sw(a1, MemOperand(a2, -kPointerSize));
1187 __ bind(&shift_arguments);
1190 __ sll(at, a0, kPointerSizeLog2);
1191 __ addu(a2, sp, at);
1193 __ bind(&loop);
1194 __ lw(at, MemOperand(a2, -kPointerSize));
1195 __ sw(at, MemOperand(a2));
1196 __ Subu(a2, a2, Operand(kPointerSize));
1197 __ Branch(&loop, ne, a2, Operand(sp));
1200 __ Subu(a0, a0, Operand(1));
1201 __ Pop();
1210 __ Branch(&function, eq, t0, Operand(zero_reg));
1212 __ mov(a2, zero_reg);
1213 __ Branch(&non_proxy, ne, t0, Operand(1));
1215 __ push(a1); // Re-add proxy object as additional argument.
1216 __ Addu(a0, a0, Operand(1));
1217 __ GetBuiltinFunction(a1, Builtins::CALL_FUNCTION_PROXY);
1218 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1221 __ bind(&non_proxy);
1222 __ GetBuiltinFunction(a1, Builtins::CALL_NON_FUNCTION);
1223 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1225 __ bind(&function);
1233 __ lw(a3, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1234 __ lw(a2,
1236 __ sra(a2, a2, kSmiTagSize);
1238 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1241 __ lw(a3, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
1243 __ InvokeCode(a3, expected, expected, JUMP_FUNCTION, NullCallWrapper());
1258 __ lw(a0, MemOperand(fp, kFunctionOffset)); // Get the function.
1259 __ push(a0);
1260 __ lw(a0, MemOperand(fp, kArgsOffset)); // Get the args array.
1261 __ push(a0);
1263 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
1269 __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
1272 __ subu(a2, sp, a2);
1274 __ sll(t3, v0, kPointerSizeLog2 - kSmiTagSize);
1275 __ Branch(&okay, gt, a2, Operand(t3)); // Signed comparison.
1278 __ lw(a1, MemOperand(fp, kFunctionOffset));
1279 __ Push(a1, v0);
1280 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
1284 __ bind(&okay);
1285 __ mov(a1, zero_reg);
1286 __ Push(v0, a1); // Limit and initial index.
1289 __ lw(a0, MemOperand(fp, kRecvOffset));
1293 __ lw(a1, MemOperand(fp, kFunctionOffset));
1294 __ GetObjectType(a1, a2, a2);
1295 __ Branch(&push_receiver, ne, a2, Operand(JS_FUNCTION_TYPE));
1298 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1300 __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1305 __ lw(a2, FieldMemOperand(a2, SharedFunctionInfo::kCompilerHintsOffset));
1306 __ And(t3, a2, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1308 __ Branch(&push_receiver, ne, t3, Operand(zero_reg));
1311 __ And(t3, a2, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1312 __ Branch(&push_receiver, ne, t3, Operand(zero_reg));
1315 __ JumpIfSmi(a0, &call_to_object);
1316 __ LoadRoot(a1, Heap::kNullValueRootIndex);
1317 __ Branch(&use_global_proxy, eq, a0, Operand(a1));
1318 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
1319 __ Branch(&use_global_proxy, eq, a0, Operand(a2));
1324 __ GetObjectType(a0, a1, a1);
1325 __ Branch(&push_receiver, ge, a1, Operand(FIRST_SPEC_OBJECT_TYPE));
1329 __ bind(&call_to_object);
1330 __ push(a0);
1331 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1332 __ mov(a0, v0); // Put object in a0 to match other paths to push_receiver.
1333 __ Branch(&push_receiver);
1335 __ bind(&use_global_proxy);
1336 __ lw(a0, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
1337 __ lw(a0, FieldMemOperand(a0, GlobalObject::kGlobalProxyOffset));
1341 __ bind(&push_receiver);
1342 __ push(a0);
1346 __ lw(a0, MemOperand(fp, kIndexOffset));
1347 __ Branch(&entry);
1352 __ bind(&loop);
1353 __ lw(a1, MemOperand(fp, kArgsOffset));
1354 __ Push(a1, a0);
1357 __ CallRuntime(Runtime::kGetProperty, 2);
1358 __ push(v0);
1361 __ lw(a0, MemOperand(fp, kIndexOffset));
1362 __ Addu(a0, a0, Operand(1 << kSmiTagSize));
1363 __ sw(a0, MemOperand(fp, kIndexOffset));
1367 __ bind(&entry);
1368 __ lw(a1, MemOperand(fp, kLimitOffset));
1369 __ Branch(&loop, ne, a0, Operand(a1));
1374 __ sra(a0, a0, kSmiTagSize);
1375 __ lw(a1, MemOperand(fp, kFunctionOffset));
1376 __ GetObjectType(a1, a2, a2);
1377 __ Branch(&call_proxy, ne, a2, Operand(JS_FUNCTION_TYPE));
1379 __ InvokeFunction(a1, actual, CALL_FUNCTION, NullCallWrapper());
1382 __ Ret(USE_DELAY_SLOT);
1383 __ Addu(sp, sp, Operand(3 * kPointerSize)); // In delay slot.
1386 __ bind(&call_proxy);
1387 __ push(a1); // Add function proxy as last argument.
1388 __ Addu(a0, a0, Operand(1));
1389 __ li(a2, Operand(0, RelocInfo::NONE32));
1390 __ GetBuiltinFunction(a1, Builtins::CALL_FUNCTION_PROXY);
1391 __ Call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1396 __ Ret(USE_DELAY_SLOT);
1397 __ Addu(sp, sp, Operand(3 * kPointerSize)); // In delay slot.
1411 __ LoadRoot(t1, Heap::kRealStackLimitRootIndex);
1414 __ subu(t1, sp, t1);
1416 __ sll(at, a2, kPointerSizeLog2);
1418 __ Branch(stack_overflow, le, t1, Operand(at));
1423 __ sll(a0, a0, kSmiTagSize);
1424 __ li(t0, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1425 __ MultiPush(a0.bit() | a1.bit() | t0.bit() | fp.bit() | ra.bit());
1426 __ Addu(fp, sp,
1437 __ lw(a1, MemOperand(fp, -(StandardFrameConstants::kFixedFrameSizeFromFp +
1439 __ mov(sp, fp);
1440 __ MultiPop(fp.bit() | ra.bit());
1441 __ sll(t0, a1, kPointerSizeLog2 - kSmiTagSize);
1442 __ Addu(sp, sp, t0);
1444 __ Addu(sp, sp, Operand(kPointerSize));
1461 __ lw(a3, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
1462 __ Branch(&dont_adapt_arguments, eq,
1465 __ Branch(&too_few, Uless, a0, Operand(a2));
1472 __ bind(&enough);
1476 __ sll(a0, a0, kPointerSizeLog2 - kSmiTagSize);
1477 __ Addu(a0, fp, a0);
1479 __ Addu(a0, a0, Operand(2 * kPointerSize));
1481 __ sll(a2, a2, kPointerSizeLog2);
1482 __ subu(a2, a0, a2);
1491 __ bind(©);
1492 __ lw(t0, MemOperand(a0));
1493 __ push(t0);
1494 __ Branch(USE_DELAY_SLOT, ©, ne, a0, Operand(a2));
1495 __ addiu(a0, a0, -kPointerSize); // In delay slot.
1497 __ jmp(&invoke);
1501 __ bind(&too_few);
1509 __ sll(a0, a0, kPointerSizeLog2 - kSmiTagSize);
1510 __ Addu(a0, fp, a0);
1512 __ Addu(a0, a0, Operand(2 * kPointerSize));
1514 __ Addu(t3, fp, kPointerSize);
1523 __ bind(©);
1524 __ lw(t0, MemOperand(a0)); // Adjusted above for return addr and receiver.
1525 __ Subu(sp, sp, kPointerSize);
1526 __ Subu(a0, a0, kPointerSize);
1527 __ Branch(USE_DELAY_SLOT, ©, ne, a0, Operand(t3));
1528 __ sw(t0, MemOperand(sp)); // In the delay slot.
1534 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
1535 __ sll(t2, a2, kPointerSizeLog2);
1536 __ Subu(a2, fp, Operand(t2));
1538 __ Subu(a2, a2, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
1542 __ bind(&fill);
1543 __ Subu(sp, sp, kPointerSize);
1544 __ Branch(USE_DELAY_SLOT, &fill, ne, sp, Operand(a2));
1545 __ sw(t0, MemOperand(sp));
1549 __ bind(&invoke);
1551 __ Call(a3);
1558 __ Ret();
1564 __ bind(&dont_adapt_arguments);
1565 __ Jump(a3);
1567 __ bind(&stack_overflow);
1571 __ InvokeBuiltin(Builtins::STACK_OVERFLOW, CALL_FUNCTION);
1572 __ break_(0xCC);
1577 #undef __