Lines Matching refs:__
44 #define __ ACCESS_MASM(masm)
65 __ push(a1);
72 __ Addu(s0, a0, num_extra_args + 1);
73 __ sll(s1, s0, kPointerSizeLog2);
74 __ Subu(s1, s1, kPointerSize);
75 __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
84 __ lw(result, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX)));
85 __ lw(result,
88 __ lw(result,
99 __ lw(result, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX)));
100 __ lw(result,
103 __ lw(result,
121 __ LoadInitialArrayMap(array_function, scratch2, scratch1);
129 __ AllocateInNewSpace(size,
140 __ sw(scratch1, FieldMemOperand(result, JSObject::kMapOffset));
141 __ LoadRoot(scratch1, Heap::kEmptyFixedArrayRootIndex);
142 __ sw(scratch1, FieldMemOperand(result, JSArray::kPropertiesOffset));
144 __ mov(scratch3, zero_reg);
145 __ sw(scratch3, FieldMemOperand(result, JSArray::kLengthOffset));
148 __ sw(scratch1, FieldMemOperand(result, JSArray::kElementsOffset));
156 __ Addu(scratch1, result, Operand(JSArray::kSize));
157 __ sw(scratch1, FieldMemOperand(result, JSArray::kElementsOffset));
160 __ And(scratch1, scratch1, Operand(~kHeapObjectTagMask));
167 __ LoadRoot(scratch3, Heap::kFixedArrayMapRootIndex);
169 __ sw(scratch3, MemOperand(scratch1));
170 __ Addu(scratch1, scratch1, kPointerSize);
171 __ li(scratch3, Operand(Smi::FromInt(initial_capacity)));
173 __ sw(scratch3, MemOperand(scratch1));
174 __ Addu(scratch1, scratch1, kPointerSize);
178 __ LoadRoot(scratch3, Heap::kTheHoleValueRootIndex);
182 __ sw(scratch3, MemOperand(scratch1, i * kPointerSize));
186 __ Addu(scratch2, scratch1, Operand(initial_capacity * kPointerSize));
187 __ Branch(&entry);
188 __ bind(&loop);
189 __ sw(scratch3, MemOperand(scratch1));
190 __ Addu(scratch1, scratch1, kPointerSize);
191 __ bind(&entry);
192 __ Branch(&loop, lt, scratch1, Operand(scratch2));
217 __ LoadInitialArrayMap(array_function, scratch2, elements_array_storage);
220 __ Assert(
227 __ li(elements_array_end,
229 __ sra(scratch1, array_size, kSmiTagSize);
230 __ Addu(elements_array_end, elements_array_end, scratch1);
231 __ AllocateInNewSpace(
244 __ sw(elements_array_storage, FieldMemOperand(result, JSObject::kMapOffset));
245 __ LoadRoot(elements_array_storage, Heap::kEmptyFixedArrayRootIndex);
246 __ sw(elements_array_storage,
249 __ sw(array_size, FieldMemOperand(result, JSArray::kLengthOffset));
255 __ Addu(elements_array_storage, result, Operand(JSArray::kSize));
256 __ sw(elements_array_storage,
260 __ And(elements_array_storage,
268 __ LoadRoot(scratch1, Heap::kFixedArrayMapRootIndex);
270 __ sw(scratch1, MemOperand(elements_array_storage));
271 __ Addu(elements_array_storage, elements_array_storage, kPointerSize);
279 __ sw(array_size, MemOperand(elements_array_storage));
280 __ Addu(elements_array_storage, elements_array_storage, kPointerSize);
287 __ sll(elements_array_end, array_size, kPointerSizeLog2 - kSmiTagSize);
288 __ Addu(elements_array_end, elements_array_storage, elements_array_end);
296 __ LoadRoot(scratch1, Heap::kTheHoleValueRootIndex);
297 __ Branch(&entry);
298 __ bind(&loop);
299 __ sw(scratch1, MemOperand(elements_array_storage));
300 __ Addu(elements_array_storage, elements_array_storage, kPointerSize);
302 __ bind(&entry);
303 __ Branch(&loop, lt, elements_array_storage, Operand(elements_array_end));
329 __ Branch(&argc_one_or_more, ne, a0, Operand(zero_reg));
331 __ bind(&empty_array);
339 __ IncrementCounter(counters->array_function_native(), 1, a3, t0);
341 __ mov(v0, a2);
342 __ Addu(sp, sp, Operand(kPointerSize));
343 __ Ret();
347 __ bind(&argc_one_or_more);
348 __ Branch(&argc_two_or_more, ne, a0, Operand(1));
351 __ lw(a2, MemOperand(sp)); // Get the argument from the stack.
352 __ Branch(¬_empty_array, ne, a2, Operand(zero_reg));
353 __ Drop(1); // Adjust stack.
354 __ mov(a0, zero_reg); // Treat this as a call with argc of zero.
355 __ Branch(&empty_array);
357 __ bind(¬_empty_array);
358 __ And(a3, a2, Operand(kIntptrSignBit | kSmiTagMask));
359 __ Branch(call_generic_code, eq, a3, Operand(zero_reg));
364 __ Branch(call_generic_code, Ugreater_equal, a2,
381 __ IncrementCounter(counters->array_function_native(), 1, a2, t0);
384 __ mov(v0, a3);
385 __ Addu(sp, sp, Operand(2 * kPointerSize));
386 __ Ret();
389 __ bind(&argc_two_or_more);
390 __ sll(a2, a0, kSmiTagSize); // Convert argc to a smi.
406 __ IncrementCounter(counters->array_function_native(), 1, a2, t2);
418 __ Branch(USE_DELAY_SLOT, &entry);
419 __ mov(t3, sp);
420 __ bind(&loop);
421 __ lw(a2, MemOperand(t3));
423 __ JumpIfNotSmi(a2, &has_non_smi_element);
425 __ Addu(t3, t3, kPointerSize);
426 __ Addu(t1, t1, -kPointerSize);
427 __ sw(a2, MemOperand(t1));
428 __ bind(&entry);
429 __ Branch(&loop, lt, t0, Operand(t1));
431 __ bind(&finish);
432 __ mov(sp, t3);
439 __ Addu(sp, sp, Operand(kPointerSize));
440 __ mov(v0, a3);
441 __ Ret();
443 __ bind(&has_non_smi_element);
445 __ CheckMap(
447 __ bind(&cant_transition_map);
448 __ UndoAllocationInNewSpace(a3, t0);
449 __ Branch(call_generic_code);
451 __ bind(¬_double);
454 __ lw(a2, FieldMemOperand(a3, HeapObject::kMapOffset));
455 __ LoadTransitionedArrayMapConditional(FAST_SMI_ONLY_ELEMENTS,
460 __ sw(a2, FieldMemOperand(a3, HeapObject::kMapOffset));
461 __ RecordWriteField(a3,
470 __ bind(&loop2);
471 __ lw(a2, MemOperand(t3));
472 __ Addu(t3, t3, kPointerSize);
473 __ Subu(t1, t1, kPointerSize);
474 __ sw(a2, MemOperand(t1));
475 __ Branch(&loop2, lt, t0, Operand(t1));
476 __ Branch(&finish);
493 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
494 __ And(t0, a2, Operand(kSmiTagMask));
495 __ Assert(ne, "Unexpected initial map for InternalArray function",
497 __ GetObjectType(a2, a3, t0);
498 __ Assert(eq, "Unexpected initial map for InternalArray function",
508 __ bind(&generic_array_code);
512 __ Jump(array_code, RelocInfo::CODE_TARGET);
529 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
530 __ And(t0, a2, Operand(kSmiTagMask));
531 __ Assert(ne, "Unexpected initial map for Array function (1)",
533 __ GetObjectType(a2, a3, t0);
534 __ Assert(eq, "Unexpected initial map for Array function (2)",
543 __ bind(&generic_array_code);
547 __ Jump(array_code, RelocInfo::CODE_TARGET);
564 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
565 __ And(t0, a2, Operand(kSmiTagMask));
566 __ Assert(ne, "Unexpected initial map for Array function (3)",
568 __ GetObjectType(a2, a3, t0);
569 __ Assert(eq, "Unexpected initial map for Array function (4)",
578 __ bind(&generic_constructor);
582 __ Jump(generic_construct_stub, RelocInfo::CODE_TARGET);
595 __ IncrementCounter(counters->string_ctor_calls(), 1, a2, a3);
599 __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, a2);
600 __ Assert(eq, "Unexpected String function", function, Operand(a2));
605 __ Branch(&no_arguments, eq, a0, Operand(zero_reg));
607 __ Subu(a0, a0, Operand(1));
608 __ sll(a0, a0, kPointerSizeLog2);
609 __ Addu(sp, a0, sp);
610 __ lw(a0, MemOperand(sp));
612 __ Drop(2);
625 __ IncrementCounter(counters->string_ctor_cached_number(), 1, a3, t0);
626 __ bind(&argument_is_string);
635 __ AllocateInNewSpace(JSValue::kSize,
644 __ LoadGlobalFunctionInitialMap(function, map, t0);
646 __ lbu(t0, FieldMemOperand(map, Map::kInstanceSizeOffset));
647 __ Assert(eq, "Unexpected string wrapper instance size",
649 __ lbu(t0, FieldMemOperand(map, Map::kUnusedPropertyFieldsOffset));
650 __ Assert(eq, "Unexpected unused properties of string wrapper",
653 __ sw(map, FieldMemOperand(v0, HeapObject::kMapOffset));
655 __ LoadRoot(a3, Heap::kEmptyFixedArrayRootIndex);
656 __ sw(a3, FieldMemOperand(v0, JSObject::kPropertiesOffset));
657 __ sw(a3, FieldMemOperand(v0, JSObject::kElementsOffset));
659 __ sw(argument, FieldMemOperand(v0, JSValue::kValueOffset));
664 __ Ret();
669 __ bind(¬_cached);
670 __ JumpIfSmi(a0, &convert_argument);
673 __ lw(a2, FieldMemOperand(a0, HeapObject::kMapOffset));
674 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
676 __ And(t0, a3, Operand(kIsNotStringMask));
677 __ Branch(&convert_argument, ne, t0, Operand(zero_reg));
678 __ mov(argument, a0);
679 __ IncrementCounter(counters->string_ctor_conversions(), 1, a3, t0);
680 __ Branch(&argument_is_string);
683 __ bind(&convert_argument);
684 __ push(function); // Preserve the function.
685 __ IncrementCounter(counters->string_ctor_conversions(), 1, a3, t0);
688 __ push(v0);
689 __ InvokeBuiltin(Builtins::TO_STRING, CALL_FUNCTION);
691 __ pop(function);
692 __ mov(argument, v0);
693 __ Branch(&argument_is_string);
697 __ bind(&no_arguments);
698 __ LoadRoot(argument, Heap::kEmptyStringRootIndex);
699 __ Drop(1);
700 __ Branch(&argument_is_string);
704 __ bind(&gc_required);
705 __ IncrementCounter(counters->string_ctor_gc_required(), 1, a3, t0);
708 __ push(argument);
709 __ CallRuntime(Runtime::kNewStringWrapper, 1);
711 __ Ret();
742 __ sll(a0, a0, kSmiTagSize); // Tag arguments count.
743 __ MultiPushReversed(a0.bit() | a1.bit());
746 __ LoadRoot(t7, Heap::kUndefinedValueRootIndex);
756 __ li(a2, Operand(debug_step_in_fp));
757 __ lw(a2, MemOperand(a2));
758 __ Branch(&rt_call, ne, a2, Operand(zero_reg));
763 __ lw(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
764 __ JumpIfSmi(a2, &rt_call);
765 __ GetObjectType(a2, a3, t4);
766 __ Branch(&rt_call, ne, t4, Operand(MAP_TYPE));
773 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
774 __ Branch(&rt_call, eq, a3, Operand(JS_FUNCTION_TYPE));
779 __ lw(a3, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
782 __ lbu(t0, constructor_count);
783 __ Subu(t0, t0, Operand(1));
784 __ sb(t0, constructor_count);
785 __ Branch(&allocate, ne, t0, Operand(zero_reg));
787 __ Push(a1, a2);
789 __ push(a1); // Constructor.
791 __ CallRuntime(Runtime::kFinalizeInstanceSize, 1);
793 __ pop(a2);
794 __ pop(a1);
796 __ bind(&allocate);
802 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceSizeOffset));
803 __ AllocateInNewSpace(a3, t4, t5, t6, &rt_call, SIZE_IN_WORDS);
811 __ LoadRoot(t6, Heap::kEmptyFixedArrayRootIndex);
812 __ mov(t5, t4);
813 __ sw(a2, MemOperand(t5, JSObject::kMapOffset));
814 __ sw(t6, MemOperand(t5, JSObject::kPropertiesOffset));
815 __ sw(t6, MemOperand(t5, JSObject::kElementsOffset));
816 __ Addu(t5, t5, Operand(3*kPointerSize));
827 __ sll(t0, a3, kPointerSizeLog2);
828 __ addu(t6, t4, t0); // End of object.
830 __ LoadRoot(t7, Heap::kUndefinedValueRootIndex);
832 __ lw(a0, FieldMemOperand(a2, Map::kInstanceSizesOffset));
833 __ Ext(a0, a0, Map::kPreAllocatedPropertyFieldsByte * kBitsPerByte,
835 __ sll(t0, a0, kPointerSizeLog2);
836 __ addu(a0, t5, t0);
839 __ Assert(le, "Unexpected number of pre-allocated property fields.",
842 __ InitializeFieldsWithFiller(t5, a0, t7);
844 __ LoadRoot(t7, Heap::kOnePointerFillerMapRootIndex);
846 __ InitializeFieldsWithFiller(t5, t6, t7);
852 __ Addu(t4, t4, Operand(kHeapObjectTag));
859 __ lbu(a3, FieldMemOperand(a2, Map::kUnusedPropertyFieldsOffset));
862 __ lw(a0, FieldMemOperand(a2, Map::kInstanceSizesOffset));
863 __ Ext(t6, a0, Map::kPreAllocatedPropertyFieldsByte * kBitsPerByte,
865 __ Addu(a3, a3, Operand(t6));
866 __ Ext(t6, a0, Map::kInObjectPropertiesByte * kBitsPerByte,
868 __ subu(a3, a3, t6);
871 __ Branch(&allocated, eq, a3, Operand(zero_reg));
872 __ Assert(greater_equal, "Property allocation count failed.",
881 __ Addu(a0, a3, Operand(FixedArray::kHeaderSize / kPointerSize));
882 __ AllocateInNewSpace(
895 __ LoadRoot(t6, Heap::kFixedArrayMapRootIndex);
896 __ mov(a2, t5);
897 __ sw(t6, MemOperand(a2, JSObject::kMapOffset));
898 __ sll(a0, a3, kSmiTagSize);
899 __ sw(a0, MemOperand(a2, FixedArray::kLengthOffset));
900 __ Addu(a2, a2, Operand(2 * kPointerSize));
911 __ sll(t3, a3, kPointerSizeLog2);
912 __ addu(t6, a2, t3); // End of object.
916 __ LoadRoot(t7, Heap::kUndefinedValueRootIndex);
918 __ LoadRoot(t8, Heap::kUndefinedValueRootIndex);
919 __ Assert(eq, "Undefined value not loaded.", t7, Operand(t8));
921 __ jmp(&entry);
922 __ bind(&loop);
923 __ sw(t7, MemOperand(a2));
924 __ addiu(a2, a2, kPointerSize);
925 __ bind(&entry);
926 __ Branch(&loop, less, a2, Operand(t6));
934 __ Addu(t5, t5, Operand(kHeapObjectTag)); // Add the heap tag.
935 __ sw(t5, FieldMemOperand(t4, JSObject::kPropertiesOffset));
940 __ jmp(&allocated);
946 __ bind(&undo_allocation);
947 __ UndoAllocationInNewSpace(t4, t5);
950 __ bind(&rt_call);
953 __ push(a1); // Argument for Runtime_NewObject.
954 __ CallRuntime(Runtime::kNewObject, 1);
955 __ mov(t4, v0);
959 __ bind(&allocated);
960 __ push(t4);
961 __ push(t4);
968 __ lw(a1, MemOperand(sp, 2 * kPointerSize));
969 __ lw(a3, MemOperand(sp, 3 * kPointerSize));
972 __ Addu(a2, fp, Operand(StandardFrameConstants::kCallerSPOffset));
975 __ srl(a0, a3, kSmiTagSize);
987 __ jmp(&entry);
988 __ bind(&loop);
989 __ sll(t0, a3, kPointerSizeLog2 - kSmiTagSize);
990 __ Addu(t0, a2, Operand(t0));
991 __ lw(t1, MemOperand(t0));
992 __ push(t1);
993 __ bind(&entry);
994 __ Addu(a3, a3, Operand(-2));
995 __ Branch(&loop, greater_equal, a3, Operand(zero_reg));
1001 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1005 __ InvokeCode(code, expected, expected,
1009 __ InvokeFunction(a1, actual, CALL_FUNCTION,
1019 __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
1031 __ JumpIfSmi(v0, &use_receiver);
1035 __ GetObjectType(v0, a3, a3);
1036 __ Branch(&exit, greater_equal, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
1040 __ bind(&use_receiver);
1041 __ lw(v0, MemOperand(sp));
1045 __ bind(&exit);
1050 __ lw(a1, MemOperand(sp, 2 * kPointerSize));
1055 __ sll(t0, a1, kPointerSizeLog2 - 1);
1056 __ Addu(sp, sp, t0);
1057 __ Addu(sp, sp, kPointerSize);
1058 __ IncrementCounter(isolate->counters()->constructed_objects(), 1, a1, a2);
1059 __ Ret();
1091 __ mov(cp, zero_reg);
1098 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1101 __ Push(a1, a2);
1107 __ sll(t0, a3, kPointerSizeLog2);
1108 __ addu(t2, s0, t0);
1109 __ b(&entry);
1110 __ nop(); // Branch delay slot nop.
1112 __ bind(&loop);
1113 __ lw(t0, MemOperand(s0)); // Read next parameter.
1114 __ addiu(s0, s0, kPointerSize);
1115 __ lw(t0, MemOperand(t0)); // Dereference handle.
1116 __ push(t0); // Push parameter.
1117 __ bind(&entry);
1118 __ Branch(&loop, ne, s0, Operand(t2));
1122 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
1123 __ mov(s1, t0);
1124 __ mov(s2, t0);
1125 __ mov(s3, t0);
1126 __ mov(s4, t0);
1127 __ mov(s5, t0);
1132 __ mov(a0, a3);
1135 __ CallStub(&stub);
1138 __ InvokeFunction(a1, actual, CALL_FUNCTION,
1145 __ Jump(ra);
1165 __ push(a1);
1167 __ push(t1);
1170 __ push(a1);
1172 __ CallRuntime(Runtime::kLazyCompile, 1);
1174 __ addiu(t9, v0, Code::kHeaderSize - kHeapObjectTag);
1177 __ pop(t1);
1179 __ pop(a1);
1185 __ Jump(t9);
1195 __ push(a1);
1197 __ push(t1);
1200 __ push(a1);
1201 __ CallRuntime(Runtime::kLazyRecompile, 1);
1203 __ Addu(t9, v0, Operand(Code::kHeaderSize - kHeapObjectTag));
1206 __ pop(t1);
1208 __ pop(a1);
1214 __ Jump(t9);
1223 __ li(a0, Operand(Smi::FromInt(static_cast<int>(type))));
1224 __ push(a0);
1225 __ CallRuntime(Runtime::kNotifyDeoptimized, 1);
1229 __ lw(t2, MemOperand(sp, 0 * kPointerSize));
1230 __ SmiUntag(t2);
1233 __ Branch(&with_tos_register,
1235 __ Addu(sp, sp, Operand(1 * kPointerSize)); // Remove state.
1236 __ Ret();
1238 __ bind(&with_tos_register);
1239 __ lw(v0, MemOperand(sp, 1 * kPointerSize));
1240 __ Branch(&unknown_state, ne, t2, Operand(FullCodeGenerator::TOS_REG));
1242 __ Addu(sp, sp, Operand(2 * kPointerSize)); // Remove state.
1243 __ Ret();
1245 __ bind(&unknown_state);
1246 __ stop("no cases left");
1267 __ MultiPush(saved_regs);
1270 __ CallRuntime(Runtime::kNotifyOSR, 0);
1272 __ MultiPop(saved_regs);
1273 __ Ret();
1280 __ Abort("Unreachable code: Cannot optimize without FPU support.");
1286 __ lw(a0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
1289 __ push(a0);
1290 __ CallRuntime(Runtime::kCompileForOnStackReplacement, 1);
1295 __ Ret(eq, v0, Operand(Smi::FromInt(-1)));
1298 __ SmiUntag(v0);
1299 __ push(v0);
1312 __ Branch(&done, ne, a0, Operand(zero_reg));
1313 __ LoadRoot(t2, Heap::kUndefinedValueRootIndex);
1314 __ push(t2);
1315 __ Addu(a0, a0, Operand(1));
1316 __ bind(&done);
1323 __ sll(at, a0, kPointerSizeLog2);
1324 __ addu(at, sp, at);
1325 __ lw(a1, MemOperand(at));
1326 __ JumpIfSmi(a1, &non_function);
1327 __ GetObjectType(a1, a2, a2);
1328 __ Branch(&slow, ne, a2, Operand(JS_FUNCTION_TYPE));
1334 __ li(t0, Operand(0, RelocInfo::NONE)); // Indicate regular JS_FUNCTION.
1337 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1340 __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1341 __ lw(a3, FieldMemOperand(a2, SharedFunctionInfo::kCompilerHintsOffset));
1342 __ And(t3, a3, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1344 __ Branch(&shift_arguments, ne, t3, Operand(zero_reg));
1347 __ And(t3, a3, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1348 __ Branch(&shift_arguments, ne, t3, Operand(zero_reg));
1352 __
1353 __ addu(a2, sp, at);
1354 __ lw(a2, MemOperand(a2, -kPointerSize));
1358 __ JumpIfSmi(a2, &convert_to_object, t2);
1360 __ LoadRoot(a3, Heap::kUndefinedValueRootIndex);
1361 __ Branch(&use_global_receiver, eq, a2, Operand(a3));
1362 __ LoadRoot(a3, Heap::kNullValueRootIndex);
1363 __ Branch(&use_global_receiver, eq, a2, Operand(a3));
1366 __ GetObjectType(a2, a3, a3);
1367 __ Branch(&shift_arguments, ge, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
1369 __ bind(&convert_to_object);
1373 __ sll(a0, a0, kSmiTagSize); // Smi tagged.
1374 __ push(a0);
1376 __ push(a2);
1377 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1378 __ mov(a2, v0);
1380 __ pop(a0);
1381 __ sra(a0, a0, kSmiTagSize); // Un-tag.
1385 __ sll(at, a0, kPointerSizeLog2);
1386 __ addu(at, sp, at);
1387 __ lw(a1, MemOperand(at));
1388 __ li(t0, Operand(0, RelocInfo::NONE));
1389 __ Branch(&patch_receiver);
1393 __ bind(&use_global_receiver);
1396 __ lw(a2, FieldMemOperand(cp, kGlobalIndex));
1397 __ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalContextOffset));
1398 __ lw(a2, FieldMemOperand(a2, kGlobalIndex));
1399 __ lw(a2, FieldMemOperand(a2, GlobalObject::kGlobalReceiverOffset));
1401 __ bind(&patch_receiver);
1402 __ sll(at, a0, kPointerSizeLog2);
1403 __ addu(a3, sp, at);
1404 __ sw(a2, MemOperand(a3, -kPointerSize));
1406 __ Branch(&shift_arguments);
1410 __ bind(&slow);
1411 __ li(t0, Operand(1, RelocInfo::NONE)); // Indicate function proxy.
1412 __ Branch(&shift_arguments, eq, a2, Operand(JS_FUNCTION_PROXY_TYPE));
1414 __ bind(&non_function);
1415 __ li(t0, Operand(2, RelocInfo::NONE)); // Indicate non-function.
1424 __ sll(at, a0, kPointerSizeLog2);
1425 __ addu(a2, sp, at);
1426 __ sw(a1, MemOperand(a2, -kPointerSize));
1434 __ bind(&shift_arguments);
1437 __ sll(at, a0, kPointerSizeLog2);
1438 __ addu(a2, sp, at);
1440 __ bind(&loop);
1441 __ lw(at, MemOperand(a2, -kPointerSize));
1442 __ sw(at, MemOperand(a2));
1443 __ Subu(a2, a2, Operand(kPointerSize));
1444 __ Branch(&loop, ne, a2, Operand(sp));
1447 __ Subu(a0, a0, Operand(1));
1448 __ Pop();
1457 __ Branch(&function, eq, t0, Operand(zero_reg));
1459 __ mov(a2, zero_reg);
1460 __ SetCallKind(t1, CALL_AS_METHOD);
1461 __ Branch(&non_proxy, ne, t0, Operand(1));
1463 __ push(a1); // Re-add proxy object as additional argument.
1464 __ Addu(a0, a0, Operand(1));
1465 __ GetBuiltinEntry(a3, Builtins::CALL_FUNCTION_PROXY);
1466 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1469 __ bind(&non_proxy);
1470 __ GetBuiltinEntry(a3, Builtins::CALL_NON_FUNCTION);
1471 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1473 __ bind(&function);
1481 __ lw(a3, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1482 __ lw(a2,
1484 __ sra(a2, a2, kSmiTagSize);
1485 __ lw(a3, FieldMemOperand(a1, JSFunction::kCodeEntryOffset));
1486 __ SetCallKind(t1, CALL_AS_METHOD);
1488 __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1492 __ InvokeCode(a3, expected, expected, JUMP_FUNCTION,
1506 __ lw(a0, MemOperand(fp, kFunctionOffset)); // Get the function.
1507 __ push(a0);
1508 __ lw(a0, MemOperand(fp, kArgsOffset)); // Get the args array.
1509 __ push(a0);
1511 __ InvokeBuiltin(Builtins::APPLY_PREPARE, CALL_FUNCTION);
1517 __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
1520 __ subu(a2, sp, a2);
1522 __ sll(t3, v0, kPointerSizeLog2 - kSmiTagSize);
1523 __ Branch(&okay, gt, a2, Operand(t3)); // Signed comparison.
1526 __ lw(a1, MemOperand(fp, kFunctionOffset));
1527 __ push(a1);
1528 __ push(v0);
1529 __ InvokeBuiltin(Builtins::APPLY_OVERFLOW, CALL_FUNCTION);
1533 __ bind(&okay);
1534 __ push(v0); // Limit.
1535 __ mov(a1, zero_reg); // Initial index.
1536 __ push(a1);
1539 __ lw(a0, MemOperand(fp, kRecvOffset));
1543 __ lw(a1, MemOperand(fp, kFunctionOffset));
1544 __ GetObjectType(a1, a2, a2);
1545 __ Branch(&push_receiver, ne, a2, Operand(JS_FUNCTION_TYPE));
1548 __ lw(cp, FieldMemOperand(a1, JSFunction::kContextOffset));
1550 __ lw(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1555 __ lw(a2, FieldMemOperand(a2, SharedFunctionInfo::kCompilerHintsOffset));
1556 __ And(t3, a2, Operand(1 << (SharedFunctionInfo::kStrictModeFunction +
1558 __ Branch(&push_receiver, ne, t3, Operand(zero_reg));
1561 __ And(t3, a2, Operand(1 << (SharedFunctionInfo::kNative + kSmiTagSize)));
1562 __ Branch(&push_receiver, ne, t3, Operand(zero_reg));
1565 __ JumpIfSmi(a0, &call_to_object);
1566 __ LoadRoot(a1, Heap::kNullValueRootIndex);
1567 __ Branch(&use_global_receiver, eq, a0, Operand(a1));
1568 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
1569 __ Branch(&use_global_receiver, eq, a0, Operand(a2));
1574 __ GetObjectType(a0, a1, a1);
1575 __ Branch(&push_receiver, ge, a1, Operand(FIRST_SPEC_OBJECT_TYPE));
1579 __ bind(&call_to_object);
1580 __ push(a0);
1581 __ InvokeBuiltin(Builtins::TO_OBJECT, CALL_FUNCTION);
1582 __ mov(a0, v0); // Put object in a0 to match other paths to push_receiver.
1583 __ Branch(&push_receiver);
1586 __ bind(&use_global_receiver);
1589 __ lw(a0, FieldMemOperand(cp, kGlobalOffset));
1590 __ lw(a0, FieldMemOperand(a0, GlobalObject::kGlobalContextOffset));
1591 __ lw(a0, FieldMemOperand(a0, kGlobalOffset));
1592 __ lw(a0, FieldMemOperand(a0, GlobalObject::kGlobalReceiverOffset));
1596 __ bind(&push_receiver);
1597 __ push(a0);
1601 __ lw(a0, MemOperand(fp, kIndexOffset));
1602 __ Branch(&entry);
1607 __ bind(&loop);
1608 __ lw(a1, MemOperand(fp, kArgsOffset));
1609 __ push(a1);
1610 __ push(a0);
1613 __ CallRuntime(Runtime::kGetProperty, 2);
1614 __ push(v0);
1617 __ lw(a0, MemOperand(fp, kIndexOffset));
1618 __ Addu(a0, a0, Operand(1 << kSmiTagSize));
1619 __ sw(a0, MemOperand(fp, kIndexOffset));
1623 __ bind(&entry);
1624 __ lw(a1, MemOperand(fp, kLimitOffset));
1625 __ Branch(&loop, ne, a0, Operand(a1));
1630 __ sra(a0, a0, kSmiTagSize);
1631 __ lw(a1, MemOperand(fp, kFunctionOffset));
1632 __ GetObjectType(a1, a2, a2);
1633 __ Branch(&call_proxy, ne, a2, Operand(JS_FUNCTION_TYPE));
1635 __ InvokeFunction(a1, actual, CALL_FUNCTION,
1639 __ Ret(USE_DELAY_SLOT);
1640 __ Addu(sp, sp, Operand(3 * kPointerSize)); // In delay slot.
1643 __ bind(&call_proxy);
1644 __ push(a1); // Add function proxy as last argument.
1645 __ Addu(a0, a0, Operand(1));
1646 __ li(a2, Operand(0, RelocInfo::NONE));
1647 __ SetCallKind(t1, CALL_AS_METHOD);
1648 __ GetBuiltinEntry(a3, Builtins::CALL_FUNCTION_PROXY);
1649 __ Call(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
1654 __ Ret(USE_DELAY_SLOT);
1655 __ Addu(sp, sp, Operand(3 * kPointerSize)); // In delay slot.
1660 __ sll(a0, a0, kSmiTagSize);
1661 __ li(t0, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
1662 __ MultiPush(a0.bit() | a1.bit() | t0.bit() | fp.bit() | ra.bit());
1663 __ Addu(fp, sp, Operand(3 * kPointerSize));
1673 __ lw(a1, MemOperand(fp, -3 * kPointerSize));
1674 __ mov(sp, fp);
1675 __ MultiPop(fp.bit() | ra.bit());
1676 __ sll(t0, a1, kPointerSizeLog2 - kSmiTagSize);
1677 __ Addu(sp, sp, t0);
1679 __ Addu(sp, sp, Operand(kPointerSize));
1696 __ Branch(&dont_adapt_arguments, eq,
1699 __ Branch(&too_few, Uless, a0, Operand(a2));
1706 __ bind(&enough);
1710 __ sll(a0, a0, kPointerSizeLog2 - kSmiTagSize);
1711 __ Addu(a0, fp, a0);
1713 __ Addu(a0, a0, Operand(2 * kPointerSize));
1715 __ sll(a2, a2, kPointerSizeLog2);
1716 __ subu(a2, a0, a2);
1725 __ bind(©);
1726 __ lw(t0, MemOperand(a0));
1727 __ push(t0);
1728 __ Branch(USE_DELAY_SLOT, ©, ne, a0, Operand(a2));
1729 __ addiu(a0, a0, -kPointerSize); // In delay slot.
1731 __ jmp(&invoke);
1735 __ bind(&too_few);
1743 __ sll(a0, a0, kPointerSizeLog2 - kSmiTagSize);
1744 __ Addu(a0, fp, a0);
1746 __ Addu(a0, a0, Operand(2 * kPointerSize));
1748 __ Addu(t3, fp, kPointerSize);
1757 __ bind(©);
1758 __ lw(t0, MemOperand(a0)); // Adjusted above for return addr and receiver.
1759 __ Subu(sp, sp, kPointerSize);
1760 __ Subu(a0, a0, kPointerSize);
1761 __ Branch(USE_DELAY_SLOT, ©, ne, a0, Operand(t3));
1762 __ sw(t0, MemOperand(sp)); // In the delay slot.
1768 __ LoadRoot(t0, Heap::kUndefinedValueRootIndex);
1769 __ sll(t2, a2, kPointerSizeLog2);
1770 __ Subu(a2, fp, Operand(t2));
1771 __ Addu(a2, a2, Operand(-4 * kPointerSize)); // Adjust for frame.
1774 __ bind(&fill);
1775 __ Subu(sp, sp, kPointerSize);
1776 __ Branch(USE_DELAY_SLOT, &fill, ne, sp, Operand(a2));
1777 __ sw(t0, MemOperand(sp));
1781 __ bind(&invoke);
1783 __ Call(a3);
1790 __ Ret();
1796 __ bind(&dont_adapt_arguments);
1797 __ Jump(a3);
1801 #undef __
