Lines Matching defs:r2
90 r2,
100 __ ldr(r2, MemOperand(cp, Context::SlotOffset(Context::GLOBAL_INDEX)));
101 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset));
102 __ ldr(r2, MemOperand(r2, Context::SlotOffset(map_index)));
103 __ str(r2, FieldMemOperand(r0, HeapObject::kMapOffset));
108 __ LoadRoot(r2, Heap::kTheHoleValueRootIndex);
112 __ str(r2, FieldMemOperand(r0, JSFunction::kPrototypeOrInitialMapOffset));
145 r2,
153 __ LoadRoot(r2, Heap::kContextMapRootIndex);
154 __ str(r2, FieldMemOperand(r0, HeapObject::kMapOffset));
155 __ mov(r2, Operand(Smi::FromInt(length)));
156 __ str(r2, FieldMemOperand(r0, FixedArray::kLengthOffset));
233 r2,
249 __ add(r2, r0, Operand(JSArray::kSize));
250 __ str(r2, FieldMemOperand(r0, JSArray::kElementsOffset));
253 __ CopyFields(r2, r3, r1.bit(), elements_size / kPointerSize);
378 // either d7 and d6 or in r2/r3 and r0/r1 respectively. If the destination is
388 // either d7 and d6 or in r2/r3 and r0/r1 respectively. If the destination is
476 // r2: Right value (least significant part of mantissa).
510 __ vmov(r2, r3, d7);
515 // Write Smi from r0 to r3 and r2 in double format.
517 ConvertToDoubleStub stub1(r3, r2, scratch1, scratch2);
537 // Load right operand (r0) to d6 or r2/r3.
539 r0, d7, r2, r3, heap_number_map, scratch1, scratch2, slow);
936 // r2: Right value (least significant part of mantissa).
1041 __ LoadRoot(r2, Heap::kUndefinedValueRootIndex);
1042 __ cmp(r0, r2);
1079 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
1081 __ Sbfx(r3, r2, HeapNumber::kExponentShift, HeapNumber::kExponentBits);
1087 __ mov(r2, Operand(r2, LSL, HeapNumber::kNonMantissaBitsInTopWord));
1090 __ orr(r0, r3, Operand(r2), SetCC);
1153 // Convert lhs to a double in r2, r3.
1155 ConvertToDoubleStub stub1(r3, r2, r7, r6);
1193 // Load lhs to a double in r2, r3.
1194 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1208 Register lhs_exponent = exp_first ? r2 : r3;
1210 Register lhs_mantissa = exp_first ? r3 : r2;
1261 Register lhs_exponent = exp_first ? r2 : r3;
1263 Register lhs_mantissa = exp_first ? r3 : r2;
1265 // r0, r1, r2, r3 have the two doubles. Neither is a NaN.
1314 // Get the type of the first operand into r2 and compare it with
1316 __ CompareObjectType(rhs, r2, r2, FIRST_JS_OBJECT_TYPE);
1326 __ cmp(r2, Operand(ODDBALL_TYPE));
1340 __ and_(r2, r2, Operand(r3));
1341 __ tst(r2, Operand(kIsSymbolMask));
1356 __ CompareObjectType(rhs, r3, r2, HEAP_NUMBER_TYPE);
1358 __ ldr(r2, FieldMemOperand(lhs, HeapObject::kMapOffset));
1359 __ cmp(r2, r3);
1371 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1387 // r2 is object type of rhs.
1391 __ tst(r2, Operand(kIsNotStringMask));
1393 __ tst(r2, Operand(kIsSymbolMask));
1406 __ cmp(r2, Operand(FIRST_JS_OBJECT_TYPE));
1408 __ CompareObjectType(lhs, r2, r3, FIRST_JS_OBJECT_TYPE);
1414 __ ldrb(r2, FieldMemOperand(r2, Map::kBitFieldOffset));
1416 __ and_(r0, r2, Operand(r3));
1524 GenerateLookupNumberStringCache(masm, r1, r0, r2, r3, r4, false, &runtime);
1546 __ orr(r2, r1, r0);
1547 __ tst(r2, Operand(kSmiTagMask));
1554 __ orr(r2, r1, r0);
1555 __ tst(r2, Operand(kSmiTagMask));
1570 __ and_(r2, lhs_, Operand(rhs_));
1571 __ tst(r2, Operand(kSmiTagMask));
1581 // into r0, r1, r2, and r3.
1586 // VFP3 is supported, or in r0, r1, r2, and r3.
1615 // Compares two doubles in r0, r1, r2, r3 that are not NaNs. Returns the
1632 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
1634 // In this case r2 will contain the type of rhs_. Never falls through.
1648 // Assumes that r2 is the type of rhs_ on entry.
1656 __ JumpIfNonSmisNotBothSequentialAsciiStrings(lhs_, rhs_, r2, r3, &slow);
1658 __ IncrementCounter(isolate->counters()->string_compare_native(), 1, r2, r3);
1662 r2,
1784 __ mov(r2, Operand(Smi::FromInt(MinorKey())));
1787 __ Push(r2, r1, r0);
2007 // Load left and right operands into d6 and d7 or r0/r1 and r2/r3
2079 __ SmiUntag(r2, right);
2081 // Convert operands to 32-bit integers. Right in r2 and left in r3.
2093 r2,
2105 __ orr(r2, r3, Operand(r2));
2108 __ eor(r2, r3, Operand(r2));
2111 __ and_(r2, r3, Operand(r2));
2115 __ GetLeastBitsFromInt32(r2, r2, 5);
2116 __ mov(r2, Operand(r3, ASR, r2));
2120 __ GetLeastBitsFromInt32(r2, r2, 5);
2121 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2134 __ GetLeastBitsFromInt32(r2, r2, 5);
2135 __ mov(r2, Operand(r3, LSL, r2));
2142 __ add(r3, r2, Operand(0x40000000), SetCC);
2144 __ SmiTag(r0, r2);
2158 // r2: Answer as signed int32.
2166 // Convert the int32 in r2 to the heap number in r0. r3 is corrupted. As
2169 __ vmov(s0, r2);
2179 // Tail call that writes the int32 in r2 to the heap number in r0, using
2181 WriteInt32ToHeapNumberStub stub(r2, r0, r3);
2307 r2,
2447 // Convert operands to 32-bit integers. Right in r2 and left in r3. The
2461 r2,
2473 __ orr(r2, r3, Operand(r2));
2476 __ eor(r2, r3, Operand(r2));
2479 __ and_(r2, r3, Operand(r2));
2482 __ and_(r2, r2, Operand(0x1f));
2483 __ mov(r2, Operand(r3, ASR, r2));
2486 __ and_(r2, r2, Operand(0x1f));
2487 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2489 // We only get a negative result if the shift value (r2) is 0.
2504 __ and_(r2, r2, Operand(0x1f));
2505 __ mov(r2, Operand(r3, LSL, r2));
2512 __ add(scratch1, r2, Operand(0x40000000), SetCC);
2516 __ SmiTag(r0, r2);
2532 __ vmov(double_scratch.low(), r2);
2536 __ vmov(double_scratch.low(), r2);
2546 // Tail call that writes the int32 in r2 to the heap number in r0, using
2549 WriteInt32ToHeapNumberStub stub(r2, r0, r3);
2638 __ CompareObjectType(left, r2, r2, FIRST_NONSTRING_TYPE);
2648 r2, r2, FIRST_NONSTRING_TYPE);
2764 // of the double into r2, r3.
2765 __ IntegerToDoubleConversionWithVFP3(r0, r3, r2);
2776 // low and high words into r2, r3.
2778 __ vmov(r2, r3, d0);
2781 __ vmov(r2, r3, d2);
2784 // r2 = low 32 bits of double value
2788 __ eor(r1, r2, Operand(r3));
2794 // r2 = low 32 bits of double value.
2830 __ cmp(r2, r4);
2874 __ stm(ia, cache_entry, r2.bit() | r3.bit() | r6.bit());
2999 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3000 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3001 __ str(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3003 __ AllocateHeapNumber(r1, r2, r3, r6, &slow);
3005 __ ldr(r2, FieldMemOperand(r0, HeapNumber::kExponentOffset));
3007 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3008 __ str(r2, FieldMemOperand(r1, HeapNumber::kExponentOffset));
3032 __ ConvertToInt32(r0, r1, r2, r3, d0, &slow);
3038 __ add(r2, r1, Operand(0x40000000), SetCC);
3048 __ AllocateHeapNumber(r2, r3, r4, r6, &slow);
3049 __ mov(r0, Operand(r2));
3053 // Convert the int32 in r1 to the heap number in r0. r2 is corrupted.
3057 __ sub(r2, r0, Operand(kHeapObjectTag));
3058 __ vstr(d0, r2, HeapNumber::kValueOffset);
3062 WriteInt32ToHeapNumberStub stub(r1, r0, r2);
3145 __ mov(r2, exponent);
3176 __ vmov(r2, r3, double_exponent);
3256 __ mov(r2, Operand(ExternalReference::isolate_address()));
3275 // It's okay to clobber r2 and r3 here. Don't mess with r0 and r1
3277 __ mov(r2, Operand(scope_depth));
3278 __ ldr(r3, MemOperand(r2));
3280 __ str(r3, MemOperand(r2));
3286 // Lower 2 bits of r2 are 0 iff r0 has failure tag.
3287 __ add(r2, r0, Operand(1));
3288 __ tst(r2, Operand(kFailureTagMask));
3405 // r2: receiver
3425 // r2: receiver
3438 // r2: receiver
3508 // r2: receiver
3590 const Register scratch = r2;
3647 // Get prototype of object into r2.
3765 __ ldr(r2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
3766 __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
3786 __ ldr(r0, MemOperand(r2, ArgumentsAdaptorFrameConstants::kLengthOffset));
3792 __ add(r3, r2, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
3811 __ ldr(r2, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
3812 __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
3822 __ ldr(r1, MemOperand(r2, ArgumentsAdaptorFrameConstants::kLengthOffset));
3824 __ add(r3, r2, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize));
3843 r2,
3878 __ ldr(r2, MemOperand(sp, 1 * kPointerSize));
3894 // Pre-decrement r2 with kPointerSize on each iteration.
3896 __ ldr(r3, MemOperand(r2, kPointerSize, NegPreIndex));
3984 __ ldr(r2,
3990 __ add(r2, r2, Operand(2)); // r2 was a smi.
3992 __ cmp(r2, Operand(OffsetsVector::kStaticOffsetsVectorSize));
3995 // r2: Number of capture registers
4006 // r2: Number of capture registers
4018 // r2: Number of capture registers
4038 __ add(r2, r2, Operand(RegExpImpl::kLastMatchOverhead));
4039 __ cmp(r2, Operand(r0, ASR, kSmiTagSize));
4109 __ IncrementCounter(isolate->counters()->regexp_entry_native(), 1, r0, r2);
4130 __ mov(r2, Operand(address_of_regexp_stack_memory_size));
4131 __ ldr(r2, MemOperand(r2, 0));
4132 __ add(r0, r0, Operand(r2));
4148 // Argument 3 (r2): Start of string data
4149 __ add(r2, r9, Operand(r1, LSL, r3));
4187 __ mov(r2, Operand(ExternalReference(Isolate::k_pending_exception_address,
4189 __ ldr(r0, MemOperand(r2, 0));
4193 __ str(r1, MemOperand(r2, 0)); // Clear pending exception.
4224 __ mov(r2, Operand(r1, LSL, kSmiTagSize + kSmiShiftSize)); // To smi.
4225 __ str(r2, FieldMemOperand(last_match_info_elements,
4232 __ RecordWrite(r3, Operand(RegExpImpl::kLastSubjectOffset), r2, r7);
4237 __ RecordWrite(r3, Operand(RegExpImpl::kLastInputOffset), r2, r7);
4242 __ mov(r2, Operand(address_of_static_offsets_vector));
4245 // r2: offsets vector
4256 __ ldr(r3, MemOperand(r2, kPointerSize, PostIndex));
4295 __ add(r2, r5, Operand(objects_size));
4297 r2, // In: Size, in words.
4311 __ ldr(r2, ContextOperand(cp, Context::GLOBAL_INDEX));
4314 __ ldr(r2, FieldMemOperand(r2, GlobalObject::kGlobalContextOffset));
4316 __ ldr(r2, ContextOperand(r2, Context::REGEXP_RESULT_MAP_INDEX));
4318 __ str(r2, FieldMemOperand(r0, HeapObject::kMapOffset));
4334 __ mov(r2, Operand(FACTORY->fixed_array_map()));
4335 __ str(r2, FieldMemOperand(r3, HeapObject::kMapOffset));
4340 __ mov(r2, Operand(FACTORY->the_hole_value()));
4344 // r2: the hole.
4352 __ str(r2, MemOperand(r3, r5, LSL, kPointerSizeLog2));
4379 __ CompareObjectType(r1, r2, r2, FIRST_JS_OBJECT_TYPE);
4401 __ CompareObjectType(r1, r2, r2, JS_FUNCTION_TYPE);
4415 __ mov(r2, Operand(0, RelocInfo::NONE));
5132 __ mov(r2, Operand(to, ASR, 1), SetCC);
5140 __ sub(r2, r2, Operand(r3), SetCC);
5145 __ cmp(r2, Operand(2));
5148 // r2: length
5162 // r2: length
5189 // r2: length
5200 // r2: result string length.
5211 __ cmp(r2, Operand(2));
5229 // r2: result string length.
5232 __ AllocateAsciiString(r0, r2, r4, r5, r9, &runtime);
5241 __ AllocateAsciiString(r0, r2, r3, r4, r1, &runtime);
5244 // r2: result string length.
5255 // r2: result string length.
5258 StringHelper::GenerateCopyCharactersLong(masm, r1, r5, r2, r3, r4, r6, r7, r9,
5265 // r2: result string length.
5271 __ AllocateTwoByteString(r0, r2, r1, r3, r4, &runtime);
5274 // r2: result string length.
5287 // r2: result length.
5291 masm, r1, r5, r2, r3, r4, r6, r7, r9, DEST_ALWAYS_ALIGNED);
5377 __ IncrementCounter(counters->string_compare_native(), 1, r1, r2);
5384 __ JumpIfNotBothSequentialAsciiStrings(r1, r0, r2, r3, &runtime);
5387 __ IncrementCounter(counters->string_compare_native(), 1, r2, r3);
5389 GenerateCompareFlatAsciiStrings(masm, r1, r0, r2, r3, r4, r5);
5431 masm, 1 * kPointerSize, r0, r2, r3, r4, r5, &call_builtin);
5436 masm, 0 * kPointerSize, r1, r2, r3, r4, r5, &call_builtin);
5449 __ ldr(r2, FieldMemOperand(r0, String::kLengthOffset));
5452 __ cmp(r2, Operand(Smi::FromInt(0))); // Test if first string is empty.
5459 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5466 __ mov(r2, Operand(r2, ASR, kSmiTagSize));
5471 // r2: length of first string
5479 __ add(r6, r2, Operand(r3));
5496 __ ldrb(r2, FieldMemOperand(r0, SeqAsciiString::kHeaderSize));
5503 masm, r2, r3, r6, r7, r4, r5, r9, &make_two_character_string);
5504 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5510 // are combined into single halfword in r2 register.
5516 __ strh(r2, FieldMemOperand(r0, SeqAsciiString::kHeaderSize));
5517 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5554 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5580 // r2: length of first string
5600 // r2: length of first string.
5622 // r2: length of first string.
5626 StringHelper::GenerateCopyCharacters(masm, r6, r0, r2, r4, true);
5636 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5644 // r2: length of first string.
5650 // r2: length of first string.
5661 // r2: length of first string.
5665 StringHelper::GenerateCopyCharacters(masm, r6, r0, r2, r4, false);
5677 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
5744 __ orr(r2, r1, r0);
5745 __ tst(r2, Operand(kSmiTagMask));
5769 __ and_(r2, r1, Operand(r0));
5770 __ tst(r2, Operand(kSmiTagMask));
5773 __ CompareObjectType(r0, r2, r2, HEAP_NUMBER_TYPE);
5775 __ CompareObjectType(r1, r2, r2, HEAP_NUMBER_TYPE);
5784 __ sub(r2, r1, Operand(kHeapObjectTag));
5785 __ vldr(d0, r2, HeapNumber::kValueOffset);
5786 __ sub(r2, r0, Operand(kHeapObjectTag));
5787 __ vldr(d1, r2, HeapNumber::kValueOffset);
5816 __ and_(r2, r1, Operand(r0));
5817 __ tst(r2, Operand(kSmiTagMask));
5820 __ CompareObjectType(r0, r2, r2, JS_OBJECT_TYPE);
5822 __ CompareObjectType(r1, r2, r2, JS_OBJECT_TYPE);
5848 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
5853 __ Jump(r2);
5866 __ mov(r2, Operand(function));
5869 __ Jump(r2); // Call the api function.
