Cross Reference: /external/v8/src/mips/code-stubs-mips.cc

Lines Matching refs:a3
402     __ GetObjectType(rhs, a3, a3);
403     __ Branch(&return_not_equal, greater, a3, Operand(FIRST_JS_RECEIVER_TYPE));
406     __ Branch(&return_not_equal, eq, a3, Operand(ODDBALL_TYPE));
411     __ Or(a2, a2, Operand(a3));
423   __ GetObjectType(lhs, a3, a2);
427   __ Branch(slow, ne, a3, Operand(a2));
453   __ GetObjectType(rhs, a3, a3);
454   __ Branch(runtime_call, ge, a3, Operand(FIRST_NONSTRING_TYPE));
455   __ And(at, a3, Operand(kIsNotInternalizedMask));
466   __ lw(a3, FieldMemOperand(rhs, HeapObject::kMapOffset));
468   __ lbu(t1, FieldMemOperand(a3, Map::kBitFieldOffset));
476   __ GetInstanceType(a3, a3);
477   __ Branch(runtime_call, lt, a3, Operand(FIRST_JS_RECEIVER_TYPE));
493   __ GetInstanceType(a3, a3);
494   __ Branch(&return_unequal, ne, a3, Operand(ODDBALL_TYPE));
530   CompareICStub_CheckInputType(masm, rhs, a3, right(), &miss);
564   // or in GP registers (a0, a1, a2, a3) depending on the presence of the FPU.
570   // and the right hand side if we have FPU. Otherwise a2, a3 represent
656   __ JumpIfNonSmisNotBothSequentialOneByteStrings(lhs, rhs, a2, a3, &slow);
659                       a3);
661     StringHelper::GenerateFlatOneByteStringEquals(masm, lhs, rhs, a2, a3, t0);
663     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, a2, a3, t0,
974     // a0 = hidden result argument, a1 = argc, a2 = argv, a3 = isolate.
975     __ li(a3, Operand(ExternalReference::isolate_address(isolate())));
1119   // a3: argc
1159   // a3: argc
1219   // a3: argc
1357   __ mov(a3, subject);  // Make a copy of the original subject string.
1359   // a3: subject string
1413   // a3: original subject string
1414   // Load previous index and check range before a3 is overwritten.  We have to
1415   // use a3 instead of subject here because subject might have been only made
1419   __ lw(a3, FieldMemOperand(a3, String::kLengthOffset));
1420   __ Branch(&runtime, ls, a3, Operand(a1));
1428   __ sra(a3, a0, 3);  // a3 is 1 for ASCII, 0 for UC16 (used below).
1440   // a3: encoding of subject string (1 if one_byte, 0 if two_byte);
1497   __ Xor(a3, a3, Operand(1));  // 1 for 2-byte str, 0 for 1-byte.
1504   // Argument 4, a3: End of string data
1507   __ sllv(t1, t0, a3);
1509   __ sllv(t1, a1, a3);
1514   __ sllv(t1, t2, a3);
1515   __ addu(a3, t0, t1);
1621   __ lw(a3, MemOperand(a2, 0));
1624   __ sll(a3, a3, kSmiTagSize);  // Convert to Smi.
1625   __ sw(a3, MemOperand(a0, 0));
1692   // a3 : slot in feedback vector (Smi)
1698                              1 << 7 |  // a3
1719   // a3 : slot in feedback vector (Smi)
1728   __ Lsa(t2, a2, a3, kPointerSizeLog2 - kSmiTagSize);
1772   __ Lsa(t2, a2, a3, kPointerSizeLog2 - kSmiTagSize);
1797   __ Lsa(at, a2, a3, kPointerSizeLog2 - kSmiTagSize);
1808   // a3 : slot in feedback vector (Smi, for RecordCallTarget)
1819   __ Lsa(t1, a2, a3, kPointerSizeLog2 - kSmiTagSize);
1832   __ mov(a3, a1);
1842   __ mov(a3, a1);
2081   __ CheckMap(a0, a3, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
2220   Register tmp2 = a3;
2261   Register tmp2 = a3;
2306   Register tmp2 = a3;
2417   __ lw(a3, FieldMemOperand(a1, HeapObject::kMapOffset));
2419   __ Branch(&miss, ne, a3, Operand(t0));
2554       (ra.bit() | t2.bit() | t1.bit() | t0.bit() | a3.bit() |
2585   Register mask = a3;
2946       __ TailCallStub(&stub, eq, a3, Operand(kind));
2960   // a3 - kind (if mode != DISABLE_ALLOCATION_SITES)
2974     __ And(at, a3, Operand(1));
2999     __ Addu(a3, a3, Operand(1));
3007     // Save the resulting elements kind in type info. We can't just store a3
3022       __ TailCallStub(&stub, eq, a3, Operand(kind));
3089   //  -- a3 : Original constructor
3115   __ Branch(&subclassing, ne, a1, Operand(a3));
3122   __ lw(a3, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
3123   __ SmiUntag(a3);
3125   __ And(a3, a3, Operand(AllocationSite::ElementsKindBits::kMask));
3137   __ Push(a3, a2);
3179     __ lw(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
3181     __ SmiTst(a3, at);
3184     __ GetObjectType(a3, a3, t0);
3190   __ lw(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
3192   // Load the map's "bit field 2" into a3. We only need the first byte,
3194   __ lbu(a3, FieldMemOperand(a3, Map::kBitField2Offset));
3196   __ DecodeField<Map::ElementsKindBits>(a3);
3200     __ Branch(&done, eq, a3, Operand(FAST_ELEMENTS));
3203         a3, Operand(FAST_HOLEY_ELEMENTS));
3208   __ Branch(&fast_elements_case, eq, a3, Operand(FAST_ELEMENTS));