Lines Matching refs:__
39 #ifdef __
135 #define __ down_cast<CodeGeneratorARM64*>(codegen)->GetVIXLAssembler()->
167 __ Add(new_base, base, Operand(spill_offset + core_spill_size));
176 __ StoreCPURegList(core_list, MemOperand(base, spill_offset));
177 __ StoreCPURegList(fp_list, MemOperand(base, spill_offset + core_spill_size));
179 __ LoadCPURegList(core_list, MemOperand(base, spill_offset));
180 __ LoadCPURegList(fp_list, MemOperand(base, spill_offset + core_spill_size));
228 __ Bind(GetEntryLabel());
258 __ Bind(GetEntryLabel());
290 __ Bind(GetEntryLabel());
294 __ Mov(calling_convention.GetRegisterAt(0).W(), cls_->GetTypeIndex());
313 __ B(GetExitLabel());
344 __ Bind(GetEntryLabel());
349 __ Mov(calling_convention.GetRegisterAt(0).W(), string_index);
357 __ B(GetExitLabel());
372 __ Bind(GetEntryLabel());
397 __ Bind(GetEntryLabel());
404 __ B(GetReturnLabel());
406 __ B(arm64_codegen->GetLabelOf(successor_));
446 __ Bind(GetEntryLabel());
475 __ B(GetExitLabel());
495 __ Bind(GetEntryLabel());
516 __ Bind(GetEntryLabel());
545 __ B(GetExitLabel());
563 __ Bind(&table_start_);
572 __ place(&literal);
601 __ Bind(GetEntryLabel());
615 __ B(GetExitLabel());
645 // __ Ldr(out, HeapOperand(out, class_offset);
670 __ Bind(GetEntryLabel());
708 __ Mov(free_reg.W(), index_reg);
721 __ Lsl(index_reg, index_reg, Primitive::ComponentSizeShift(type));
725 __ Add(index_reg, index_reg, Operand(offset_));
772 __ B(GetExitLabel());
824 __ Bind(GetEntryLabel());
840 __ Mov(calling_convention.GetRegisterAt(0), XRegisterFrom(out_));
849 __ B(GetExitLabel());
861 #undef __
928 #define __ GetVIXLAssembler()->
939 __ FinalizeCode();
1000 __ Bind(&frame_entry_label_);
1007 __ Sub(temp, sp, static_cast<int32_t>(GetStackOverflowReservedBytes(kArm64)));
1008 __ Ldr(wzr, MemOperand(temp, 0));
1020 __ Str(kArtMethodRegister, MemOperand(sp, -frame_size, PreIndex));
1038 __ Drop(frame_size);
1041 __ Ret();
1060 __ Bind(GetLabelOf(block));
1065 __ Mov(RegisterFrom(location, Primitive::kPrimInt), value);
1082 __ Cbz(value, &done);
1084 __ Ldr(card, MemOperand(tr, Thread::CardTableOffset<kArm64WordSize>().Int32Value()));
1085 __ Lsr(temp, object, gc::accounting::CardTable::kCardShift);
1086 __ Strb(card, MemOperand(card, temp.X()));
1088 __ Bind(&done);
1126 __ Str(reg, MemOperand(sp, stack_index));
1132 __ Ldr(reg, MemOperand(sp, stack_index));
1138 __ Str(reg, MemOperand(sp, stack_index));
1144 __ Ldr(reg, MemOperand(sp, stack_index));
1158 __ Mov(Register(destination), constant->AsIntConstant()->GetValue());
1160 __ Mov(Register(destination), constant->AsLongConstant()->GetValue());
1162 __ Mov(Register(destination), 0);
1164 __ Fmov(FPRegister(destination), constant->AsFloatConstant()->GetValue());
1167 __ Fmov(FPRegister(destination), constant->AsDoubleConstant()->GetValue());
1218 __ Ldr(dst, StackOperandFrom(source));
1224 __ Mov(Register(dst), RegisterFrom(source, dst_type));
1230 __ Fmov(FPRegisterFrom(destination, dst_type), RegisterFrom(source, source_type));
1238 __ Fmov(RegisterFrom(destination, dst_type), FPRegisterFrom(source, source_type));
1241 __ Fmov(FPRegister(dst), FPRegisterFrom(source, dst_type));
1256 __ Str(CPURegisterFrom(source, dst_type), StackOperandFrom(destination));
1274 __ Str(temp, StackOperandFrom(destination));
1281 __ Ldr(temp, StackOperandFrom(source));
1282 __ Str(temp, StackOperandFrom(destination));
1292 __ Ldrb(Register(dst), src);
1295 __ Ldrsb(Register(dst), src);
1298 __ Ldrsh(Register(dst), src);
1301 __ Ldrh(Register(dst), src);
1309 __ Ldr(dst, src);
1330 __ Add(temp_base, src.base(), OperandFromMemOperand(src));
1334 __ Ldarb(Register(dst), base);
1340 __ Ldarb(Register(dst), base);
1344 __ Sbfx(Register(dst), Register(dst), 0, Primitive::ComponentSize(type) * kBitsPerByte);
1347 __ Ldarh(Register(dst), base);
1353 __ Ldarh(Register(dst), base);
1357 __ Sbfx(Register(dst), Register(dst), 0, Primitive::ComponentSize(type) * kBitsPerByte);
1363 __ Ldar(Register(dst), base);
1374 __ Ldar(temp, base);
1378 __ Fmov(FPRegister(dst), temp);
1392 __ Strb(Register(src), dst);
1396 __ Strh(Register(src), dst);
1404 __ Str(src, dst);
1422 __ Add(temp_base, dst.base(), op);
1427 __ Stlrb(Register(src), base);
1431 __ Stlrh(Register(src), base);
1437 __ Stlr(Register(src), base);
1445 __ Fmov(temp, FPRegister(src));
1446 __ Stlr(temp, base);
1470 __ Ldr(lr, MemOperand(tr, entry_point_offset));
1471 __ Blr(lr);
1483 __ Add(temp, class_reg, status_offset);
1484 __ Ldar(temp, HeapOperand(temp));
1485 __ Cmp(temp, mirror::Class::kStatusInitialized);
1486 __ B(lt, slow_path->GetEntryLabel());
1487 __ Bind(slow_path->GetExitLabel());
1510 __ Dmb(InnerShareable, type);
1532 __ Ldrh(temp, MemOperand(tr, Thread::ThreadFlagsOffset<kArm64WordSize>().SizeValue()));
1534 __ Cbnz(temp, slow_path->GetEntryLabel());
1535 __ Bind(slow_path->GetReturnLabel());
1537 __ Cbz(temp, codegen_->GetLabelOf(successor));
1538 __ B(slow_path->GetEntryLabel());
1564 __ Brk(UNIMPLEMENTED_INSTRUCTION_BREAK_CODE(name)); \
1703 __ Mov(temp, value.W());
1732 __ Add(dst, lhs, rhs);
1734 __ And(dst, lhs, rhs);
1736 __ Orr(dst, lhs, rhs);
1738 __ Sub(dst, lhs, rhs);
1742 __ Ror(dst, lhs, shift);
1748 __ Ror(dst, lhs, RegisterFrom(instr->GetLocations()->InAt(1), type));
1752 __ Eor(dst, lhs, rhs);
1762 __ Fadd(dst, lhs, rhs);
1764 __ Fsub(dst, lhs, rhs);
1807 __ Lsl(dst, lhs, shift_value);
1809 __ Asr(dst, lhs, shift_value);
1811 __ Lsr(dst, lhs, shift_value);
1817 __ Lsl(dst, lhs, rhs_reg);
1819 __ Asr(dst, lhs, rhs_reg);
1821 __ Lsr(dst, lhs, rhs_reg);
1863 __ Bic(dst, lhs, rhs);
1866 __ Orn(dst, lhs, rhs);
1869 __ Eon(dst, lhs, rhs);
1927 __ Add(out, left, right_operand);
1930 __ And(out, left, right_operand);
1934 __ Neg(out, right_operand);
1937 __ Orr(out, left, right_operand);
1940 __ Sub(out, left, right_operand);
1943 __ Eor(out, left, right_operand);
1967 __ Add(OutputRegister(instruction),
2007 __ nop();
2013 __ Madd(res, mul_left, mul_right, accumulator);
2018 __ Mneg(res, mul_left, mul_right);
2021 __ Msub(res, mul_left, mul_right, accumulator);
2092 __ Add(temp, obj, offset);
2122 __ Ldr(OutputRegister(instruction),
2184 __ Add(temp, array, offset);
2222 __ Cbnz(Register(value), &non_zero);
2224 __ Add(temp, array, offset);
2226 __ Str(wzr, destination);
2228 __ B(&done);
2229 __ Bind(&non_zero);
2236 // __ Mov(temp2, temp);
2238 // __ Ldr(temp, HeapOperand(temp, component_offset));
2243 // __ Ldr(temp2, HeapOperand(Register(value), class_offset));
2247 // __ Cmp(temp, temp2);
2258 __ B(slow_path->GetEntryLabel());
2262 __ Ldr(temp, HeapOperand(array, class_offset));
2267 __ Ldr(temp, HeapOperand(temp, component_offset));
2269 __ Ldr(temp2, HeapOperand(Register(value), class_offset));
2272 __ Cmp(temp, temp2);
2276 __ B(eq, &do_put);
2282 __ Ldr(temp, HeapOperand(temp, super_offset));
2285 __ Cbnz(temp, slow_path->GetEntryLabel());
2286 __ Bind(&do_put);
2288 __ B(ne, slow_path->GetEntryLabel());
2297 __ Mov(temp2, value.W());
2303 __ Add(temp, array, offset);
2305 __ Str(source, destination);
2315 __ Bind(&done);
2319 __ Bind(slow_path->GetExitLabel());
2341 __ Cmp(InputRegisterAt(instruction, 0), InputOperandAt(instruction, 1));
2342 __ B(slow_path->GetEntryLabel(), hs);
2387 __ Fcmp(lhs_reg, 0.0);
2389 __ Fcmp(lhs_reg, InputFPRegisterAt(instruction, 1));
2440 __ Cmp(left, right);
2441 __ Cset(result, ne); // result == +1 if NE or 0 otherwise
2442 __ Cneg(result, result, lt); // result == -1 if LT or unchanged otherwise
2449 __ Cset(result, ne);
2450 __ Cneg(result, result, ARM64FPCondition(kCondLT, compare->IsGtBias()));
2489 __ Cset(res, ARM64FPCondition(if_cond, instruction->IsGtBias()));
2494 __ Cmp(lhs, rhs);
2495 __ Cset(res, ARM64Condition(if_cond));
2530 __ Mov(out, 0);
2533 __ Mov(out, dividend);
2535 __ Neg(out, dividend);
2557 __ Add(temp, dividend, abs_imm - 1);
2558 __ Cmp(dividend, 0);
2559 __ Csel(out, temp, dividend, lt);
2561 __ Asr(out, out, ctz_imm);
2563 __ Neg(out, Operand(out, ASR, ctz_imm));
2567 __ Asr(temp, dividend, bits - 1);
2568 __ Lsr(temp, temp, bits - ctz_imm);
2569 __ Add(out, dividend, temp);
2570 __ And(out, out, abs_imm - 1);
2571 __ Sub(out, out, temp);
2597 __ Mov(temp, magic);
2599 __ Smulh(temp, dividend, temp);
2601 __ Smull(temp.X(), dividend, temp);
2602 __ Lsr(temp.X(), temp.X(), 32);
2606 __ Add(temp, temp, dividend);
2608 __ Sub(temp, temp, dividend);
2612 __ Asr(temp, temp, shift);
2616 __ Sub(out, temp, Operand(temp, ASR, type == Primitive::kPrimLong ? 63 : 31));
2618 __ Sub(temp, temp, Operand(temp, ASR, type == Primitive::kPrimLong ? 63 : 31));
2621 __ Mov(temp_imm, imm);
2622 __ Msub(out, temp, temp_imm, dividend);
2652 __ Sdiv(out, dividend, divisor);
2656 __ Sdiv(temp, dividend, divisor);
2657 __ Msub(out, temp, divisor, dividend);
2695 __ Fdiv(OutputFPRegister(div), InputFPRegisterAt(div, 0), InputFPRegisterAt(div, 1));
2730 __ B(slow_path->GetEntryLabel());
2736 __ Cbz(InputRegisterAt(instruction, 0), slow_path->GetEntryLabel());
2783 __ B(codegen_->GetLabelOf(successor));
2822 __ B(true_target);
2827 __ B(false_target);
2846 __ Cbz(InputRegisterAt(instruction, condition_input_index), false_target);
2848 __ Cbnz(InputRegisterAt(instruction, condition_input_index), true_target);
2860 __ B(ARM64FPCondition(opposite_condition, condition->IsGtBias()), false_target);
2862 __ B(ARM64FPCondition(condition->GetCondition(), condition->IsGtBias()), true_target);
2883 __ Cbz(lhs, non_fallthrough_target);
2886 __ Cbnz(lhs, non_fallthrough_target);
2890 __ Tbnz(lhs, (lhs.IsX() ? kXRegSize : kWRegSize) - 1, non_fallthrough_target);
2894 __ Tbz(lhs, (lhs.IsX() ? kXRegSize : kWRegSize) - 1, non_fallthrough_target);
2902 __ Cmp(lhs, rhs);
2903 __ B(arm64_cond, non_fallthrough_target);
2911 __ B(false_target);
2915 __ Bind(&fallthrough_target);
3037 __ Cmp(InputRegisterAt(select, 2), 0);
3044 __ Cmp(InputRegisterAt(cond, 0), InputOperandAt(cond, 1));
3051 __ Csel(OutputRegister(select),
3057 __ Csel(OutputRegister(select),
3063 __ Fcsel(OutputFPRegister(select),
3080 __ Nop();
3160 __ Cbz(obj, &zero);
3168 __ Cmp(out, cls);
3169 __ Cset(out, eq);
3171 __ B(&done);
3180 __ Bind(&loop);
3184 __ Cbz(out, &done);
3185 __ Cmp(out, cls);
3186 __ B(ne, &loop);
3187 __ Mov(out, 1);
3189 __ B(&done);
3197 __ Bind(&loop);
3198 __ Cmp(out, cls);
3199 __ B(eq, &success);
3202 __ Cbnz(out, &loop);
3204 __ B(&done);
3205 __ Bind(&success);
3206 __ Mov(out, 1);
3208 __ B(&done);
3216 __ Cmp(out, cls);
3217 __ B(eq, &exact_check);
3222 __ Cbz(out, &done);
3223 __ Ldrh(out, HeapOperand(out, primitive_offset));
3225 __ Cbnz(out, &zero);
3226 __ Bind(&exact_check);
3227 __ Mov(out, 1);
3228 __ B(&done);
3233 __ Cmp(out, cls);
3238 __ B(ne, slow_path->GetEntryLabel());
3239 __ Mov(out, 1);
3241 __ B(&done);
3270 __ B(slow_path->GetEntryLabel());
3272 __ B(&done);
3279 __ Bind(&zero);
3280 __ Mov(out, 0);
3284 __ Bind(&done);
3288 __ Bind(slow_path->GetExitLabel());
3355 __ Cbz(obj, &done);
3364 __ Cmp(temp, cls);
3367 __ B(ne, type_check_slow_path->GetEntryLabel());
3375 __ Bind(&loop);
3382 __ Cbnz(temp, &compare_classes);
3391 __ B(type_check_slow_path->GetEntryLabel());
3393 __ Bind(&compare_classes);
3394 __ Cmp(temp, cls);
3395 __ B(ne, &loop);
3402 __ Bind(&loop);
3403 __ Cmp(temp, cls);
3404 __ B(eq, &done);
3411 __ Cbnz(temp, &loop);
3420 __ B(type_check_slow_path->GetEntryLabel());
3427 __ Cmp(temp, cls);
3428 __ B(eq, &done);
3438 __ Cbnz(temp, &check_non_primitive_component_type);
3447 __ B(type_check_slow_path->GetEntryLabel());
3449 __ Bind(&check_non_primitive_component_type);
3450 __ Ldrh(temp, HeapOperand(temp, primitive_offset));
3452 __ Cbz(temp, &done);
3457 __ B(type_check_slow_path->GetEntryLabel());
3480 __ B(type_check_slow_path->GetEntryLabel());
3483 __ Bind(&done);
3485 __ Bind(type_check_slow_path->GetExitLabel());
3540 __ Mov(ip1, invoke->GetDexMethodIndex());
3543 __ Ldr(temp.W(), StackOperandFrom(receiver));
3545 __ Ldr(temp.W(), HeapOperand(temp.W(), class_offset));
3548 __ Ldr(temp.W(), HeapOperandFrom(receiver, class_offset));
3559 __ Ldr(temp,
3564 __ Ldr(temp, MemOperand(temp, method_offset));
3566 __ Ldr(lr, MemOperand(temp, entry_point.Int32Value()));
3568 __ Blr(lr);
3617 __ Ldr(lr, DeduplicateMethodCodeLiteral(invoke->GetTargetMethod()));
3622 __ Ldr(lr, DeduplicateUint64Literal(invoke->GetDirectCodePtr()));
3634 __ Ldr(XRegisterFrom(temp), MemOperand(tr, invoke->GetStringInitOffset()));
3641 __ Ldr(XRegisterFrom(temp), DeduplicateUint64Literal(invoke->GetMethodAddress()));
3645 __ Ldr(XRegisterFrom(temp),
3655 __ Bind(adrp_label);
3656 __ adrp(XRegisterFrom(temp), /* offset placeholder */ 0);
3663 __ Bind(ldr_label);
3664 __ ldr(XRegisterFrom(temp), MemOperand(XRegisterFrom(temp), /* offset placeholder */ 0));
3678 __ Ldr(reg.X(), MemOperand(sp, kCurrentMethodStackOffset));
3682 __ Ldr(reg.X(),
3688 __ Ldr(reg.X(), MemOperand(reg.X(), GetCachePointerOffset(index_in_cache)));
3695 __ Bl(&frame_entry_label_);
3701 __ Bind(label);
3702 __ bl(0); // Branch and link to itself. This will be overriden at link time.
3710 __ Blr(lr);
3714 __ Ldr(lr, MemOperand(
3718 __ Blr(lr);
3742 __ Ldr(temp.W(), HeapOperandFrom(LocationFrom(receiver), class_offset));
3752 __ Ldr(temp, MemOperand(temp, method_offset));
3754 __ Ldr(lr, MemOperand(temp, entry_point.SizeValue()));
3756 __ Blr(lr);
3788 [this]() { return __ CreateLiteralDestroyedWithPool<uint32_t>(/* placeholder */ 0u); });
3861 [this, value]() { return __ CreateLiteralDestroyedWithPool<uint32_t>(value); });
3867 [this, value]() { return __ CreateLiteralDestroyedWithPool<uint64_t>(value); });
3875 [this]() { return __ CreateLiteralDestroyedWithPool<uint64_t>(/* placeholder */ 0u); });
3948 __ Ldr(out.X(), MemOperand(current_method, resolved_types_offset.Int32Value()));
3959 __ Cbz(out, slow_path->GetEntryLabel());
3964 __ Bind(slow_path->GetExitLabel());
3981 __ Ldr(OutputRegister(instruction), GetExceptionTlsAddress());
3989 __ Str(wzr, GetExceptionTlsAddress());
4044 __ Ldr(out, codegen_->DeduplicateBootImageStringLiteral(load->GetDexFile(),
4055 __ Bind(adrp_label);
4056 __ adrp(out.X(), /* offset placeholder */ 0);
4063 __ Bind(add_label);
4064 __ add(out.X(), out.X(), Operand(/* offset placeholder */ 0));
4071 __ Ldr(out.W(), codegen_->DeduplicateBootImageAddressLiteral(load->GetAddress()));
4085 __ Ldr(out.X(), codegen_->DeduplicateDexCacheAddressLiteral(base_address));
4096 __ Bind(adrp_label);
4097 __ adrp(out.X(), /* offset placeholder */ 0);
4111 __ Ldr(out.X(), HeapOperand(out, mirror::Class::DexCacheStringsOffset().Uint32Value()));
4125 __ Cbz(out, slow_path->GetEntryLabel());
4126 __ Bind(slow_path->GetExitLabel());
4186 __ Mul(OutputRegister(mul), InputRegisterAt(mul, 0), InputRegisterAt(mul, 1));
4191 __ Fmul(OutputFPRegister(mul), InputFPRegisterAt(mul, 0), InputFPRegisterAt(mul, 1));
4224 __ Neg(OutputRegister(neg), InputOperandAt(neg, 0));
4229 __ Fneg(OutputFPRegister(neg), InputFPRegisterAt(neg, 0));
4252 __ Mov(type_index, instruction->GetTypeIndex());
4282 __ Ldr(XRegisterFrom(temp), MemOperand(tr, QUICK_ENTRY_POINT(pNewEmptyString)));
4283 __ Ldr(lr, MemOperand(XRegisterFrom(temp), code_offset.Int32Value()));
4284 __ Blr(lr);
4305 __ Mvn(OutputRegister(instruction), InputOperandAt(instruction, 0));
4320 __ Eor(OutputRegister(instruction), InputRegisterAt(instruction, 0), vixl::Operand(1));
4341 __ Ldr(wzr, HeapOperandFrom(obj, Offset(0)));
4352 __ Cbz(RegisterFrom(obj, instruction->InputAt(0)->GetType()), slow_path->GetEntryLabel());
4689 __ Mov(output.W(), source.W());
4692 __ Ubfx(output,
4696 __ Sbfx(output, output.IsX() ? source.X() : source.W(), 0, min_size * kBitsPerByte);
4699 __ Scvtf(OutputFPRegister(conversion), InputRegisterAt(conversion, 0));
4702 __ Fcvtzs(OutputRegister(conversion), InputFPRegisterAt(conversion, 0));
4705 __ Fcvt(OutputFPRegister(conversion), InputFPRegisterAt(conversion, 0));
4765 __ Subs(temp, value_reg, Operand(lower_bound));
4769 __ B(eq, codegen_->GetLabelOf(successors[0]));
4772 __ Subs(temp, temp, Operand(2));
4774 __ B(lo, codegen_->GetLabelOf(successors[last_index + 1]));
4776 __ B(eq, codegen_->GetLabelOf(successors[last_index + 2]));
4780 __ Cmp(temp, Operand(1));
4781 __ B(eq, codegen_->GetLabelOf(successors[last_index + 1]));
4786 __ B(codegen_->GetLabelOf(default_block));
4800 __ Sub(index, value_reg, Operand(lower_bound));
4806 __ Cmp(index, Operand(num_entries));
4807 __ B(hs, codegen_->GetLabelOf(default_block));
4814 __ Adr(table_base, jump_table->GetTableStartLabel());
4816 __ Ldr(jump_offset, MemOperand(table_base, index, UXTW, 2));
4820 __ Add(target_address, table_base, Operand(jump_offset, SXTW));
4821 __ Br(target_address);
4848 __ Mov(temp_reg, out_reg);
4850 __ Ldr(out_reg, HeapOperand(out_reg, offset));
4856 __ Ldr(out_reg, HeapOperand(out_reg, offset));
4884 __ Ldr(out_reg, HeapOperand(obj_reg, offset));
4890 __ Ldr(out_reg, HeapOperand(obj_reg, offset));
4913 __ Ldr(root_reg, MemOperand(obj, offset));
4916 __ Bind(fixup_label);
4917 __ ldr(root_reg, MemOperand(obj, offset));
4936 __ Ldr(temp, MemOperand(tr, Thread::IsGcMarkingOffset<kArm64WordSize>().Int32Value()));
4937 __ Cbnz(temp, slow_path->GetEntryLabel());
4938 __ Bind(slow_path->GetExitLabel());
4944 __ Add(root_reg.X(), obj.X(), offset);
4947 __ Bind(fixup_label);
4948 __ add(root_reg.X(), obj.X(), offset);
4957 __ Ldr(root_reg, MemOperand(obj, offset));
4960 __ Bind(fixup_label);
4961 __ ldr(root_reg, MemOperand(obj, offset));
5047 __ Ldr(temp, HeapOperand(obj, monitor_offset));
5055 __ Lsr(temp, temp, LockWord::kReadBarrierStateShift);
5056 __ And(temp, temp, Operand(LockWord::kReadBarrierStateMask));
5066 __ Bic(temp2, temp, Operand(LockWord::kReadBarrierStateMask));
5069 __ Add(obj, obj, Operand(temp2));
5085 __ Add(temp2, obj, offset);
5109 __ Cmp(temp, ReadBarrier::gray_ptr_);
5110 __ B(eq, slow_path->GetEntryLabel());
5111 __ Bind(slow_path->GetExitLabel());
5137 __ B(slow_path->GetEntryLabel());
5138 __ Bind(slow_path->GetExitLabel());
5172 __ B(slow_path->GetEntryLabel());
5173 __ Bind(slow_path->GetExitLabel());
5188 __ Ldr(XRegisterFrom(locations->Out()),
5193 __ Ldr(XRegisterFrom(locations->Out()), MemOperand(XRegisterFrom(locations->InAt(0)),
5195 __ Ldr(XRegisterFrom(locations->Out()),
5202 #undef __