5#ifndef RUNTIME_VM_COMPILER_ASSEMBLER_ASSEMBLER_ARM_H_
6#define RUNTIME_VM_COMPILER_ASSEMBLER_ASSEMBLER_ARM_H_
8#if defined(DART_PRECOMPILED_RUNTIME)
9#error "AOT runtime should not use compiler sources (including header files)"
12#ifndef RUNTIME_VM_COMPILER_ASSEMBLER_ASSEMBLER_H_
13#error Do not include assembler_arm.h directly; use assembler.h instead.
32class FlowGraphCompiler;
39 DA = (0 | 0 | 0) << 21,
40 IA = (0 | 4 | 0) << 21,
41 DB = (8 | 0 | 0) << 21,
42 IB = (8 | 4 | 0) << 21,
46 IB_W = (8 | 4 | 1) << 21
55 int32_t
value()
const {
return value_; }
109 return static_cast<uint32_t
>(rd) <<
kRdShift;
114 return static_cast<uint32_t
>(rm) <<
kRmShift;
119 return static_cast<uint32_t
>(rn) <<
kRnShift;
124 return static_cast<uint32_t
>(rs) <<
kRsShift;
136 :
ValueObject(), type_(other.type_), encoding_(other.encoding_) {}
141 encoding_ = other.encoding_;
149 encoding_ = immediate;
162 encoding_ =
static_cast<uint32_t
>(
rm);
171 static_cast<uint32_t
>(
rm);
178 static_cast<uint32_t
>(shift) <<
kShiftShift | (1 << 4) |
179 static_cast<uint32_t
>(
rm);
190 for (
int rot = 0; rot < 16; rot++) {
202 bool is_valid()
const {
return (type_ == 0) || (type_ == 1); }
204 uint32_t type()
const {
209 uint32_t encoding()
const {
243 encoding_(other.encoding_),
246 offset_(other.offset_) {}
249 encoding_ = other.encoding_;
252 offset_ = other.offset_;
257 return (encoding_ == other.encoding_) && (kind_ == other.kind_);
268 encoding_ = (am ^ (1 <<
kUShift)) | -offset;
270 encoding_ = am | offset;
282 uint32_t shift_imm = 0,
284 Operand o(rm, shift, shift_imm);
286 if ((shift ==
LSL) && (shift_imm == 0)) {
301 int32_t* offset_mask);
304 int32_t* offset_mask);
322 bool has_writeback()
const {
345 uint32_t encoding()
const {
351 uint32_t encoding3()
const;
354 uint32_t vencoding()
const;
358 int32_t offset()
const {
return offset_; }
396 if ((r0 < r1) && (r0 !=
SP) && (r1 !=
SP)) {
397 RegList reg_list = (1 << r0) | (1 << r1);
407 if ((r0 < r1) && (r0 !=
SP) && (r1 !=
SP)) {
408 RegList reg_list = (1 << r0) | (1 << r1);
435 Load(dst, address, size);
442 Store(src, address, size);
455 return FLAG_use_far_branches || use_far_branches_;
458#if defined(TESTING) || defined(DEBUG)
621 bool enter_safepoint);
625 bool ignore_unwind_in_progress =
false);
629 bool ignore_unwind_in_progress);
794 const Object& equivalence,
898 Lsl(dst, dst, shift);
949 void Drop(intptr_t stack_elements);
1026 intptr_t begin_offset,
1027 intptr_t end_offset,
1044 Label* target)
override;
1054 bool can_be_null =
false)
override;
1105 int32_t payload_start,
1153 Store(temp, address);
1234 b(label, condition);
1243 intptr_t bit_number,
1248 b(label, condition);
1463 intptr_t index_scale,
1464 bool* needs_base =
nullptr);
1469 intptr_t index_scale,
1478 intptr_t index_scale,
1485 intptr_t index_scale,
1494 intptr_t index_scale,
1505 Register offset_in_words_as_smi)
override;
1509 int32_t
offset)
override {
1536 intptr_t instance_size,
1543 intptr_t instance_size,
1556 Stop(
"Allocation canary");
1592 intptr_t offset_into_target = 0);
1598 intptr_t offset_into_target = 0);
1611 compiler::LRState
lr_state()
const {
return lr_state_; }
1631 bool use_far_branches_;
1633 bool constant_pool_allowed_;
1635 compiler::LRState lr_state_ = compiler::LRState::OnEntry();
1642 void BindARMv7(
Label* label);
1647 void LoadObjectHelper(
1668 void EmitMemOpAddressMode3(
Condition cond,
1734 void EmitSIMDqqq(int32_t opcode,
1740 void EmitSIMDddd(int32_t opcode,
1748 void BailoutIfInvalidBranchOffset(int32_t
offset);
1749 int32_t EncodeTstOffset(int32_t
offset, int32_t inst);
1750 int32_t DecodeTstOffset(int32_t inst);
1754 generate_invoke_write_barrier_wrapper_;
1755 std::function<void(
Condition)> generate_invoke_array_write_barrier_;
static void done(const char *config, const char *src, const char *srcOptions, const char *name)
static bool rotate(const SkDCubic &cubic, int zero, int index, SkDCubic &rotPath)
static bool equals(T *a, T *b)
static bool left(const SkPoint &p0, const SkPoint &p1)
static bool right(const SkPoint &p0, const SkPoint &p1)
#define ASSERT_EQUAL(expected, actual)
#define ASSERT_IMPLIES(antecedent, consequent)
static Instr * At(uword pc)
static bool IsInt(intptr_t N, T value)
static bool MagnitudeIsUint(intptr_t N, T value)
static constexpr int ShiftForPowerOfTwo(T x)
static T RotateLeft(T value, uint8_t rotate)
static constexpr bool IsAligned(T x, uintptr_t alignment, uintptr_t offset=0)
static constexpr bool IsPowerOfTwo(T x)
Address(Register rn, Register r, Mode am)
Address(Register rn, Register rm, Shift shift, Register r, Mode am=Offset)
Address & operator=(const Address &other)
static OperandSize OperandSizeFor(intptr_t cid)
static bool CanHoldStoreOffset(OperandSize size, int32_t offset, int32_t *offset_mask)
Address(Register rn, Register rm, Shift shift=LSL, uint32_t shift_imm=0, Mode am=Offset)
static bool CanHoldImmediateOffset(bool is_load, intptr_t cid, int64_t offset)
Address(Register rn, int32_t offset=0, Mode am=Offset)
bool Equals(const Address &other) const
static bool CanHoldLoadOffset(OperandSize size, int32_t offset, int32_t *offset_mask)
Address(const Address &other)
static uint32_t Rs(Register rs)
static uint32_t Rm(Register rm)
static uint32_t Rd(Register rd)
static uint32_t Rn(Register rn)
void Stop(const char *message)
ObjectPoolBuilder & object_pool_builder()
void vaddqs(QRegister qd, QRegister qn, QRegister qm)
void PushRegistersInOrder(std::initializer_list< Register > regs)
void PopRegisterPair(Register r0, Register r1)
void MoveUnboxedDouble(FpuRegister dst, FpuRegister src)
void PopList(RegList regs, Condition cond=AL)
void LoadPatchableImmediate(Register rd, int32_t value, Condition cond=AL)
void smull(Register rd_lo, Register rd_hi, Register rn, Register rm, Condition cond=AL)
void RestoreCodePointer()
void SignFill(Register rd, Register rm, Condition cond=AL)
bool CanLoadFromObjectPool(const Object &object) const
void eor(Register rd, Register rn, Operand o, Condition cond=AL)
void LoadSFromOffset(SRegister reg, Register base, int32_t offset, Condition cond=AL)
void vmlad(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void StoreUnboxedDouble(FpuRegister src, Register base, int32_t offset)
void bx(Register rm, Condition cond=AL)
void MoveUnboxedSimd128(FpuRegister dst, FpuRegister src)
void BranchIfZero(Register rn, Label *label, JumpDistance distance=kFarJump)
void Load(Register reg, const Address &address, OperandSize type=kFourBytes) override
void LoadAllocationTracingStateAddress(Register dest, Register cid)
void CombineHashes(Register dst, Register other) override
void GenerateUnRelocatedPcRelativeTailCall(Condition cond=AL, intptr_t offset_into_target=0)
void orr(Register rd, Register rn, Operand o, Condition cond=AL)
void MonomorphicCheckedEntryJIT()
void BranchIfSmi(Register reg, Label *label, JumpDistance distance=kFarJump) override
void LoadTaggedClassIdMayBeSmi(Register result, Register object)
void Call(const Code &code)
void LoadWordUnaligned(Register dst, Register addr, Register tmp)
void BranchLink(const Code &code, ObjectPoolBuilderEntry::Patchability patchable=ObjectPoolBuilderEntry::kNotPatchable, CodeEntryKind entry_kind=CodeEntryKind::kNormal, ObjectPoolBuilderEntry::SnapshotBehavior snapshot_behavior=ObjectPoolBuilderEntry::kSnapshotable)
void PushList(RegList regs, Condition cond=AL)
static int32_t DecodeBranchOffset(int32_t inst)
void LoadDFromOffset(DRegister reg, Register base, int32_t offset, Condition cond=AL)
void ldr(Register rd, Address ad, Condition cond=AL)
void LoadStaticFieldAddress(Register address, Register field, Register scratch)
void vmaxqs(QRegister qd, QRegister qn, QRegister qm)
void vcgtqs(QRegister qd, QRegister qn, QRegister qm)
void Load(Register reg, const Address &address, OperandSize type, Condition cond)
void vmovsrr(SRegister sm, Register rt, Register rt2, Condition cond=AL)
void PushRegisterPair(Register r0, Register r1)
void CompareClassId(Register object, intptr_t class_id, Register scratch)
void LoadFieldFromOffset(Register reg, Register base, int32_t offset, OperandSize type, Condition cond)
void LoadIsolate(Register rd)
Assembler(ObjectPoolBuilder *object_pool_builder, intptr_t far_branch_level=0)
void vcvtsu(SRegister sd, SRegister sm, Condition cond=AL)
void vcvtus(SRegister sd, SRegister sm, Condition cond=AL)
void LoadUniqueObject(Register rd, const Object &object, Condition cond=AL, ObjectPoolBuilderEntry::SnapshotBehavior snapshot_behavior=ObjectPoolBuilderEntry::kSnapshotable)
void StoreHalfWordUnaligned(Register src, Register addr, Register tmp)
void MaybeTraceAllocation(Register stats_addr_reg, Label *trace)
void LeaveDartFrameAndReturn()
void LoadFieldFromOffset(Register reg, Register base, int32_t offset, OperandSize type=kFourBytes) override
void CheckAllocationCanary(Register top, Register tmp=TMP)
void vcvtdu(DRegister dd, SRegister sm, Condition cond=AL)
void vornq(QRegister qd, QRegister qn, QRegister qm)
void mls(Register rd, Register rn, Register rm, Register ra, Condition cond=AL)
void vstrs(SRegister sd, Address ad, Condition cond=AL)
void Lsl(Register rd, Register rm, Register rs, Condition cond=AL)
static bool CanEncodeBranchDistance(int32_t distance)
void veorq(QRegister qd, QRegister qn, QRegister qm)
void vcmps(SRegister sd, SRegister sm, Condition cond=AL)
void TryAllocateObject(intptr_t cid, intptr_t instance_size, Label *failure, JumpDistance distance, Register instance_reg, Register temp_reg) override
void SmiUntag(Register dst, Register src, Condition cond=AL)
void Jump(Label *label, JumpDistance distance=kFarJump)
void StoreFieldToOffset(Register reg, Register base, int32_t offset, OperandSize type=kFourBytes) override
void bics(Register rd, Register rn, Operand o, Condition cond=AL)
void CompareObjectRegisters(Register rn, Register rm)
void LoadAcquire(Register dst, const Address &address, OperandSize size=kFourBytes) override
void Pop(Register rd, Condition cond=AL)
void vcmpsz(SRegister sd, Condition cond=AL)
void vcmpd(DRegister dd, DRegister dm, Condition cond=AL)
void vaddd(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void LoadFromStack(Register dst, intptr_t depth)
static int32_t BkptEncoding(uint16_t imm16)
void LoadAllocationTracingStateAddress(Register dest, intptr_t cid)
void vabss(SRegister sd, SRegister sm, Condition cond=AL)
void orrs(Register rd, Register rn, Operand o, Condition cond=AL)
void vldms(BlockAddressMode am, Register base, SRegister first, SRegister last, Condition cond=AL)
void vmlss(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void EnterDartFrame(intptr_t frame_size, bool load_pool_pointer=true)
void ubfx(Register rd, Register rn, int32_t lsb, int32_t width, Condition cond=AL)
bool vmovd(DRegister dd, double d_imm, Condition cond=AL)
void TestImmediate(Register rn, int32_t imm, Condition cond=AL)
void CompareImmediate(Register rn, int32_t value, Condition cond)
void CompareWithMemoryValue(Register value, Address address, OperandSize size=kFourBytes) override
void PushRegister(Register r)
void LoadMemoryValue(Register dst, Register base, int32_t offset)
void Ror(Register rd, Register rm, Register rs, Condition cond=AL)
void vstrd(DRegister dd, Address ad, Condition cond=AL)
void vmstat(Condition cond=AL)
void ExtractClassIdFromTags(Register result, Register tags, Condition cond=AL)
void PushQuad(FpuRegister rd, Condition cond=AL)
void b(Label *label, Condition cond=AL)
void vcvtid(SRegister sd, DRegister dm, Condition cond=AL)
void ExtendAndSmiTagValue(Register rd, Register rm, OperandSize sz=kFourBytes) override
void umlal(Register rd_lo, Register rd_hi, Register rn, Register rm, Condition cond=AL)
void Lsl(Register rd, Register rm, const Operand &shift_imm, Condition cond=AL)
void vmlas(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void set_constant_pool_allowed(bool b)
void vmovd(DRegister dd, DRegister dm, Condition cond=AL)
void LoadDImmediate(DRegister dd, double value, Register scratch, Condition cond=AL)
void vcmpdz(DRegister dd, Condition cond=AL)
void vmovrs(Register rt, SRegister sn, Condition cond=AL)
void PushRegisters(const RegisterSet ®s)
void IntegerDivide(Register result, Register left, Register right, DRegister tmpl, DRegister tmpr)
void vdivd(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void LslImmediate(Register rd, Register rn, int32_t shift)
void MoveRegister(Register rd, Register rm) override
void SmiTag(Register dst, Register src, Condition cond=AL)
void Lsr(Register rd, Register rm, const Operand &shift_imm, Condition cond=AL)
void vcvtdi(DRegister dd, SRegister sm, Condition cond=AL)
void StoreObjectIntoObjectNoBarrier(Register object, const Address &dest, const Object &value, MemoryOrder memory_order=kRelaxedNonAtomic, OperandSize size=kWordBytes) override
void LoadClassById(Register result, Register class_id)
void StoreWordToPoolIndex(Register value, intptr_t index, Register pp=PP, Condition cond=AL)
void BranchLinkWithEquivalence(const Code &code, const Object &equivalence, CodeEntryKind entry_kind=CodeEntryKind::kNormal)
void PushValueAtOffset(Register base, int32_t offset)
void StoreWordUnaligned(Register src, Register addr, Register tmp)
void adds(Register rd, Register rn, Operand o, Condition cond=AL)
void vmovs(SRegister sd, SRegister sm, Condition cond=AL)
void Vdivqs(QRegister qd, QRegister qn, QRegister qm)
void PopRegisters(const RegisterSet ®s)
void muls(Register rd, Register rn, Register rm, Condition cond=AL)
void AddImmediateSetFlags(Register rd, Register rn, int32_t value, Condition cond=AL)
void cmn(Register rn, Operand o, Condition cond=AL)
void Push(Register rd, Condition cond=AL)
void Ror(Register rd, Register rm, const Operand &shift_imm, Condition cond=AL)
void mla(Register rd, Register rn, Register rm, Register ra, Condition cond=AL)
void LsrImmediate(Register rd, int32_t shift) override
void str(Register rd, Address ad, Condition cond=AL)
void OrImmediate(Register rd, int32_t imm, Condition cond=AL)
void BranchLinkOffset(Register base, int32_t offset)
void mov(Register rd, Operand o, Condition cond=AL)
void SetReturnAddress(Register value)
void vceqqs(QRegister qd, QRegister qn, QRegister qm)
void TransitionNativeToGenerated(Register scratch0, Register scratch1, bool exit_safepoint, bool ignore_unwind_in_progress=false)
void LoadPoolPointer(Register reg=PP)
void vsubs(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void tst(Register rn, Operand o, Condition cond=AL)
void LoadInt32FromBoxOrSmi(Register result, Register value) override
void vcgeqs(QRegister qd, QRegister qn, QRegister qm)
void BranchIf(Condition condition, Label *label, JumpDistance distance=kFarJump)
void EnterOsrFrame(intptr_t extra_size)
void vcvtsi(SRegister sd, SRegister sm, Condition cond=AL)
void vshlqu(OperandSize sz, QRegister qd, QRegister qm, QRegister qn)
void stm(BlockAddressMode am, Register base, RegList regs, Condition cond=AL)
void CompareObject(Register rn, const Object &object)
void vzipqw(QRegister qd, QRegister qm)
void vnegqs(QRegister qd, QRegister qm)
void Asr(Register rd, Register rm, const Operand &shift_imm, Condition cond=AL)
void LoadElementAddressForIntIndex(Register address, bool is_load, bool is_external, intptr_t cid, intptr_t index_scale, Register array, intptr_t index)
void Store(Register reg, const Address &address, OperandSize type=kFourBytes) override
void vmovsr(SRegister sn, Register rt, Condition cond=AL)
void vminqs(QRegister qd, QRegister qn, QRegister qm)
void PushObject(const Object &object)
void AndRegisters(Register dst, Register src1, Register src2=kNoRegister) override
void PopQuad(FpuRegister rd, Condition cond=AL)
void mvn_(Register rd, Operand o, Condition cond=AL)
void vtbl(DRegister dd, DRegister dn, int length, DRegister dm)
void LoadMultipleDFromOffset(DRegister first, intptr_t count, Register base, int32_t offset)
void ldm(BlockAddressMode am, Register base, RegList regs, Condition cond=AL)
void Rrx(Register rd, Register rm, Condition cond=AL)
void LoadNativeEntry(Register dst, const ExternalLabel *label, ObjectPoolBuilderEntry::Patchability patchable, Condition cond=AL)
void LsrImmediate(Register rd, Register rn, int32_t shift)
void ldrsh(Register rd, Address ad, Condition cond=AL)
void LoadElementAddressForRegIndex(Register address, bool is_load, bool is_external, intptr_t cid, intptr_t index_scale, bool index_unboxed, Register array, Register index)
void cmp(Register rn, Operand o, Condition cond=AL)
void LoadUnboxedSimd128(FpuRegister dst, Register base, int32_t offset)
void LoadQImmediate(QRegister dd, simd128_value_t value)
void StoreMemoryValue(Register src, Register base, int32_t offset)
void vmuls(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void StoreFieldToOffset(Register reg, Register base, int32_t offset, OperandSize type, Condition cond)
void bic(Register rd, Register rn, Operand o, Condition cond=AL)
Address ElementAddressForRegIndex(bool is_load, bool is_external, intptr_t cid, intptr_t index_scale, bool index_unboxed, Register array, Register index)
void smlal(Register rd_lo, Register rd_hi, Register rn, Register rm, Condition cond=AL)
Address PrepareLargeLoadOffset(const Address &addr, OperandSize sz, Condition cond)
void StoreToStack(Register src, intptr_t depth)
void vadds(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void InitializeFieldsNoBarrierUnrolled(Register object, Register base, intptr_t begin_offset, intptr_t end_offset, Register value_even, Register value_odd)
void vandq(QRegister qd, QRegister qn, QRegister qm)
void set_use_far_branches(bool b)
void nop(Condition cond=AL)
void vsubqs(QRegister qd, QRegister qn, QRegister qm)
void SubRegisters(Register dest, Register src)
void rbit(Register rd, Register rm, Condition cond=AL)
void StoreToOffset(Register reg, Register base, int32_t offset, OperandSize type, Condition cond)
void StoreInternalPointer(Register object, const Address &dest, Register value)
void vaddqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void MulImmediate(Register reg, int32_t imm, OperandSize width=kFourBytes) override
void AddRegisters(Register dest, Register src)
void rsb(Register rd, Register rn, Operand o, Condition cond=AL)
void Bind(Label *label) override
void ReserveAlignedFrameSpace(intptr_t frame_space)
void vstmd(BlockAddressMode am, Register base, DRegister first, intptr_t count, Condition cond=AL)
void blx(Register rm, Condition cond=AL)
void strd(Register rd, Register rd2, Register rn, int32_t offset, Condition cond=AL)
void vsqrts(SRegister sd, SRegister sm, Condition cond=AL)
void ldrsb(Register rd, Address ad, Condition cond=AL)
void MonomorphicCheckedEntryAOT()
void LoadImmediate(Register rd, int32_t value, Condition cond)
void sbc(Register rd, Register rn, Operand o, Condition cond=AL)
bool use_far_branches() const
void RangeCheck(Register value, Register temp, intptr_t low, intptr_t high, RangeCheckCondition condition, Label *target) override
void Ret(Condition cond=AL)
void vldrd(DRegister dd, Address ad, Condition cond=AL)
void movs(Register rd, Operand o, Condition cond=AL)
void LoadClassId(Register result, Register object, Condition cond=AL)
void sbcs(Register rd, Register rn, Operand o, Condition cond=AL)
void StoreMultipleDToOffset(DRegister first, intptr_t count, Register base, int32_t offset)
void teq(Register rn, Operand o, Condition cond=AL)
void bl(Label *label, Condition cond=AL)
void GenerateUnRelocatedPcRelativeCall(Condition cond=AL, intptr_t offset_into_target=0)
void PushImmediate(int32_t immediate)
bool constant_pool_allowed() const
void PopRegister(Register r)
void vorrq(QRegister qd, QRegister qn, QRegister qm)
void ArrayStoreBarrier(Register object, Register slot, Register value, CanBeSmi can_be_smi, Register scratch) override
void LslRegister(Register dst, Register shift) override
void strh(Register rd, Address ad, Condition cond=AL)
void add(Register rd, Register rn, Operand o, Condition cond=AL)
void ldrb(Register rd, Address ad, Condition cond=AL)
void StoreRelease(Register src, const Address &address, OperandSize size=kFourBytes) override
void ExitFullSafepoint(Register scratch0, Register scratch1, bool ignore_unwind_in_progress)
void LoadHalfWordUnsignedUnaligned(Register dst, Register addr, Register tmp)
void mul(Register rd, Register rn, Register rm, Condition cond=AL)
void Call(Address target, Condition cond=AL)
void vcvtud(SRegister sd, DRegister dm, Condition cond=AL)
void StoreSToOffset(SRegister reg, Register base, int32_t offset, Condition cond=AL)
void WriteAllocationCanary(Register top)
Address ElementAddressForIntIndex(bool is_load, bool is_external, intptr_t cid, intptr_t index_scale, Register array, intptr_t index, Register temp)
void vcvtds(DRegister dd, SRegister sm, Condition cond=AL)
void vmvnq(QRegister qd, QRegister qm)
void CallRuntime(const RuntimeEntry &entry, intptr_t argument_count)
void ExtractInstanceSizeFromTags(Register result, Register tags)
void LoadObject(Register rd, const Object &object, Condition cond=AL)
void Asrs(Register rd, Register rm, const Operand &shift_imm, Condition cond=AL)
void CompareRegisters(Register rn, Register rm)
void AndImmediate(Register rd, int32_t imm, Condition cond)
void ExtendValue(Register rd, Register rm, OperandSize sz) override
bool vmovs(SRegister sd, float s_imm, Condition cond=AL)
void CompareToStack(Register src, intptr_t depth)
void umull(Register rd_lo, Register rd_hi, Register rn, Register rm, Condition cond=AL)
void vrecpsqs(QRegister qd, QRegister qn, QRegister qm)
void sbfx(Register rd, Register rn, int32_t lsb, int32_t width, Condition cond=AL)
void SubImmediateSetFlags(Register rd, Register rn, int32_t value, Condition cond=AL)
void LeaveFrame(RegList regs, bool allow_pop_pc=false)
void LoadImmediate(Register rd, Immediate value, Condition cond=AL)
void bkpt(uint16_t imm16)
void VreciprocalSqrtqs(QRegister qd, QRegister qm)
void vceqqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void LoadImmediate(Register rd, int32_t value) override
void Vreciprocalqs(QRegister qd, QRegister qm)
void AddImmediate(Register rd, Register rn, int32_t value, Condition cond=AL)
void AndImmediate(Register rd, Register rs, int32_t imm, Condition cond=AL)
void adcs(Register rd, Register rn, Operand o, Condition cond=AL)
void vcugeqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void vmovrrs(Register rt, Register rt2, SRegister sm, Condition cond=AL)
void vsqrtd(DRegister dd, DRegister dm, Condition cond=AL)
void vmuld(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void LoadFromOffset(Register reg, Register base, int32_t offset, OperandSize type=kFourBytes) override
void vrsqrtsqs(QRegister qd, QRegister qn, QRegister qm)
void PushNativeCalleeSavedRegisters()
void Jump(const Address &address)
void vnegs(SRegister sd, SRegister sm, Condition cond=AL)
void vsubqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void vcvtsd(SRegister sd, DRegister dm, Condition cond=AL)
void adc(Register rd, Register rn, Operand o, Condition cond=AL)
static bool AddressCanHoldConstantIndex(const Object &constant, bool is_load, bool is_external, intptr_t cid, intptr_t index_scale, bool *needs_base=nullptr)
void LoadWordFromPoolIndex(Register rd, intptr_t index, Register pp=PP, Condition cond=AL)
void strb(Register rd, Address ad, Condition cond=AL)
void MaybeTraceAllocation(intptr_t cid, Label *trace, Register temp_reg, JumpDistance distance=JumpDistance::kFarJump)
void CallCFunction(Register target, Condition cond=AL)
void vdivs(SRegister sd, SRegister sn, SRegister sm, Condition cond=AL)
void BranchLinkPatchable(const Code &code, CodeEntryKind entry_kind=CodeEntryKind::kNormal, ObjectPoolBuilderEntry::SnapshotBehavior snapshot_behavior=ObjectPoolBuilderEntry::kSnapshotable)
void vmulqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void vcgeqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
static bool IsSafeSmi(const Object &object)
void vcgtqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void TransitionGeneratedToNative(Register destination_address, Register exit_frame_fp, Register exit_through_ffi, Register scratch0, bool enter_safepoint)
void and_(Register rd, Register rn, Operand o, Condition cond=AL)
void vabsqs(QRegister qd, QRegister qm)
void SubImmediate(Register rd, Register rn, int32_t value, Condition cond=AL)
void vcvtis(SRegister sd, SRegister sm, Condition cond=AL)
void Drop(intptr_t stack_elements)
void vabsd(DRegister dd, DRegister dm, Condition cond=AL)
void StoreUnboxedSimd128(FpuRegister src, Register base, int32_t offset)
void EnterCFrame(intptr_t frame_space)
void InitializeFieldsNoBarrier(Register object, Register begin, Register end, Register value_even, Register value_odd)
void StoreBarrier(Register object, Register value, CanBeSmi can_be_smi, Register scratch) override
compiler::LRState lr_state() const
void vcugtqi(OperandSize sz, QRegister qd, QRegister qn, QRegister qm)
void SmiTag(Register reg, Condition cond)
void AddScaled(Register dest, Register src, ScaleFactor scale, int32_t value)
void AndImmediate(Register rd, int32_t imm) override
void vmovq(QRegister qd, QRegister qm)
void vldrs(SRegister sd, Address ad, Condition cond=AL)
void vmlsd(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void ands(Register rd, Register rn, Operand o, Condition cond=AL)
void VerifyStoreNeedsNoWriteBarrier(Register object, Register value) override
void udiv(Register rd, Register rn, Register rm, Condition cond=AL)
void CompareWords(Register reg1, Register reg2, intptr_t offset, Register count, Register temp, Label *equals) override
void SmiUntag(Register dst, Register src, Label *is_smi)
void ExtendValue(Register rd, Register rm, OperandSize sz, Condition cond)
void clz(Register rd, Register rm, Condition cond=AL)
void BranchIfNotSmi(Register reg, Label *label, JumpDistance distance=kFarJump)
void MoveAndSmiTagRegister(Register rd, Register rm) override
void ldrh(Register rd, Address ad, Condition cond=AL)
void vmulqs(QRegister qd, QRegister qn, QRegister qm)
void vdup(OperandSize sz, QRegister qd, DRegister dm, int idx)
void vmrs(Register rd, Condition cond=AL)
void CallCFunction(Address target)
void vldmd(BlockAddressMode am, Register base, DRegister first, intptr_t count, Condition cond=AL)
void set_lr_state(compiler::LRState b)
void subs(Register rd, Register rn, Operand o, Condition cond=AL)
void vshlqi(OperandSize sz, QRegister qd, QRegister qm, QRegister qn)
static bool IsSafe(const Object &object)
void BranchIfBit(Register rn, intptr_t bit_number, Condition condition, Label *label, JumpDistance distance=kFarJump)
void OrImmediate(Register rd, Register rs, int32_t imm, Condition cond=AL)
void StoreIntoSmiField(const Address &dest, Register value)
void LoadFromOffset(Register reg, Register base, int32_t offset, OperandSize type, Condition cond)
void Vsqrtqs(QRegister qd, QRegister qm, QRegister temp)
void Jump(Register target)
void sdiv(Register rd, Register rn, Register rm, Condition cond=AL)
void mvns(Register rd, Operand o, Condition cond=AL)
void ldrd(Register rd, Register rd2, Register rn, int32_t offset, Condition cond=AL)
void LoadClassIdMayBeSmi(Register result, Register object)
void LoadSImmediate(SRegister sd, float value, Condition cond=AL)
void ldrex(Register rd, Register rn, Condition cond=AL)
void LoadUnboxedDouble(FpuRegister dst, Register base, int32_t offset)
void LoadIsolateGroup(Register dst)
void LoadFieldAddressForRegOffset(Register address, Register instance, Register offset_in_words_as_smi) override
void PopNativeCalleeSavedRegisters()
void AndImmediateSetFlags(Register rd, Register rn, int32_t value, Condition cond=AL)
void BranchOnMonomorphicCheckedEntryJIT(Label *label)
void Store(Register reg, const Address &address, OperandSize type, Condition cond)
void SmiUntag(Register reg, Condition cond=AL)
void MoveRegister(Register rd, Register rm, Condition cond)
void Breakpoint() override
void sub(Register rd, Register rn, Operand o, Condition cond=AL)
void vnegd(DRegister dd, DRegister dm, Condition cond=AL)
void LoadFieldAddressForOffset(Register address, Register instance, int32_t offset) override
void EmitEntryFrameVerification(Register scratch)
void TryAllocateArray(intptr_t cid, intptr_t instance_size, Label *failure, Register instance, Register end_address, Register temp1, Register temp2)
void CompareImmediate(Register rn, int32_t value, OperandSize width=kFourBytes) override
void EnterFrame(RegList regs, intptr_t frame_space)
void StoreToOffset(Register reg, Register base, int32_t offset, OperandSize type=kFourBytes) override
void vsubd(DRegister dd, DRegister dn, DRegister dm, Condition cond=AL)
void vrecpeqs(QRegister qd, QRegister qm)
void vmovdr(DRegister dd, int i, Register rt, Condition cond=AL)
void MaybeTraceAllocation(Register cid, Label *trace, Register temp_reg, JumpDistance distance=JumpDistance::kFarJump)
void vrsqrteqs(QRegister qd, QRegister qm)
void Asr(Register rd, Register rm, Register rs, Condition cond=AL)
void FinalizeHashForSize(intptr_t bit_size, Register dst, Register scratch=TMP) override
void strex(Register rd, Register rt, Register rn, Condition cond=AL)
void EnsureHasClassIdInDEBUG(intptr_t cid, Register src, Register scratch, bool can_be_null=false) override
void ExtendAndSmiTagValue(Register rd, Register rm, OperandSize sz, Condition cond)
void LslImmediate(Register rd, int32_t shift)
void rsc(Register rd, Register rn, Operand o, Condition cond=AL)
void LoadIndexedPayload(Register dst, Register base, int32_t payload_start, Register index, ScaleFactor scale, OperandSize type=kFourBytes) override
void StoreDToOffset(DRegister reg, Register base, int32_t offset, Condition cond=AL)
void AddImmediate(Register rd, int32_t value, Condition cond=AL)
void rsbs(Register rd, Register rn, Operand o, Condition cond=AL)
void vmovdrr(DRegister dm, Register rt, Register rt2, Condition cond=AL)
void MarkExceptionHandler(Label *label)
void vstms(BlockAddressMode am, Register base, SRegister first, SRegister last, Condition cond=AL)
void LoadDecodableImmediate(Register rd, int32_t value, Condition cond=AL)
void Branch(const Address &address, Condition cond=AL)
void EnterFullSafepoint(Register scratch0, Register scratch1)
static int32_t EncodeBranchOffset(int32_t offset, int32_t inst)
void CopyMemoryWords(Register src, Register dst, Register size, Register temp)
void LoadHalfWordUnaligned(Register dst, Register addr, Register tmp)
void umaal(Register rd_lo, Register rd_hi, Register rn, Register rm)
void StoreZero(const Address &address, Register temp)
Address PrepareLargeStoreOffset(const Address &addr, OperandSize sz, Condition cond)
void MoveAndSmiTagRegister(Register rd, Register rm, Condition cond)
void SetupGlobalPoolAndDispatchTable()
void SmiTag(Register reg) override
void Lsr(Register rd, Register rm, Register rs, Condition cond=AL)
void vmovrrd(Register rt, Register rt2, DRegister dm, Condition cond=AL)
void ArithmeticShiftRightImmediate(Register reg, intptr_t shift) override
FieldAddress & operator=(const FieldAddress &other)
FieldAddress(Register base, Register r)
FieldAddress(const FieldAddress &other)
FieldAddress(Register base, int32_t disp)
intptr_t far_branch_level() const
Operand(uint32_t immediate)
Operand(uint32_t rotate, uint32_t immed8)
static bool CanHold(uint32_t immediate, Operand *o)
Operand(const Operand &other)
Operand(Register rm, Shift shift, Register rs)
Operand & operator=(const Operand &other)
Operand(Register rm, Shift shift, uint32_t shift_imm)
static const char * begin(const StringSlice &s)
constexpr OperandSize kWordBytes
static DRegister EvenDRegisterOf(QRegister q)
static constexpr intptr_t kAllocationCanary
constexpr intptr_t kBitsPerInt32