Lines Matching defs:r3
91 __ pop(r3);
120 __ str(r3, FieldMemOperand(r0, JSFunction::kSharedFunctionInfoOffset));
127 __ ldr(r3, FieldMemOperand(r3, SharedFunctionInfo::kCodeOffset));
128 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
129 __ str(r3, FieldMemOperand(r0, JSFunction::kCodeEntryOffset));
137 __ Push(cp, r3, r4);
156 __ ldr(r3, MemOperand(sp, 0));
167 __ str(r3, MemOperand(r0, Context::SlotOffset(Context::CLOSURE_INDEX)));
202 __ ldr(r3, MemOperand(sp, 0));
218 __ JumpIfNotSmi(r3, &after_sentinel);
221 __ cmp(r3, Operand::Zero());
224 __ ldr(r3, GlobalObjectOperand());
225 __ ldr(r3, FieldMemOperand(r3, GlobalObject::kGlobalContextOffset));
226 __ ldr(r3, ContextOperand(r3, Context::CLOSURE_INDEX));
231 __ str(r3, ContextOperand(r0, Context::CLOSURE_INDEX));
260 // r3: boilerplate literal array.
284 __ ldr(r1, FieldMemOperand(r3, i));
292 __ ldr(r3, FieldMemOperand(r3, JSArray::kElementsOffset));
298 __ CopyFields(r2, r3, r1.bit(), elements_size / kPointerSize);
309 // Load boilerplate object into r3 and check if we need to create a
312 __ ldr(r3, MemOperand(sp, 2 * kPointerSize));
314 __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
315 __ ldr(r3, MemOperand(r3, r0, LSL, kPointerSizeLog2 - kSmiTagSize));
316 __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
322 __ ldr(r0, FieldMemOperand(r3, JSArray::kElementsOffset));
360 __ push(r3);
361 __ ldr(r3, FieldMemOperand(r3, JSArray::kElementsOffset));
362 __ ldr(r3, FieldMemOperand(r3, HeapObject::kMapOffset));
363 __ CompareRoot(r3, expected_map_index);
365 __ pop(r3);
387 // Load boilerplate object into r3 and check if we need to create a
390 __ ldr(r3, MemOperand(sp, 3 * kPointerSize));
392 __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
393 __ ldr(r3, MemOperand(r3, r0, LSL, kPointerSizeLog2 - kSmiTagSize));
394 __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
400 __ ldr(r0, FieldMemOperand(r3, HeapObject::kMapOffset));
409 __ ldr(r1, FieldMemOperand(r3, i));
531 __ vmov(r2, r3, d7);
536 // Write Smi from r0 to r3 and r2 in double format.
538 ConvertToDoubleStub stub1(r3, r2, scratch1, scratch2);
558 // Load right operand (r0) to d6 or r2/r3.
560 r0, d7, r2, r3, heap_number_map, scratch1, scratch2, slow);
970 // r3: Right value (sign, exponent, top of mantissa).
983 __ vmov(d1, r2, r3);
1011 if (the_int_.is(r2) && the_heap_number_.is(r0) && scratch_.is(r3)) {
1023 WriteInt32ToHeapNumberStub stub2(r2, r0, r3);
1150 __ Sbfx(r3, r2, HeapNumber::kExponentShift, HeapNumber::kExponentBits);
1152 __ cmp(r3, Operand(-1));
1158 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
1159 __ orr(r0, r3, Operand(r2), SetCC);
1221 // Convert lhs to a double in r2, r3.
1223 ConvertToDoubleStub stub1(r3, r2, r7, r6);
1261 // Load lhs to a double in r2, r3.
1262 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1276 Register lhs_exponent = exp_first ? r2 : r3;
1278 Register lhs_mantissa = exp_first ? r3 : r2;
1329 Register lhs_exponent = exp_first ? r2 : r3;
1331 Register lhs_mantissa = exp_first ? r3 : r2;
1333 // r0, r1, r2, r3 have the two doubles. Neither is a NaN.
1367 __ vmov(d1, r2, r3);
1405 __ CompareObjectType(lhs, r3, r3, FIRST_SPEC_OBJECT_TYPE);
1409 __ cmp(r3, Operand(ODDBALL_TYPE));
1416 __ and_(r2, r2, Operand(r3));
1432 __ CompareObjectType(rhs, r3, r2, HEAP_NUMBER_TYPE);
1435 __ cmp(r2, r3);
1447 __ Ldrd(r2, r3, FieldMemOperand(lhs, HeapNumber::kValueOffset));
1471 __ CompareObjectType(lhs, r3, r3, FIRST_NONSTRING_TYPE);
1473 __ tst(r3, Operand(kIsSymbolMask));
1484 __ CompareObjectType(lhs, r2, r3, FIRST_SPEC_OBJECT_TYPE);
1489 __ ldr(r3, FieldMemOperand(rhs, HeapObject::kMapOffset));
1491 __ ldrb(r3, FieldMemOperand(r3, Map::kBitFieldOffset));
1492 __ and_(r0, r2, Operand(r3));
1600 GenerateLookupNumberStringCache(masm, r1, r0, r2, r3, r4, false, &runtime);
1655 // into r0, r1, r2, and r3.
1660 // VFP3 is supported, or in r0, r1, r2, and r3.
1689 // Compares two doubles in r0, r1, r2, r3 that are not NaNs. Returns the
1706 // or load both doubles into r0, r1, r2, r3 and jump to the code that handles
1730 __ JumpIfNonSmisNotBothSequentialAsciiStrings(lhs_, rhs_, r2, r3, &slow);
1732 r3);
1738 r3,
1745 r3,
1874 if (!tos_.is(r3)) {
1875 __ mov(r3, Operand(tos_));
1879 __ Push(r3, r2, r1);
1958 __ mov(r3, Operand(r0)); // the operand
1962 __ Push(r3, r2, r1, r0);
2073 __ AllocateHeapNumber(r1, r2, r3, r6, &slow_allocate_heapnumber);
2086 __ ldr(r3, FieldMemOperand(r0, HeapNumber::kMantissaOffset));
2088 __ str(r3, FieldMemOperand(r1, HeapNumber::kMantissaOffset));
2103 __ ConvertToInt32(r0, r1, r2, r3, d0, slow);
2120 __ AllocateHeapNumber(r2, r3, r4, r6, &slow_allocate_heapnumber);
2136 __ ConvertToInt32(r0, r1, r3, r4, d0, &impossible);
2442 // Load left and right operands into d6 and d7 or r0/r1 and r2/r3
2513 __ SmiUntag(r3, left);
2516 // Convert operands to 32-bit integers. Right in r2 and left in r3.
2519 r3,
2540 __ orr(r2, r3, Operand(r2));
2543 __ eor(r2, r3, Operand(r2));
2546 __ and_(r2, r3, Operand(r2));
2551 __ mov(r2, Operand(r3, ASR, r2));
2556 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2570 __ mov(r2, Operand(r3, LSL, r2));
2577 __ add(r3, r2, Operand(0x40000000), SetCC);
2601 // Convert the int32 in r2 to the heap number in r0. r3 is corrupted. As
2610 __ sub(r3, r0, Operand(kHeapObjectTag));
2611 __ vstr(d0, r3, HeapNumber::kValueOffset);
2615 // r3 as scratch. r0 is preserved and returned.
2616 WriteInt32ToHeapNumberStub stub(r2, r0, r3);
2771 r3,
2912 // Convert operands to 32-bit integers. Right in r2 and left in r3. The
2917 r3,
2938 __ orr(r2, r3, Operand(r2));
2941 __ eor(r2, r3, Operand(r2));
2944 __ and_(r2, r3, Operand(r2));
2948 __ mov(r2, Operand(r3, ASR, r2));
2952 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2971 __ mov(r2, Operand(r3, LSL, r2));
3013 // r3 as scratch. r0 is preserved and returned.
3015 WriteInt32ToHeapNumberStub stub(r2, r0, r3);
3232 // of the double into r2, r3.
3233 __ IntegerToDoubleConversionWithVFP3(r0, r3, r2);
3244 // low and high words into r2, r3.
3246 __ vmov(r2, r3, d0);
3249 __ vmov(r2, r3, d2);
3253 // r3 = high 32 bits of double value
3256 __ eor(r1, r2, Operand(r3));
3263 // r3 = high 32 bits of double value.
3299 __ cmp(r3, r5, eq);
3346 __ stm(ia, cache_entry, r2.bit() | r3.bit() | r6.bit());
3745 // It's okay to clobber r2 and r3 here. Don't mess with r0 and r1
3748 __ ldr(r3, MemOperand(r2));
3749 __ sub(r3, r3, Operand(1));
3750 __ str(r3, MemOperand(r2));
3782 __ mov(r3, Operand(isolate->factory()->the_hole_value()));
3786 __ str(r3, MemOperand(ip));
3890 // r3: argc
3912 // r3: argc
3925 // r3: argc
3995 // r3: argc
4028 __ pop(r3);
4031 __ str(r3, MemOperand(ip));
4070 Register map = r3; // Map of the object.
4129 // Register mapping: r3 is object map and r4 is function prototype.
4250 __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
4251 __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4261 __ sub(r3, r0, r1);
4262 __ add(r3, fp, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
4263 __ ldr(r0, MemOperand(r3, kDisplacement));
4275 __ sub(r3, r0, r1);
4276 __ add(r3, r2, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
4277 __ ldr(r0, MemOperand(r3, kDisplacement));
4295 __ ldr(r3, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
4296 __ ldr(r2, MemOperand(r3, StandardFrameConstants::kContextOffset));
4301 __ ldr(r2, MemOperand(r3, ArgumentsAdaptorFrameConstants::kLengthOffset));
4303 __ add(r3, r3, Operand(r2, LSL, 1));
4304 __ add(r3, r3, Operand(StandardFrameConstants::kCallerSPOffset));
4305 __ str(r3, MemOperand(sp, 1 * kPointerSize));
4327 __ ldr(r3, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
4328 __ ldr(r2, MemOperand(r3, StandardFrameConstants::kContextOffset));
4338 __ ldr(r2, MemOperand(r3, ArgumentsAdaptorFrameConstants::kLengthOffset));
4339 __ add(r3, r3, Operand(r2, LSL, 1));
4340 __ add(r3, r3, Operand(StandardFrameConstants::kCallerSPOffset));
4341 __ str(r3, MemOperand(sp, 1 * kPointerSize));
4369 __ AllocateInNewSpace(r9, r0, r3, r4, &runtime, TAG_OBJECT);
4391 __ ldr(r3, FieldMemOperand(r4, i));
4392 __ str(r3, FieldMemOperand(r0, i));
4397 __ ldr(r3, MemOperand(sp, 2 * kPointerSize));
4400 __ str(r3, FieldMemOperand(r0, kCalleeOffset));
4421 // Move backing store address to r3, because it is
4423 __ mov(r3, r4, LeaveCC, eq);
4449 __ add(r3, r4, Operand(r6, LSL, 1));
4450 __ add(r3, r3, Operand(kParameterMapHeaderSize));
4454 // r3 = address of backing store (tagged)
4466 __ str(r7, MemOperand(r3, r5));
4474 // r3 = address of backing store (tagged)
4478 __ str(r5, FieldMemOperand(r3, FixedArray::kMapOffset));
4479 __ str(r2, FieldMemOperand(r3, FixedArray::kLengthOffset));
4490 __ add(r5, r3, Operand(r9, LSL, 1));
4517 __ ldr(r3, MemOperand(r2, StandardFrameConstants::kContextOffset));
4518 __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4529 __ add(r3, r2, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize));
4530 __ add(r3, r3, Operand(StandardFrameConstants::kCallerSPOffset));
4531 __ str(r3, MemOperand(sp, 1 * kPointerSize));
4548 r3,
4560 __ CopyFields(r0, r4, r3
4580 __ LoadRoot(r3, Heap::kFixedArrayMapRootIndex);
4581 __ str(r3, FieldMemOperand(r4, FixedArray::kMapOffset));
4593 __ ldr(r3, MemOperand(r2, kPointerSize, NegPreIndex));
4595 __ str(r3, MemOperand(r4, kPointerSize, PostIndex));
4694 // Get the length of the string to r3.
4695 __ ldr(r3, FieldMemOperand(subject, String::kLengthOffset));
4698 // r3: Length of subject string as a smi
4705 __ cmp(r3, Operand(r0));
4800 __ mov(r3, Operand(r0, ASR, 2), SetCC);
4809 // r3: encoding of subject string (1 if ASCII, 0 if two_byte);
4819 // r3: encoding of subject string (1 if ASCII, 0 if two_byte);
4858 __ eor(r3, r3, Operand(1));
4865 // Argument 4, r3: End of string data
4868 __ add(r9, r8, Operand(r9, LSL, r3));
4869 __ add(r2, r9, Operand(r1, LSL, r3));
4873 __ add(r3, r9, Operand(r8, LSL, r3));
4987 __ ldr(r3, MemOperand(r2, kPointerSize, PostIndex));
4989 __ mov(r3, Operand(r3, LSL, kSmiTagSize));
4990 __ str(r3, MemOperand(r0, kPointerSize, PostIndex));
5051 r3, // Scratch register.
5064 __ add(r3, r0, Operand(JSRegExpResult::kSize));
5067 __ str(r3, FieldMemOperand(r0, JSObject::kElementsOffset));
5082 // r3: FixedArray, tagged.
5087 __ str(r2, FieldMemOperand(r3, HeapObject::kMapOffset));
5090 __ str(r6, FieldMemOperand(r3, FixedArray::kLengthOffset));
5093 __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
5097 // r3: Start of elements in FixedArray.
5104 __ str(r2, MemOperand(r3, r5, LSL, kPointerSizeLog2));
5129 // Load the cache state into r3.
5130 __ ldr(r3, FieldMemOperand(r2, JSGlobalPropertyCell::kValueOffset));
5134 __ cmp(r3, r1);
5136 __ CompareRoot(r3, Heap::kUndefinedValueRootIndex);
5141 __ CompareRoot(r3, Heap::kTheHoleValueRootIndex);
5214 __ GetBuiltinEntry(r3, Builtins::CALL_FUNCTION_PROXY);
5228 __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
5244 __ CompareObjectType(r1, r3, r3, JS_FUNCTION_TYPE);
5258 // r3: object type
5261 __ cmp(r3, Operand(JS_FUNCTION_PROXY_TYPE));
5263 __ GetBuiltinEntry(r3, Builtins::CALL_FUNCTION_PROXY_AS_CONSTRUCTOR);
5267 __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION_AS_CONSTRUCTOR);
5846 __ Ldrd(r2, r3, MemOperand(sp, kToOffset));
5853 __ mov(r3, Operand(r3, ASR, 1), SetCC, cc);
5859 // Both r2 and r3 are untagged integers.
5860 __ sub(r2, r2, Operand(r3), SetCC, pl);
5888 __ add(r0, r0, Operand(r3));
5889 __ ldrb(r3, FieldMemOperand(r0, SeqAsciiString::kHeaderSize));
5895 masm, r3, r4, r1, r5, r6, r7, r9, &make_two_character_string);
5899 // r3: two characters combined into halfword in little endian byte order.
5902 __ strh(r3, FieldMemOperand(r0, SeqAsciiString::kHeaderSize));
5911 // r3: from index (untagged)
5935 __ add(r3, r3, Operand(r4, ASR, 1)); // Add offset to index.
5952 // r3: adjusted start index (untagged)
5971 __ mov(r3, Operand(r3, LSL, 1));
5973 __ str(r3, FieldMemOperand(r0, SlicedString::kOffsetOffset));
5982 // r3: adjusted start index (untagged)
6013 __ add(r5, r5, r3);
6022 StringHelper::GenerateCopyCharactersLong(masm, r1, r5, r2, r3, r4, r6, r7, r9,
6032 __ add(r5, r5, Operand(r3, LSL, 1));
6042 masm, r1, r5, r2, r3, r4, r6, r7, r9, DEST_ALWAYS_ALIGNED);
6046 __ IncrementCounter(counters->sub_string_native(), 1, r3, r4);
6187 __ JumpIfNotBothSequentialAsciiStrings(r1, r0, r2, r3, &runtime);
6190 __ IncrementCounter(counters->string_compare_native(), 1, r2, r3);
6192 GenerateCompareFlatAsciiStrings(masm, r1, r0, r2, r3, r4, r5);
6234 masm, 1 * kPointerSize, r0, r2, r3, r4, r5, &call_builtin);
6239 masm, 0 * kPointerSize, r1, r2, r3, r4, r5, &call_builtin);
6253 __ ldr(r3, FieldMemOperand(r1, String::kLengthOffset));
6259 __ cmp(r3, Operand(Smi::FromInt(0)), ne);
6262 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6270 __ mov(r3, Operand(r3, ASR, kSmiTagSize));
6275 // r3: length of second string
6282 __ add(r6, r2, Operand(r3));
6300 __ ldrb(r3, FieldMemOperand(r1, SeqAsciiString::kHeaderSize));
6306 masm, r2, r3, r6, r7, r4, r5, r9, &make_two_character_string);
6307 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6320 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6357 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6386 // r3: length of second string
6440 // r3: length of second string.
6453 // r3: length of second string.
6457 StringHelper::GenerateCopyCharacters(masm, r6, r1, r3, r4, true);
6458 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6469 // r3: length of second string.
6473 StringHelper::GenerateCopyCharacters(masm, r6, r1, r3, r4, false);
6474 __ IncrementCounter(counters->string_add_native(), 1, r2, r3);
6630 Register tmp2 = r3;
6670 Register tmp2 = r3;
6763 __ ldr(r3, FieldMemOperand(r1, HeapObject::kMapOffset));
6766 __ cmp(r3, Operand(known_map_));
6897 (lr.bit() | r6.bit() | r5.bit() | r4.bit() | r3.bit() |
6968 r3.bit() | r2.bit() | r1.bit() | r0.bit()) &
7007 Register mask = r3;
7097 { REG(r3), REG(r4), REG(r5), EMIT_REMEMBERED_SET },
7101 { REG(r1), REG(r2), REG(r3), EMIT_REMEMBERED_SET },
7102 { REG(r3), REG(r2), REG(r1), EMIT_REMEMBERED_SET },
7104 { REG(r2), REG(r1), REG(r3), EMIT_REMEMBERED_SET },
7105 { REG(r3), REG(r1), REG(r2), EMIT_REMEMBERED_SET },
7107 { REG(r3), REG(r2), REG(r4), EMIT_REMEMBERED_SET },
7108 { REG(r2), REG(r3), REG(r4), EMIT_REMEMBERED_SET },
7112 { REG(r2), REG(r3), REG(r9), EMIT_REMEMBERED_SET },
7113 { REG(r2), REG(r3), REG(r9), OMIT_REMEMBERED_SET },
7362 // -- r3 : element index as smi
7381 __ Push(r1, r3, r0);
7390 __ add(r6, r5, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
7402 __ add(r6, r5, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
7409 __ StoreNumberToDoubleElements(r0, r3, r1, r5, r6, r7, r9, r2,
