Lines Matching refs:__
62 #define __ down_cast<ArmAssembler*>(codegen->GetAssembler())->
71 __ Bind(GetEntryLabel());
95 __ Bind(GetEntryLabel());
120 __ Bind(GetEntryLabel());
127 __ b(GetReturnLabel());
129 __ b(arm_codegen->GetLabelOf(successor_));
163 __ Bind(GetEntryLabel());
205 __ Bind(GetEntryLabel());
209 __ LoadImmediate(calling_convention.GetRegisterAt(0), cls_->GetTypeIndex());
227 __ b(GetExitLabel());
258 __ Bind(GetEntryLabel());
263 __ LoadImmediate(calling_convention.GetRegisterAt(0), string_index);
270 __ b(GetExitLabel());
292 __ Bind(GetEntryLabel());
328 __ b(GetExitLabel());
349 __ Bind(GetEntryLabel());
370 __ Bind(GetEntryLabel());
399 __ b(GetExitLabel());
433 __ Bind(GetEntryLabel());
447 __ b(GetExitLabel());
477 // __ LoadFromOffset(kLoadWord, out, out, offset);
498 __ Bind(GetEntryLabel());
535 __ Mov(free_reg, index_reg);
548 __ Lsl(index_reg, index_reg, TIMES_4);
552 __ AddConstant(index_reg, index_reg, offset_);
587 __ LoadImmediate(calling_convention.GetRegisterAt(2), offset_);
598 __ b(GetExitLabel());
650 __ Bind(GetEntryLabel());
664 __ b(GetExitLabel());
676 #undef __
677 #define __ down_cast<ArmAssembler*>(GetAssembler())->
743 __ StoreToOffset(kStoreWord, static_cast<Register>(reg_id), SP, stack_index);
748 __ LoadFromOffset(kLoadWord, static_cast<Register>(reg_id), SP, stack_index);
753 __ StoreSToOffset(static_cast<SRegister>(reg_id), SP, stack_index);
758 __ LoadSFromOffset(static_cast<SRegister>(reg_id), SP, stack_index);
801 __ FinalizeCode();
806 uint32_t new_position = __ GetAdjustedPosition(old_position);
812 frame_entry_interval->start = __ GetAdjustedPosition(frame_entry_interval->start);
813 frame_entry_interval->end = __ GetAdjustedPosition(frame_entry_interval->end);
815 it.second.start = __ GetAdjustedPosition(it.second.start);
816 it.second.end = __ GetAdjustedPosition(it.second.end);
819 it.code_interval.start = __ GetAdjustedPosition(it.code_interval.start);
820 it.code_interval.end = __ GetAdjustedPosition(it.code_interval.end);
902 __ Bind(&frame_entry_label_);
909 __ AddConstant(IP, SP, -static_cast<int32_t>(GetStackOverflowReservedBytes(kArm)));
910 __ LoadFromOffset(kLoadWord, IP, IP, 0);
914 __ PushList(core_spill_mask_);
915 __ cfi().AdjustCFAOffset(kArmWordSize * POPCOUNT(core_spill_mask_));
916 __ cfi().RelOffsetForMany(DWARFReg(kMethodRegisterArgument), 0, core_spill_mask_, kArmWordSize);
919 __ vpushs(start_register, POPCOUNT(fpu_spill_mask_));
920 __ cfi().AdjustCFAOffset(kArmWordSize * POPCOUNT(fpu_spill_mask_));
921 __ cfi().RelOffsetForMany(DWARFReg(S0), 0, fpu_spill_mask_, kArmWordSize);
924 __ AddConstant(SP, -adjust);
925 __ cfi().AdjustCFAOffset(adjust);
926 __ StoreToOffset(kStoreWord, kMethodRegisterArgument, SP, 0);
931 __ bx(LR);
934 __ cfi().RememberState();
936 __ AddConstant(SP, adjust);
937 __ cfi().AdjustCFAOffset(-adjust);
940 __ vpops(start_register, POPCOUNT(fpu_spill_mask_));
941 __ cfi().AdjustCFAOffset(-kArmPointerSize * POPCOUNT(fpu_spill_mask_));
942 __ cfi().RestoreMany(DWARFReg(SRegister(0)), fpu_spill_mask_);
947 __ PopList(pop_mask);
948 __ cfi().RestoreState();
949 __ cfi().DefCFAOffset(GetFrameSize());
954 __ BindTrackedLabel(label);
1073 __ Mov(destination.AsRegister<Register>(), source.AsRegister<Register>());
1075 __ vmovrs(destination.AsRegister<Register>(), source.AsFpuRegister<SRegister>());
1077 __ LoadFromOffset(kLoadWord, destination.AsRegister<Register>(), SP, source.GetStackIndex());
1081 __ vmovsr(destination.AsFpuRegister<SRegister>(), source.AsRegister<Register>());
1083 __ vmovs(destination.AsFpuRegister<SRegister>(), source.AsFpuRegister<SRegister>());
1085 __ LoadSFromOffset(destination.AsFpuRegister<SRegister>(), SP, source.GetStackIndex());
1090 __ StoreToOffset(kStoreWord, source.AsRegister<Register>(), SP, destination.GetStackIndex());
1092 __ StoreSToOffset(source.AsFpuRegister<SRegister>(), SP, destination.GetStackIndex());
1095 __ LoadFromOffset(kLoadWord, IP, SP, source.GetStackIndex());
1096 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
1117 __ vmovrrd(destination.AsRegisterPairLow<Register>(),
1123 __ LoadFromOffset(kLoadWordPair, destination.AsRegisterPairLow<Register>(),
1128 __ LoadDFromOffset(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()),
1132 __ vmovdrr(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()),
1144 __ StoreToOffset(kStoreWord, R1, SP, destination.GetStackIndex());
1145 __ StoreToOffset(kStoreWord, R2, SP, destination.GetHighStackIndex(kArmWordSize));
1147 __ StoreToOffset(kStoreWordPair, source.AsRegisterPairLow<Register>(),
1151 __ StoreDToOffset(FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()),
1169 __ LoadImmediate(location.AsRegister<Register>(), value);
1204 __ LoadFromOffset(kLoadWord, LR, TR, entry_point_offset);
1205 __ blx(LR);
1226 __ b(codegen_->GetLabelOf(successor));
1259 __ vmstat(); // transfer FP status register to ARM APSR.
1260 __ b(true_label, ARMFPCondition(cond->GetCondition(), cond->IsGtBias()));
1315 __ CmpConstant(left_high, val_high);
1317 __ b(true_label, ARMCondition(true_high_cond));
1319 __ b(false_label, ARMCondition(false_high_cond));
1321 __ b(true_label, ARMCondition(true_high_cond));
1322 __ b(false_label, ARMCondition(false_high_cond));
1325 __ CmpConstant(left_low, val_low);
1330 __ cmp(left_high, ShifterOperand(right_high));
1332 __ b(true_label, ARMCondition(true_high_cond));
1334 __ b(false_label, ARMCondition(false_high_cond));
1336 __ b(true_label, ARMCondition(true_high_cond));
1337 __ b(false_label, ARMCondition(false_high_cond));
1340 __ cmp(left_low, ShifterOperand(right_low));
1344 __ b(true_label, final_condition);
1366 __ vcmps(left.AsFpuRegister<SRegister>(), right.AsFpuRegister<SRegister>());
1370 __ vcmpd(FromLowSToD(left.AsFpuRegisterPairLow<SRegister>()),
1379 __ b(false_target);
1383 __ Bind(&fallthrough_target);
1400 __ b(true_target);
1405 __ b(false_target);
1424 __ CompareAndBranchIfZero(cond_val.AsRegister<Register>(), false_target);
1426 __ CompareAndBranchIfNonZero(cond_val.AsRegister<Register>(), true_target);
1446 __ cmp(left, ShifterOperand(right.AsRegister<Register>()));
1449 __ CmpConstant(left, CodeGenerator::GetInt32ValueOf(right.GetConstant()));
1452 __ b(false_target, ARMCondition(condition->GetOppositeCondition()));
1454 __ b(true_target, ARMCondition(condition->GetCondition()));
1461 __ b(false_target);
1521 __ Bind(&false_target);
1533 __ nop();
1582 __ cmp(left.AsRegister<Register>(), ShifterOperand(right.AsRegister<Register>()));
1585 __ CmpConstant(left.AsRegister<Register>(),
1588 __ it(ARMCondition(cond->GetCondition()), kItElse);
1589 __ mov(locations->Out().AsRegister<Register>(), ShifterOperand(1),
1591 __ mov(locations->Out().AsRegister<Register>(), ShifterOperand(0),
1599 __ vcmps(left.AsFpuRegister<SRegister>(), right.AsFpuRegister<SRegister>());
1603 __ vcmpd(FromLowSToD(left.AsFpuRegisterPairLow<SRegister>()),
1613 __ Bind(&false_label);
1614 __ LoadImmediate(out, 0);
1615 __ b(&done_label);
1618 __ Bind(&true_label);
1619 __ LoadImmediate(out, 1);
1620 __ Bind(&done_label);
1880 __ LoadImmediate(hidden_reg, invoke->GetDexMethodIndex());
1883 __ LoadFromOffset(kLoadWord, temp, SP, receiver.GetStackIndex());
1885 __ LoadFromOffset(kLoadWord, temp, temp, class_offset);
1888 __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
1898 __ MaybeUnpoisonHeapReference(temp);
1899 __ LoadFromOffset(kLoadWord, temp, temp,
1904 __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
1908 __ LoadFromOffset(kLoadWord, LR, temp, entry_point);
1910 __ blx(LR);
1948 __ rsb(out.AsRegister<Register>(), in.AsRegister<Register>(), ShifterOperand(0));
1954 __ rsbs(out.AsRegisterPairLow<Register>(),
1963 __ sbc(out.AsRegisterPairHigh<Register>(),
1967 __ sub(out.AsRegisterPairHigh<Register>(),
1974 __ vnegs(out.AsFpuRegister<SRegister>(), in.AsFpuRegister<SRegister>());
1979 __ vnegd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2219 __ sbfx(out.AsRegister<Register>(), in.AsRegisterPairLow<Register>(), 0, 8);
2227 __ sbfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 8);
2240 __ sbfx(out.AsRegister<Register>(), in.AsRegisterPairLow<Register>(), 0, 16);
2248 __ sbfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 16);
2263 __ Mov(out.AsRegister<Register>(), in.AsRegisterPairLow<Register>());
2265 __ LoadFromOffset(kLoadWord, out.AsRegister<Register>(), SP, in.GetStackIndex());
2270 __ LoadImmediate(out.AsRegister<Register>(), static_cast<int32_t>(value));
2277 __ vmovs(temp, in.AsFpuRegister<SRegister>());
2278 __ vcvtis(temp, temp);
2279 __ vmovrs(out.AsRegister<Register>(), temp);
2287 __ vmovd(temp_d, FromLowSToD(in.AsFpuRegisterPairLow<SRegister>()));
2288 __ vcvtid(temp_s, temp_d);
2289 __ vmovrs(out.AsRegister<Register>(), temp_s);
2310 __ Mov(out.AsRegisterPairLow<Register>(), in.AsRegister<Register>());
2312 __ Asr(out.AsRegisterPairHigh<Register>(),
2345 __ ubfx(out.AsRegister<Register>(), in.AsRegisterPairLow<Register>(), 0, 16);
2353 __ ubfx(out.AsRegister<Register>(), in.AsRegister<Register>(), 0, 16);
2371 __ vmovsr(out.AsFpuRegister<SRegister>(), in.AsRegister<Register>());
2372 __ vcvtsi(out.AsFpuRegister<SRegister>(), out.AsFpuRegister<SRegister>());
2387 __ vcvtsd(out.AsFpuRegister<SRegister>(),
2406 __ vmovsr(out.AsFpuRegisterPairLow<SRegister>(), in.AsRegister<Register>());
2407 __ vcvtdi(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2424 __ vmovsr(temp_s, high);
2425 __ vcvtdi(temp_d, temp_s);
2427 __ LoadDImmediate(constant_d, bit_cast<double, int64_t>(k2Pow32EncodingForDouble));
2429 __ vmovsr(out_s, low);
2430 __ vcvtdu(out_d, out_s);
2432 __ vmlad(out_d, temp_d, constant_d);
2438 __ vcvtds(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2493 __ add(out.AsRegister<Register>(),
2497 __ AddConstant(out.AsRegister<Register>(),
2505 __ adds(out.AsRegisterPairLow<Register>(),
2508 __ adc(out.AsRegisterPairHigh<Register>(),
2515 __ vadds(out.AsFpuRegister<SRegister>(),
2521 __ vaddd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2568 __ sub(out.AsRegister<Register>(),
2572 __ AddConstant(out.AsRegister<Register>(),
2581 __ subs(out.AsRegisterPairLow<Register>(),
2584 __ sbc(out.AsRegisterPairHigh<Register>(),
2591 __ vsubs(out.AsFpuRegister<SRegister>(),
2598 __ vsubd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2642 __ mul(out.AsRegister<Register>(),
2668 __ mul(IP, in1_lo, in2_hi);
2670 __ mla(out_hi, in1_hi, in2_lo, IP);
2672 __ umull(out_lo, IP, in1_lo, in2_lo);
2674 __ add(out_hi, out_hi, ShifterOperand(IP));
2679 __ vmuls(out.AsFpuRegister<SRegister>(),
2686 __ vmuld(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
2711 __ LoadImmediate(out, 0);
2714 __ Mov(out, dividend);
2716 __ rsb(out, dividend, ShifterOperand(0));
2737 __ Lsr(temp, dividend, 32 - ctz_imm);
2739 __ Asr(temp, dividend, 31);
2740 __ Lsr(temp, temp, 32 - ctz_imm);
2742 __ add(out, temp, ShifterOperand(dividend));
2745 __ Asr(out, out, ctz_imm);
2747 __ rsb(out, out, ShifterOperand(0));
2750 __ ubfx(out, out, 0, ctz_imm);
2751 __ sub(out, out, ShifterOperand(temp));
2773 __ LoadImmediate(temp1, magic);
2774 __ smull(temp2, temp1, dividend, temp1);
2777 __ add(temp1, temp1, ShifterOperand(dividend));
2779 __ sub(temp1, temp1, ShifterOperand(dividend));
2783 __ Asr(temp1, temp1, shift);
2787 __ sub(out, temp1, ShifterOperand(temp1, ASR, 31));
2789 __ sub(temp1, temp1, ShifterOperand(temp1, ASR, 31));
2791 __ LoadImmediate(temp2, imm);
2792 __ mls(out, temp1, temp2, dividend);
2894 __ sdiv(out.AsRegister<Register>(),
2924 __ vdivs(out.AsFpuRegister<SRegister>(),
2931 __ vdivd(FromLowSToD(out.AsFpuRegisterPairLow<SRegister>()),
3039 __ sdiv(temp, reg1, reg2);
3040 __ mls(out.AsRegister<Register>(), temp, reg2, reg1);
3101 __ CompareAndBranchIfZero(value.AsRegister<Register>(), slow_path->GetEntryLabel());
3105 __ b(slow_path->GetEntryLabel());
3112 __ orrs(IP,
3115 __ b(slow_path->GetEntryLabel(), EQ);
3119 __ b(slow_path->GetEntryLabel());
3142 __ Ror(out, in, rot);
3144 __ Mov(out, in);
3147 __ Ror(out, in, rhs.AsRegister<Register>());
3175 __ Lsr(out_reg_hi, in_reg_hi, rot);
3176 __ orr(out_reg_hi, out_reg_hi, ShifterOperand(in_reg_lo, arm::LSL, kArmBitsPerWord - rot));
3177 __ Lsr(out_reg_lo, in_reg_lo, rot);
3178 __ orr(out_reg_lo, out_reg_lo, ShifterOperand(in_reg_hi, arm::LSL, kArmBitsPerWord - rot));
3180 __ Mov(out_reg_lo, in_reg_lo);
3181 __ Mov(out_reg_hi, in_reg_hi);
3189 __ and_(shift_right, rhs.AsRegister<Register>(), ShifterOperand(0x1F));
3190 __ Lsrs(shift_left, rhs.AsRegister<Register>(), 6);
3191 __ rsb(shift_left, shift_right, ShifterOperand(kArmBitsPerWord), AL, kCcKeep);
3192 __ b(&shift_by_32_plus_shift_right, CC);
3196 __ Lsl(out_reg_hi, in_reg_hi, shift_left);
3197 __ Lsr(out_reg_lo, in_reg_lo, shift_right);
3198 __ add(out_reg_hi, out_reg_hi, ShifterOperand(out_reg_lo));
3199 __ Lsl(out_reg_lo, in_reg_lo, shift_left);
3200 __ Lsr(shift_left, in_reg_hi, shift_right);
3201 __ add(out_reg_lo, out_reg_lo, ShifterOperand(shift_left));
3202 __ b(&end);
3204 __ Bind(&shift_by_32_plus_shift_right); // Shift by 32+shift_right.
3207 __ Lsr(out_reg_hi, in_reg_hi, shift_right);
3208 __ Lsl(out_reg_lo, in_reg_lo, shift_left);
3209 __ add(out_reg_hi, out_reg_hi, ShifterOperand(out_reg_lo));
3210 __ Lsr(out_reg_lo, in_reg_lo, shift_right);
3211 __ Lsl(shift_right, in_reg_hi, shift_left);
3212 __ add(out_reg_lo, out_reg_lo, ShifterOperand(shift_right));
3214 __ Bind(&end);
3318 __ and_(out_reg, second_reg, ShifterOperand(kMaxIntShiftDistance));
3320 __ Lsl(out_reg, first_reg, out_reg);
3322 __ Asr(out_reg, first_reg, out_reg);
3324 __ Lsr(out_reg, first_reg, out_reg);
3330 __ Mov(out_reg, first_reg);
3332 __ Lsl(out_reg, first_reg, shift_value);
3334 __ Asr(out_reg, first_reg, shift_value);
3336 __ Lsr(out_reg, first_reg, shift_value);
3354 __ and_(o_l, second_reg, ShifterOperand(kMaxLongShiftDistance));
3356 __ Lsl(o_h, high, o_l);
3358 __ rsb(temp, o_l, ShifterOperand(kArmBitsPerWord));
3359 __ Lsr(temp, low, temp);
3360 __ orr(o_h, o_h, ShifterOperand(temp));
3362 __ subs(temp, o_l, ShifterOperand(kArmBitsPerWord));
3363 __ it(PL);
3364 __ Lsl(o_h, low, temp, PL);
3366 __ Lsl(o_l, low, o_l);
3368 __ and_(o_h, second_reg, ShifterOperand(kMaxLongShiftDistance));
3370 __ Lsr(o_l, low, o_h);
3372 __ rsb(temp, o_h, ShifterOperand(kArmBitsPerWord));
3373 __ Lsl(temp, high, temp);
3374 __ orr(o_l, o_l, ShifterOperand(temp));
3376 __ subs(temp, o_h, ShifterOperand(kArmBitsPerWord));
3377 __ it(PL);
3378 __ Asr(o_l, high, temp, PL);
3380 __ Asr(o_h, high, o_h);
3382 __ and_(o_h, second_reg, ShifterOperand(kMaxLongShiftDistance));
3384 __ Lsr(o_l, low, o_h);
3385 __ rsb(temp, o_h, ShifterOperand(kArmBitsPerWord));
3386 __ Lsl(temp, high, temp);
3387 __ orr(o_l, o_l, ShifterOperand(temp));
3388 __ subs(temp, o_h, ShifterOperand(kArmBitsPerWord));
3389 __ it(PL);
3390 __ Lsr(o_l, high, temp, PL);
3391 __ Lsr(o_h, high, o_h);
3401 __ Lsl(o_h, low, shift_value - 32);
3402 __ LoadImmediate(o_l, 0);
3404 __ Asr(o_l, high, shift_value - 32);
3405 __ Asr(o_h, high, 31);
3407 __ Lsr(o_l, high, shift_value - 32);
3408 __ LoadImmediate(o_h, 0);
3412 __ mov(o_h, ShifterOperand(low));
3413 __ LoadImmediate(o_l, 0);
3415 __ mov(o_l, ShifterOperand(high));
3416 __ Asr(o_h, high, 31);
3418 __ mov(o_l, ShifterOperand(high));
3419 __ LoadImmediate(o_h, 0);
3423 __ Lsls(o_l, low, 1);
3424 __ adc(o_h, high, ShifterOperand(high));
3426 __ Asrs(o_h, high, 1);
3427 __ Rrx(o_l, low);
3429 __ Lsrs(o_h, high, 1);
3430 __ Rrx(o_l, low);
3435 __ Lsl(o_h, high, shift_value);
3436 __ orr(o_h, o_h, ShifterOperand(low, LSR, 32 - shift_value));
3437 __ Lsl(o_l, low, shift_value);
3439 __ Lsr(o_l, low, shift_value);
3440 __ orr(o_l, o_l, ShifterOperand(high, LSL, 32 - shift_value));
3441 __ Asr(o_h, high, shift_value);
3443 __ Lsr(o_l, low, shift_value);
3444 __ orr(o_l, o_l, ShifterOperand(high, LSL, 32 - shift_value));
3445 __ Lsr(o_h, high, shift_value);
3501 __ LoadFromOffset(kLoadWord, temp, TR, QUICK_ENTRY_POINT(pNewEmptyString));
3502 __ LoadFromOffset(kLoadWord, LR, temp, code_offset.Int32Value());
3503 __ blx(LR);
3526 __ LoadImmediate(calling_convention.GetRegisterAt(0), instruction->GetTypeIndex());
3576 __ mvn(out.AsRegister<Register>(), ShifterOperand(in.AsRegister<Register>()));
3580 __ mvn(out.AsRegisterPairLow<Register>(),
3582 __ mvn(out.AsRegisterPairHigh<Register>(),
3602 __ eor(out.AsRegister<Register>(), in.AsRegister<Register>(), ShifterOperand(1));
3648 __ LoadImmediate(out, 0);
3649 __ cmp(left.AsRegister<Register>(),
3655 __ cmp(left.AsRegisterPairHigh<Register>(),
3657 __ b(&less, LT);
3658 __ b(&greater, GT);
3660 __ LoadImmediate(out, 0);
3661 __ cmp(left.AsRegisterPairLow<Register>(),
3668 __ LoadImmediate(out, 0);
3670 __ vcmps(left.AsFpuRegister<SRegister>(), right.AsFpuRegister<SRegister>());
3672 __ vcmpd(FromLowSToD(left.AsFpuRegisterPairLow<SRegister>()),
3675 __ vmstat(); // transfer FP status register to ARM APSR.
3684 __ b(&done, EQ);
3685 __ b(&less, less_cond);
3687 __ Bind(&greater);
3688 __ LoadImmediate(out, 1);
3689 __ b(&done);
3691 __ Bind(&less);
3692 __ LoadImmediate(out, -1);
3694 __ Bind(&done);
3727 __ dmb(flavor);
3738 __ LoadImmediate(out_lo, offset);
3739 __ add(IP, addr, ShifterOperand(out_lo));
3742 __ ldrexd(out_lo, out_hi, addr);
3754 __ LoadImmediate(temp1, offset);
3755 __ add(IP, addr, ShifterOperand(temp1));
3758 __ Bind(&fail);
3761 __ ldrexd(temp1, temp2, addr);
3763 __ strexd(temp1, value_lo, value_hi, addr);
3764 __ CompareAndBranchIfNonZero(temp1, &fail);
3833 __ StoreToOffset(kStoreByte, value.AsRegister<Register>(), base, offset);
3839 __ StoreToOffset(kStoreHalfword, value.AsRegister<Register>(), base, offset);
3851 __ Mov(temp, value.AsRegister<Register>());
3852 __ PoisonHeapReference(temp);
3853 __ StoreToOffset(kStoreWord, temp, base, offset);
3855 __ StoreToOffset(kStoreWord, value.AsRegister<Register>(), base, offset);
3869 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), base, offset);
3876 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), base, offset);
3886 __ vmovrrd(value_reg_lo, value_reg_hi, value_reg);
3895 __ StoreDToOffset(value_reg, base, offset);
4024 __ LoadFromOffset(kLoadUnsignedByte, out.AsRegister<Register>(), base, offset);
4028 __ LoadFromOffset(kLoadSignedByte, out.AsRegister<Register>(), base, offset);
4032 __ LoadFromOffset(kLoadSignedHalfword, out.AsRegister<Register>(), base, offset);
4036 __ LoadFromOffset(kLoadUnsignedHalfword, out.AsRegister<Register>(), base, offset);
4040 __ LoadFromOffset(kLoadWord, out.AsRegister<Register>(), base, offset);
4055 __ LoadFromOffset(kLoadWord, out.AsRegister<Register>(), base, offset);
4074 __ LoadFromOffset(kLoadWordPair, out.AsRegisterPairLow<Register>(), base, offset);
4079 __ LoadSFromOffset(out.AsFpuRegister<SRegister>(), base, offset);
4089 __ vmovdrr(out_reg, lo, hi);
4091 __ LoadDFromOffset(out_reg, base, offset);
4236 __ LoadFromOffset(kLoadWord, IP, obj.AsRegister<Register>(), 0);
4247 __ CompareAndBranchIfZero(obj.AsRegister<Register>(), slow_path->GetEntryLabel());
4296 __ LoadFromOffset(kLoadUnsignedByte, out, obj, offset);
4298 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>()));
4299 __ LoadFromOffset(kLoadUnsignedByte, out, IP, data_offset);
4310 __ LoadFromOffset(kLoadSignedByte, out, obj, offset);
4312 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>()));
4313 __ LoadFromOffset(kLoadSignedByte, out, IP, data_offset);
4324 __ LoadFromOffset(kLoadSignedHalfword, out, obj, offset);
4326 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2));
4327 __ LoadFromOffset(kLoadSignedHalfword, out, IP, data_offset);
4338 __ LoadFromOffset(kLoadUnsignedHalfword, out, obj, offset);
4340 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2));
4341 __ LoadFromOffset(kLoadUnsignedHalfword, out, IP, data_offset);
4352 __ LoadFromOffset(kLoadWord, out, obj, offset);
4354 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4355 __ LoadFromOffset(kLoadWord, out, IP, data_offset);
4378 __ LoadFromOffset(kLoadWord, out, obj, offset);
4385 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4386 __ LoadFromOffset(kLoadWord, out, IP, data_offset);
4403 __ LoadFromOffset(kLoadWordPair, out_loc.AsRegisterPairLow<Register>(), obj, offset);
4405 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8));
4406 __ LoadFromOffset(kLoadWordPair, out_loc.AsRegisterPairLow<Register>(), IP, data_offset);
4416 __ LoadSFromOffset(out, obj, offset);
4418 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4419 __ LoadSFromOffset(out, IP, data_offset);
4429 __ LoadDFromOffset(FromLowSToD(out), obj, offset);
4431 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8));
4432 __ LoadDFromOffset(FromLowSToD(out), IP, data_offset);
4497 __ StoreToOffset(kStoreByte, value, array, offset);
4499 __ add(IP, array, ShifterOperand(index.AsRegister<Register>()));
4500 __ StoreToOffset(kStoreByte, value, IP, data_offset);
4512 __ StoreToOffset(kStoreHalfword, value, array, offset);
4514 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_2));
4515 __ StoreToOffset(kStoreHalfword, value, IP, data_offset);
4531 __ StoreToOffset(kStoreWord, source, array, offset);
4534 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4535 __ StoreToOffset(kStoreWord, source, IP, data_offset);
4557 __ CompareAndBranchIfNonZero(value, &non_zero);
4561 __ StoreToOffset(kStoreWord, value, array, offset);
4564 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4565 __ StoreToOffset(kStoreWord, value, IP, data_offset);
4568 __ b(&done);
4569 __ Bind(&non_zero);
4576 // __ Mov(temp2, temp1);
4578 // __ LoadFromOffset(kLoadWord, temp1, temp1, component_offset);
4583 // __ LoadFromOffset(kLoadWord, temp2, value, class_offset);
4587 // __ cmp(temp1, ShifterOperand(temp2));
4598 __ b(slow_path->GetEntryLabel());
4601 __ LoadFromOffset(kLoadWord, temp1, array, class_offset);
4603 __ MaybeUnpoisonHeapReference(temp1);
4606 __ LoadFromOffset(kLoadWord, temp1, temp1, component_offset);
4608 __ LoadFromOffset(kLoadWord, temp2, value, class_offset);
4611 __ cmp(temp1, ShifterOperand(temp2));
4615 __ b(&do_put, EQ);
4618 __ MaybeUnpoisonHeapReference(temp1);
4621 __ LoadFromOffset(kLoadWord, temp1, temp1, super_offset);
4624 __ CompareAndBranchIfNonZero(temp1, slow_path->GetEntryLabel());
4625 __ Bind(&do_put);
4627 __ b(slow_path->GetEntryLabel(), NE);
4637 __ Mov(temp1, value);
4638 __ PoisonHeapReference(temp1);
4645 __ StoreToOffset(kStoreWord, source, array, offset);
4648 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4649 __ StoreToOffset(kStoreWord, source, IP, data_offset);
4659 __ Bind(&done);
4663 __ Bind(slow_path->GetExitLabel());
4675 __ StoreToOffset(kStoreWord, value, array, offset);
4678 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4679 __ StoreToOffset(kStoreWord, value, IP, data_offset);
4690 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), array, offset);
4692 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8));
4693 __ StoreToOffset(kStoreWordPair, value.AsRegisterPairLow<Register>(), IP, data_offset);
4704 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), array, offset);
4706 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
4707 __ StoreSToOffset(value.AsFpuRegister<SRegister>(), IP, data_offset);
4718 __ StoreDToOffset(FromLowSToD(value.AsFpuRegisterPairLow<SRegister>()), array, offset);
4720 __ add(IP, array, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_8));
4721 __ StoreDToOffset(FromLowSToD(value.AsFpuRegisterPairLow<SRegister>()), IP, data_offset);
4750 __ LoadFromOffset(kLoadWord, out, obj, offset);
4775 __ cmp(index, ShifterOperand(length));
4776 __ b(slow_path->GetEntryLabel(), HS);
4786 __ CompareAndBranchIfZero(value, &is_null);
4788 __ LoadFromOffset(kLoadWord, card, TR, Thread::CardTableOffset<kArmWordSize>().Int32Value());
4789 __ Lsr(temp, object, gc::accounting::CardTable::kCardShift);
4790 __ strb(card, Address(card, temp));
4792 __ Bind(&is_null);
4838 __ LoadFromOffset(
4841 __ CompareAndBranchIfNonZero(IP, slow_path->GetEntryLabel());
4842 __ Bind(slow_path->GetReturnLabel());
4844 __ CompareAndBranchIfZero(IP, codegen_->GetLabelOf(successor));
4845 __ b(slow_path->GetEntryLabel());
4860 __ Mov(destination.AsRegister<Register>(), source.AsRegister<Register>());
4862 __ vmovsr(destination.AsFpuRegister<SRegister>(), source.AsRegister<Register>());
4865 __ StoreToOffset(kStoreWord, source.AsRegister<Register>(),
4870 __ LoadFromOffset(kLoadWord, destination.AsRegister<Register>(),
4873 __ LoadSFromOffset(destination.AsFpuRegister<SRegister>(), SP, source.GetStackIndex());
4876 __ LoadFromOffset(kLoadWord, IP, SP, source.GetStackIndex());
4877 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
4881 __ vmovrs(destination.AsRegister<Register>(), source.AsFpuRegister<SRegister>());
4883 __ vmovs(destination.AsFpuRegister<SRegister>(), source.AsFpuRegister<SRegister>());
4886 __ StoreSToOffset(source.AsFpuRegister<SRegister>(), SP, destination.GetStackIndex());
4890 __ LoadDFromOffset(DTMP, SP, source.GetStackIndex());
4891 __ StoreDToOffset(DTMP, SP, destination.GetStackIndex());
4894 __ LoadFromOffset(
4898 __ LoadDFromOffset(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()),
4904 __ Mov(destination.AsRegisterPairLow<Register>(), source.AsRegisterPairLow<Register>());
4905 __ Mov(destination.AsRegisterPairHigh<Register>(), source.AsRegisterPairHigh<Register>());
4907 __ vmovdrr(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()),
4913 __ StoreToOffset(
4918 __ vmovrrd(destination.AsRegisterPairLow<Register>(),
4922 __ vmovd(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()),
4926 __ StoreDToOffset(FromLowSToD(source.AsFpuRegisterPairLow<SRegister>()),
4936 __ LoadImmediate(destination.AsRegister<Register>(), value);
4939 __ LoadImmediate(IP, value);
4940 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
4945 __ LoadImmediate(destination.AsRegisterPairLow<Register>(), Low32Bits(value));
4946 __ LoadImmediate(destination.AsRegisterPairHigh<Register>(), High32Bits(value));
4949 __ LoadImmediate(IP, Low32Bits(value));
4950 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
4951 __ LoadImmediate(IP, High32Bits(value));
4952 __ StoreToOffset(kStoreWord, IP, SP, destination.GetHighStackIndex(kArmWordSize));
4957 __ LoadDImmediate(FromLowSToD(destination.AsFpuRegisterPairLow<SRegister>()), value);
4961 __ LoadImmediate(IP, Low32Bits(int_value));
4962 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
4963 __ LoadImmediate(IP, High32Bits(int_value));
4964 __ StoreToOffset(kStoreWord, IP, SP, destination.GetHighStackIndex(kArmWordSize));
4970 __ LoadSImmediate(destination.AsFpuRegister<SRegister>(), value);
4973 __ LoadImmediate(IP, bit_cast<int32_t, float>(value));
4974 __ StoreToOffset(kStoreWord, IP, SP, destination.GetStackIndex());
4981 __ Mov(IP, reg);
4982 __ LoadFromOffset(kLoadWord, reg, SP, mem);
4983 __ StoreToOffset(kStoreWord, IP, SP, mem);
4989 __ LoadFromOffset(kLoadWord, static_cast<Register>(ensure_scratch.GetRegister()),
4991 __ LoadFromOffset(kLoadWord, IP, SP, mem2 + stack_offset);
4992 __ StoreToOffset(kStoreWord, static_cast<Register>(ensure_scratch.GetRegister()),
4994 __ StoreToOffset(kStoreWord, IP, SP, mem1 + stack_offset);
5005 __ Mov(IP, source.AsRegister<Register>());
5006 __ Mov(source.AsRegister<Register>(), destination.AsRegister<Register>());
5007 __ Mov(destination.AsRegister<Register>(), IP);
5015 __ vmovrs(IP, source.AsFpuRegister<SRegister>());
5016 __ vmovs(source.AsFpuRegister<SRegister>(), destination.AsFpuRegister<SRegister>());
5017 __ vmovsr(destination.AsFpuRegister<SRegister>(), IP);
5019 __ vmovdrr(DTMP, source.AsRegisterPairLow<Register>(), source.AsRegisterPairHigh<Register>());
5020 __ Mov(source.AsRegisterPairLow<Register>(), destination.AsRegisterPairLow<Register>());
5021 __ Mov(source.AsRegisterPairHigh<Register>(), destination.AsRegisterPairHigh<Register>());
5022 __ vmovrrd(destination.AsRegisterPairLow<Register>(),
5033 __ vmovdrr(DTMP, low_reg, static_cast<Register>(low_reg + 1));
5034 __ LoadFromOffset(kLoadWordPair, low_reg, SP, mem);
5035 __ StoreDToOffset(DTMP, SP, mem);
5039 __ vmovd(DTMP, first);
5040 __ vmovd(first, second);
5041 __ vmovd(second, DTMP);
5049 __ vmovd(DTMP, reg);
5050 __ LoadDFromOffset(reg, SP, mem);
5051 __ StoreDToOffset(DTMP, SP, mem);
5059 __ vmovrs(IP, reg);
5060 __ LoadSFromOffset(reg, SP, mem);
5061 __ StoreToOffset(kStoreWord, IP, SP, mem);
5071 __ Push(static_cast<Register>(reg));
5075 __ Pop(static_cast<Register>(reg));
5112 __ LoadFromOffset(kLoadWord,
5125 __ CompareAndBranchIfZero(out, slow_path->GetEntryLabel());
5130 __ Bind(slow_path->GetExitLabel());
5156 __ LoadFromOffset(kLoadWord, IP, class_reg, mirror::Class::StatusOffset().Int32Value());
5157 __ cmp(IP, ShifterOperand(mirror::Class::kStatusInitialized));
5158 __ b(slow_path->GetEntryLabel(), LT);
5161 __ dmb(ISH);
5162 __ Bind(slow_path->GetExitLabel());
5227 __ LoadLiteral(out, codegen_->DeduplicateBootImageStringLiteral(load->GetDexFile(),
5235 __ BindTrackedLabel(&labels->movw_label);
5236 __ movw(out, /* placeholder */ 0u);
5237 __ BindTrackedLabel(&labels->movt_label);
5238 __ movt(out, /* placeholder */ 0u);
5239 __ BindTrackedLabel(&labels->add_pc_label);
5240 __ add(out, out, ShifterOperand(PC));
5247 __ LoadLiteral(out, codegen_->DeduplicateBootImageAddressLiteral(address));
5262 __ LoadLiteral(out, codegen_->DeduplicateDexCacheAddressLiteral(base_address));
5280 __ LoadFromOffset(kLoadWord, out, out, mirror::Class::DexCacheStringsOffset().Int32Value());
5294 __ CompareAndBranchIfZero(out, slow_path->GetEntryLabel());
5295 __ Bind(slow_path->GetExitLabel());
5311 __ LoadFromOffset(kLoadWord, out, TR, GetExceptionTlsOffset());
5319 __ LoadImmediate(IP, 0);
5320 __ StoreToOffset(kStoreWord, IP, TR, GetExceptionTlsOffset());
5396 __ CompareAndBranchIfZero(obj, &zero);
5404 __ cmp(out, ShifterOperand(cls));
5406 __ b(&zero, NE);
5407 __ LoadImmediate(out, 1);
5408 __ b(&done);
5416 __ Bind(&loop);
5420 __ CompareAndBranchIfZero(out, &done);
5421 __ cmp(out, ShifterOperand(cls));
5422 __ b(&loop, NE);
5423 __ LoadImmediate(out, 1);
5425 __ b(&done);
5433 __ Bind(&loop);
5434 __ cmp(out, ShifterOperand(cls));
5435 __ b(&success, EQ);
5438 __ CompareAndBranchIfNonZero(out, &loop);
5440 __ b(&done);
5441 __ Bind(&success);
5442 __ LoadImmediate(out, 1);
5444 __ b(&done);
5452 __ cmp(out, ShifterOperand(cls));
5453 __ b(&exact_check, EQ);
5458 __ CompareAndBranchIfZero(out, &done);
5459 __ LoadFromOffset(kLoadUnsignedHalfword, out, out, primitive_offset);
5461 __ CompareAndBranchIfNonZero(out, &zero);
5462 __ Bind(&exact_check);
5463 __ LoadImmediate(out, 1);
5464 __ b(&done);
5469 __ cmp(out, ShifterOperand(cls));
5474 __ b(slow_path->GetEntryLabel(), NE);
5475 __ LoadImmediate(out, 1);
5477 __ b(&done);
5506 __ b(slow_path->GetEntryLabel());
5508 __ b(&done);
5515 __ Bind(&zero);
5516 __ LoadImmediate(out, 0);
5520 __ Bind(&done);
5524 __ Bind(slow_path->GetExitLabel());
5591 __ CompareAndBranchIfZero(obj, &done);
5600 __ cmp(temp, ShifterOperand(cls));
5603 __ b(type_check_slow_path->GetEntryLabel(), NE);
5611 __ Bind(&loop);
5618 __ CompareAndBranchIfNonZero(temp, &compare_classes);
5627 __ b(type_check_slow_path->GetEntryLabel());
5629 __ Bind(&compare_classes);
5630 __ cmp(temp, ShifterOperand(cls));
5631 __ b(&loop, NE);
5638 __ Bind(&loop);
5639 __ cmp(temp, ShifterOperand(cls));
5640 __ b(&done, EQ);
5647 __ CompareAndBranchIfNonZero(temp, &loop);
5656 __ b(type_check_slow_path->GetEntryLabel());
5663 __ cmp(temp, ShifterOperand(cls));
5664 __ b(&done, EQ);
5674 __ CompareAndBranchIfNonZero(temp, &check_non_primitive_component_type);
5683 __ b(type_check_slow_path->GetEntryLabel());
5685 __ Bind(&check_non_primitive_component_type);
5686 __ LoadFromOffset(kLoadUnsignedHalfword, temp, temp, primitive_offset);
5688 __ CompareAndBranchIfZero(temp, &done);
5693 __ b(type_check_slow_path->GetEntryLabel());
5716 __ b(type_check_slow_path->GetEntryLabel());
5719 __ Bind(&done);
5721 __ Bind(type_check_slow_path->GetExitLabel());
5796 __ bic(out_reg, first_reg, second_reg);
5799 __ orn(out_reg, first_reg, second_reg);
5820 __ bic(out_low, first_low, second_low);
5821 __ bic(out_high, first_high, second_high);
5824 __ orn(out_low, first_low, second_low);
5825 __ orn(out_high, first_high, second_high);
5840 __ mov(out, ShifterOperand(first));
5845 __ mov(out, ShifterOperand(0));
5849 if (__ ShifterOperandCanHold(kNoRegister, kNoRegister, AND, value, &so)) {
5850 __ and_(out, first, so);
5852 DCHECK(__ ShifterOperandCanHold(kNoRegister, kNoRegister, BIC, ~value, &so));
5853 __ bic(out, first, ShifterOperand(~value));
5861 __ mov(out, ShifterOperand(first));
5866 __ mvn(out, ShifterOperand(0));
5870 if (__ ShifterOperandCanHold(kNoRegister, kNoRegister, ORR, value, &so)) {
5871 __ orr(out, first, so);
5873 DCHECK(__ ShifterOperandCanHold(kNoRegister, kNoRegister, ORN, ~value, &so));
5874 __ orn(out, first, ShifterOperand(~value));
5882 __ mov(out, ShifterOperand(first));
5886 __ eor(out, first, ShifterOperand(value));
5936 __ and_(out_reg, first_reg, second_reg);
5938 __ orr(out_reg, first_reg, second_reg);
5941 __ eor(out_reg, first_reg, second_reg);
5952 __ and_(out_low, first_low, second_low);
5953 __ and_(out_high, first_high, second_high);
5955 __ orr(out_low, first_low, second_low);
5956 __ orr(out_high, first_high, second_high);
5959 __ eor(out_low, first_low, second_low);
5960 __ eor(out_high, first_high, second_high);
5982 __ Mov(maybe_temp.AsRegister<Register>(), out_reg);
5984 __ LoadFromOffset(kLoadWord, out_reg, out_reg, offset);
5990 __ LoadFromOffset(kLoadWord, out_reg, out_reg, offset);
5991 __ MaybeUnpoisonHeapReference(out_reg);
6012 __ LoadFromOffset(kLoadWord, out_reg, obj_reg, offset);
6018 __ LoadFromOffset(kLoadWord, out_reg, obj_reg, offset);
6019 __ MaybeUnpoisonHeapReference(out_reg);
6039 __ LoadFromOffset(kLoadWord, root_reg, obj, offset);
6054 __ LoadFromOffset(
6056 __ CompareAndBranchIfNonZero(IP, slow_path->GetEntryLabel());
6057 __ Bind(slow_path->GetExitLabel());
6062 __ AddConstant(root_reg, obj, offset);
6069 __ LoadFromOffset(kLoadWord, root_reg, obj, offset);
6140 __ LoadFromOffset(kLoadWord, temp_reg, obj, monitor_offset);
6148 __ Lsr(temp_reg, temp_reg, LockWord::kReadBarrierStateShift);
6149 __ and_(temp_reg, temp_reg, ShifterOperand(LockWord::kReadBarrierStateMask));
6158 __ bic(IP, temp_reg, ShifterOperand(LockWord::kReadBarrierStateMask));
6161 __ add(obj, obj, ShifterOperand(IP));
6173 __ LoadFromOffset(kLoadWord, ref_reg, obj, computed_offset);
6175 __ add(IP, obj, ShifterOperand(index.AsRegister<Register>(), LSL, TIMES_4));
6176 __ LoadFromOffset(kLoadWord, ref_reg, IP, offset);
6180 __ LoadFromOffset(kLoadWord, ref_reg, obj, offset);
6184 __ MaybeUnpoisonHeapReference(ref_reg);
6193 __ cmp(temp_reg, ShifterOperand(ReadBarrier::gray_ptr_));
6194 __ b(slow_path->GetEntryLabel(), EQ);
6195 __ Bind(slow_path->GetExitLabel());
6221 __ b(slow_path->GetEntryLabel());
6222 __ Bind(slow_path->GetExitLabel());
6239 __ UnpoisonHeapReference(out.AsRegister<Register>());
6256 __ b(slow_path->GetEntryLabel());
6257 __ Bind(slow_path->GetExitLabel());
6304 __ LoadFromOffset(kLoadWord, temp, SP, location.GetStackIndex());
6315 __ LoadFromOffset(kLoadWord, temp, SP, stack_offset);
6326 __ LoadLiteral(LR, DeduplicateMethodCodeLiteral(invoke->GetTargetMethod()));
6330 __ LoadImmediate(LR, invoke->GetDirectCodePtr());
6340 __ LoadFromOffset(kLoadWord, temp.AsRegister<Register>(), TR, invoke->GetStringInitOffset());
6346 __ LoadImmediate(temp.AsRegister<Register>(), invoke->GetMethodAddress());
6349 __ LoadLiteral(temp.AsRegister<Register>(),
6358 __ LoadFromOffset(kLoadWord, temp.AsRegister<Register>(), base_reg, offset);
6371 __ LoadFromOffset(kLoadWord, reg, SP, kCurrentMethodStackOffset);
6374 __ LoadFromOffset(kLoadWord,
6381 __ LoadFromOffset(kLoadWord, reg, reg, CodeGenerator::GetCachePointerOffset(index_in_cache));
6388 __ bl(GetFrameEntryLabel());
6392 __ BindTrackedLabel(&relative_call_patches_.back().label);
6394 __ bl(&relative_call_patches_.back().label);
6400 __ blx(LR);
6404 __ LoadFromOffset(
6408 __ blx(LR);
6428 __ LoadFromOffset(kLoadWord, temp, receiver, class_offset);
6437 __ MaybeUnpoisonHeapReference(temp);
6441 __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
6443 __ LoadFromOffset(kLoadWord, LR, temp, entry_point);
6445 __ blx(LR);
6468 [this]() { return __ NewLiteral<uint32_t>(/* placeholder */ 0u); });
6577 [this, value]() { return __ NewLiteral<uint32_t>(value); });
6584 [this]() { return __ NewLiteral<uint32_t>(/* placeholder */ 0u); });
6616 __ mla(res, mul_left, mul_right, accumulator);
6618 __ mls(res, mul_left, mul_right, accumulator);
6660 __ AddConstantSetFlags(temp_reg, value_reg, -lower_bound);
6664 __ b(codegen_->GetLabelOf(successors[0]), EQ);
6667 __ AddConstantSetFlags(temp_reg, temp_reg, -2);
6669 __ b(codegen_->GetLabelOf(successors[last_index + 1]), LO);
6671 __ b(codegen_->GetLabelOf(successors[last_index + 2]), EQ);
6675 __ CmpConstant(temp_reg, 1);
6676 __ b(codegen_->GetLabelOf(successors[last_index + 1]), EQ);
6681 __ b(codegen_->GetLabelOf(default_block));
6693 JumpTable* table = __ CreateJumpTable(std::move(labels), temp_reg);
6699 __ AddConstant(key_reg, value_reg, -lower_bound);
6705 __ CmpConstant(key_reg, num_entries - 1);
6706 __ b(codegen_->GetLabelOf(default_block), Condition::HI);
6709 __ ldr(temp_reg, Address(temp_reg, key_reg, Shift::LSL, 2));
6712 __ EmitJumpTableDispatch(table, temp_reg);
6725 __ BindTrackedLabel(&labels->movw_label);
6726 __ movw(base_reg, /* placeholder */ 0u);
6727 __ BindTrackedLabel(&labels->movt_label);
6728 __ movt(base_reg, /* placeholder */ 0u);
6729 __ BindTrackedLabel(&labels->add_pc_label);
6730 __ add(base_reg, base_reg, ShifterOperand(PC));
6778 __ LoadFromOffset(kLoadWord,
6785 __ LoadFromOffset(kLoadWord,
6789 __ LoadFromOffset(kLoadWord,
6796 #undef __