Lines Matching refs:a2
101 __ ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
102 __ SmiTst(a2, a4);
105 __ GetObjectType(a2, a3, a4);
131 __ ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
132 __ SmiTst(a2, a4);
135 __ GetObjectType(a2, a3, a4);
142 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
157 __ IncrementCounter(counters->string_ctor_calls(), 1, a2, a3);
161 __ LoadGlobalFunction(Context::STRING_FUNCTION_INDEX, a2);
162 __ Assert(eq, kUnexpectedStringFunction, function, Operand(a2));
176 Register argument = a2;
188 // -- a2 : argument converted to string
232 __ ld(a2, FieldMemOperand(a0, HeapObject::kMapOffset));
233 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
241 // Invoke the conversion builtin and put the result into a2.
254 // Load the empty string into a2, remove the receiver from the
288 __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
289 __ ld(a2, FieldMemOperand(a2, SharedFunctionInfo::kCodeOffset));
290 __ Daddu(at, a2, Operand(Code::kHeaderSize - kHeapObjectTag));
325 // -- a2 : allocation site or undefined
347 __ AssertUndefinedOrAllocationSite(a2, a3);
348 __ push(a2);
363 __ li(a2, Operand(debug_step_in_fp));
364 __ ld(a2, MemOperand(a2));
365 __ Branch(&rt_call, ne, a2, Operand(zero_reg));
369 __ ld(a2, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
370 __ JumpIfSmi(a2, &rt_call);
371 __ GetObjectType(a2, a3, t0);
378 // a2: initial map
379 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceTypeOffset));
384 MemOperand bit_field3 = FieldMemOperand(a2, Map::kBitField3Offset);
398 __ Push(a1, a2, a1); // a1 = Constructor.
401 __ Pop(a1, a2);
411 // a2: initial map
412 __ lbu(a3, FieldMemOperand(a2, Map::kInstanceSizeOffset));
422 // a2: initial map
427 __ sd(a2, MemOperand(t1, JSObject::kMapOffset));
437 // a2: initial map
457 __ lwu(a0, FieldMemOperand(a2, Map::kInstanceSizesOffset));
511 __ lbu(a3, FieldMemOperand(a2, Map::kUnusedPropertyFieldsOffset));
514 __ lw(a0, FieldMemOperand(a2, Map::kInstanceSizesOffset));
538 a2,
548 __ mov(a2, t1);
549 __ sd(t2, MemOperand(a2, JSObject::kMapOffset));
552 __ sd(a0, MemOperand(a2, FixedArray::kLengthOffset));
553 __ Daddu(a2, a2, Operand(2 * kPointerSize));
560 // a2: First element of FixedArray (not tagged)
565 __ daddu(t2, a2, a7); // End of object.
576 __ sd(t3, MemOperand(a2));
577 __ daddiu(a2, a2, kPointerSize);
579 __ Branch(&loop, less, a2, Operand(t2));
608 __ ld(a2, MemOperand(sp, 2 * kPointerSize));
609 __ push(a2);
633 __ ld(a2, MemOperand(sp, kPointerSize * 2));
635 __ Branch(&count_incremented, eq, a2, Operand(t1));
636 // a2 is an AllocationSite. We are creating a memento from it, so we
638 __ ld(a3, FieldMemOperand(a2,
641 __ sd(a3, FieldMemOperand(a2,
657 __ Daddu(a2, fp, Operand(StandardFrameConstants::kCallerSPOffset));
665 // a2: address of last argument (caller sp)
676 __ Daddu(a4, a2, Operand(a4));
741 __ IncrementCounter(isolate->counters()->constructed_objects(), 1, a1, a2);
763 // -- a2: receiver_pointer
779 __ Push(a1, a2);
818 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
893 __ PrepareCallCFunction(2, 0, a2);
932 __ PrepareCallCFunction(2, 0, a2);
1101 __ GetObjectType(a1, a2, a2);
1102 __ Branch(&slow, ne, a2, Operand(JS_FUNCTION_TYPE));
1114 __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1115 __ lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kStrictModeByteOffset));
1120 __ lbu(a3, FieldMemOperand(a2, SharedFunctionInfo::kNativeByteOffset));
1125 // Load first argument in a2. a2 = -kPointerSize(sp + n_args << 2).
1127 __ daddu(a2, sp, at);
1128 __ ld(a2, MemOperand(a2, -kPointerSize));
1131 // a2: first argument
1132 __ JumpIfSmi(a2, &convert_to_object, a6);
1135 __ Branch(&use_global_proxy, eq, a2, Operand(a3));
1137 __ Branch(&use_global_proxy, eq, a2, Operand(a3));
1140 __ GetObjectType(a2, a3, a3);
1148 __ Push(a0, a2);
1150 __ mov(a2, v0);
1164 __ ld(a2, ContextOperand(cp, Context::GLOBAL_OBJECT_INDEX));
1165 __ ld(a2, FieldMemOperand(a2, GlobalObject::kGlobalProxyOffset));
1170 __ sd(a2, MemOperand(a3, -kPointerSize));
1178 __ Branch(&shift_arguments, eq, a2, Operand(JS_FUNCTION_PROXY_TYPE));
1191 __ daddu(a2, sp, at);
1192 __ sd(a1, MemOperand(a2, -kPointerSize));
1204 __ daddu(a2, sp, at);
1207 __ ld(at, MemOperand(a2, -kPointerSize));
1208 __ sd(at, MemOperand(a2));
1209 __ Dsubu(a2, a2, Operand(kPointerSize));
1210 __ Branch(&loop, ne, a2, Operand(sp));
1225 __ mov(a2, zero_reg);
1249 __ lw(a2,
1253 RelocInfo::CODE_TARGET, ne, a2, Operand(a0));
1283 __ LoadRoot(a2, Heap::kRealStackLimitRootIndex);
1284 // Make a2 the space we have left. The stack might already be overflowed
1285 // here which will cause a2 to become negative.
1286 __ dsubu(a2, sp, a2);
1289 __ Branch(&okay, gt, a2, Operand(a7)); // Signed comparison.
1308 __ GetObjectType(a1, a2, a2);
1309 __ Branch(&push_receiver, ne, a2, Operand(JS_FUNCTION_TYPE));
1314 __ ld(a2, FieldMemOperand(a1, JSFunction::kSharedFunctionInfoOffset));
1319 __ lbu(a7, FieldMemOperand(a2, SharedFunctionInfo::kStrictModeByteOffset));
1323 // Do not transform the receiver for native (Compilerhints already in a2).
1324 __ lbu(a7, FieldMemOperand(a2, SharedFunctionInfo::kNativeByteOffset));
1332 __ LoadRoot(a2, Heap::kUndefinedValueRootIndex);
1333 __ Branch(&use_global_proxy, eq, a0, Operand(a2));
1390 __ GetObjectType(a1, a2, a2);
1391 __ Branch(&call_proxy, ne, a2, Operand(JS_FUNCTION_TYPE));
1403 __ li(a2, Operand(0, RelocInfo::NONE32));
1420 // -- a2 : expected number of arguments
1430 __ dsll(at, a2, kPointerSizeLog2);
1468 // -- a2: expected arguments count
1478 a2, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel));
1480 __ Branch(&too_few, Uless, a0, Operand(a2));
1485 // a2: expected number of arguments
1490 // Calculate copy start address into a0 and copy end address into a2.
1496 __ dsll(a2, a2, kPointerSizeLog2);
1497 __ dsubu(a2, a0, a2);
1502 // a2: copy end address
1509 __ Branch(USE_DELAY_SLOT, ©, ne, a0, Operand(a2));
1522 // a2: expected number of arguments
1534 // a2: expected number of arguments
1547 // a2: expected number of arguments
1550 __ dsll(a6, a2, kPointerSizeLog2);
1551 __ Dsubu(a2, fp, Operand(a6));
1553 __ Dsubu(a2, a2, Operand(StandardFrameConstants::kFixedFrameSizeFromFp +
1559 __ Branch(USE_DELAY_SLOT, &fill, ne, sp, Operand(a2));