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

Lines Matching refs:a3
398     __ GetObjectType(rhs, a3, a3);
399     __ Branch(&return_not_equal, greater, a3, Operand(FIRST_JS_RECEIVER_TYPE));
402     __ Branch(&return_not_equal, eq, a3, Operand(ODDBALL_TYPE));
407     __ Or(a2, a2, Operand(a3));
419   __ GetObjectType(lhs, a3, a2);
423   __ Branch(slow, ne, a3, Operand(a2));
449   __ GetObjectType(rhs, a3, a3);
450   __ Branch(runtime_call, ge, a3, Operand(FIRST_NONSTRING_TYPE));
451   __ And(at, a3, Operand(kIsNotInternalizedMask));
462   __ ld(a3, FieldMemOperand(rhs, HeapObject::kMapOffset));
464   __ lbu(t1, FieldMemOperand(a3, Map::kBitFieldOffset));
472   __ GetInstanceType(a3, a3);
473   __ Branch(runtime_call, lt, a3, Operand(FIRST_JS_RECEIVER_TYPE));
489   __ GetInstanceType(a3, a3);
490   __ Branch(&return_unequal, ne, a3, Operand(ODDBALL_TYPE));
526   CompareICStub_CheckInputType(masm, rhs, a3, right(), &miss);
561   // or in GP registers (a0, a1, a2, a3) depending on the presence of the FPU.
567   // and the right hand side if we have FPU. Otherwise a2, a3 represent
653   __ JumpIfNonSmisNotBothSequentialOneByteStrings(lhs, rhs, a2, a3, &slow);
656                       a3);
658     StringHelper::GenerateFlatOneByteStringEquals(masm, lhs, rhs, a2, a3, a4);
660     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, a2, a3, a4,
971     // a0 = hidden result argument, a1 = argc, a2 = argv, a3 = isolate.
972     __ li(a3, Operand(ExternalReference::isolate_address(isolate())));
1117   // a3: argc
1155   // a3: argc
1215   // a3: argc
1352   __ mov(a3, subject);  // Make a copy of the original subject string.
1355   // a3: subject string
1412   // a3: original subject string
1413   // Load previous index and check range before a3 is overwritten.  We have to
1414   // use a3 instead of subject here because subject might have been only made
1418   __ ld(a3, FieldMemOperand(a3, String::kLengthOffset));
1419   __ Branch(&runtime, ls, a3, Operand(a1));
1427   __ dsra(a3, a0, 3);  // a3 is 1 for one_byte, 0 for UC16 (used below).
1439   // a3: encoding of subject string (1 if one_byte, 0 if two_byte);
1496   __ Xor(a3, a3, Operand(1));  // 1 for 2-byte str, 0 for 1-byte.
1503   // Argument 4, a3: End of string data
1506   __ dsllv(t1, t0, a3);
1508   __ dsllv(t1, a1, a3);
1514   __ dsllv(t1, t2, a3);
1515   __ daddu(a3, t0, t1);
1621   __ lw(a3, MemOperand(a2, 0));
1624   __ SmiTag(a3);
1625   __ sd(a3, MemOperand(a0, 0));
1692   // a3 : slot in feedback vector (Smi)
1698                              1 << 7 |  // a3
1719   // a3 : slot in feedback vector (Smi)
1728   __ dsrl(a5, a3, 32 - kPointerSizeLog2);
1773   __ dsrl(a5, a3, 32 - kPointerSizeLog2);
1800   __ SmiScale(a4, a3, kPointerSizeLog2);
1812   // a3 : slot in feedback vector (Smi, for RecordCallTarget)
1823   __ dsrl(at, a3, 32 - kPointerSizeLog2);
1837   __ mov(a3, a1);
1847   __ mov(a3, a1);
2088   __ CheckMap(a0, a3, Heap::kBooleanMapRootIndex, &miss, DO_SMI_CHECK);
2227   Register tmp2 = a3;
2268   Register tmp2 = a3;
2313   Register tmp2 = a3;
2424   __ ld(a3, FieldMemOperand(a1, HeapObject::kMapOffset));
2426   __ Branch(&miss, ne, a3, Operand(a4));
2562       (ra.bit() | a6.bit() | a5.bit() | a4.bit() | a3.bit() |
2593   Register mask = a3;
2955       __ TailCallStub(&stub, eq, a3, Operand(kind));
2969   // a3 - kind (if mode != DISABLE_ALLOCATION_SITES)
2983     __ And(at, a3, Operand(1));
3007     __ Daddu(a3, a3, Operand(1));
3015     // Save the resulting elements kind in type info. We can't just store a3
3030       __ TailCallStub(&stub, eq, a3, Operand(kind));
3097   //  -- a3 : new target
3123   __ Branch(&subclassing, ne, a1, Operand(a3));
3130   __ ld(a3, FieldMemOperand(a2, AllocationSite::kTransitionInfoOffset));
3131   __ SmiUntag(a3);
3133   __ And(a3, a3, Operand(AllocationSite::ElementsKindBits::kMask));
3145   __ Push(a3, a2);
3187     __ ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
3189     __ SmiTst(a3, at);
3192     __ GetObjectType(a3, a3, a4);
3198   __ ld(a3, FieldMemOperand(a1, JSFunction::kPrototypeOrInitialMapOffset));
3200   // Load the map's "bit field 2" into a3. We only need the first byte,
3202   __ lbu(a3, FieldMemOperand(a3, Map::kBitField2Offset));
3204   __ DecodeField<Map::ElementsKindBits>(a3);
3208     __ Branch(&done, eq, a3, Operand(FAST_ELEMENTS));
3211         a3, Operand(FAST_HOLEY_ELEMENTS));
3216   __ Branch(&fast_elements_case, eq, a3, Operand(FAST_ELEMENTS));