5#ifndef RUNTIME_VM_COMPILER_ASSEMBLER_ASSEMBLER_IA32_H_
6#define RUNTIME_VM_COMPILER_ASSEMBLER_ASSEMBLER_IA32_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_ia32.h directly; use assembler.h instead.
29class Immediate :
public ValueObject {
35 int32_t
value()
const {
return value_; }
51 uint8_t
mod()
const {
return (encoding_at(0) >> 6) & 3; }
56 return static_cast<ScaleFactor>((encoding_at(1) >> 6) & 3);
60 return static_cast<Register>((encoding_at(1) >> 3) & 7);
67 return static_cast<int8_t
>(encoding_[length_ - 1]);
72 return bit_copy<int32_t>(encoding_[length_ - 4]);
76 memmove(&encoding_[0], &other.encoding_[0], other.length_);
80 length_ = other.length_;
81 memmove(&encoding_[0], &other.encoding_[0], other.length_);
86 if (length_ != other.length_)
return false;
87 for (uint8_t i = 0; i < length_; i++) {
88 if (encoding_[i] != other.encoding_[i])
return false;
98 encoding_[0] = (
mod << 6) |
rm;
110 ASSERT(length_ == 1 || length_ == 2);
111 encoding_[length_++] =
static_cast<uint8_t
>(disp);
115 ASSERT(length_ == 1 || length_ == 2);
116 intptr_t disp_size =
sizeof(disp);
117 memmove(&encoding_[length_], &disp, disp_size);
118 length_ += disp_size;
123 uint8_t encoding_[6];
129 uint8_t encoding_at(intptr_t
index)
const {
131 return encoding_[
index];
136 bool IsRegister(
Register reg)
const {
137 return ((encoding_[0] & 0xF8) == 0xC0)
138 && ((encoding_[0] & 0x07) == reg);
144class Address :
public Operand {
147 if (disp == 0 &&
base !=
EBP) {
175 if (disp == 0 &&
base !=
EBP) {
210class FieldAddress :
public Address {
232class Assembler :
public AssemblerBase {
476 F(and, 0x23, 0x21, 4) \
477 F(or, 0x0b, 0x09, 1) \
478 F(xor, 0x33, 0x31, 6) \
479 F(add, 0x03, 0x01, 0) \
480 F(adc, 0x13, 0x11, 2) \
481 F(sub, 0x2b, 0x29, 5) \
482 F(sbb, 0x1b, 0x19, 3) \
483 F(cmp, 0x3b, 0x39, 7)
486#define DECLARE_ALU(op, opcode, opcode2, modrm_opcode) \
487 void op##l(Register dst, Register src) { Alu(4, opcode, dst, src); } \
488 void op##w(Register dst, Register src) { Alu(2, opcode, dst, src); } \
489 void op##l(Register dst, const Address& src) { Alu(4, opcode, dst, src); } \
490 void op##w(Register dst, const Address& src) { Alu(2, opcode, dst, src); } \
491 void op##l(const Address& dst, Register src) { Alu(4, opcode2, dst, src); } \
492 void op##w(const Address& dst, Register src) { Alu(2, opcode2, dst, src); } \
493 void op##l(Register dst, const Immediate& imm) { \
494 Alu(modrm_opcode, dst, imm); \
496 void op##l(const Address& dst, const Immediate& imm) { \
497 Alu(modrm_opcode, dst, imm); \
601 j(condition, label, distance);
607 j(
ZERO, label, distance);
615 j(condition, label, distance);
624 int32_t payload_offset,
676 Load(dst, address, size);
677#if defined(TARGET_USES_THREAD_SANITIZER)
678#error No support for TSAN on IA32.
686 Store(src, address, size);
687#if defined(TARGET_USES_THREAD_SANITIZER)
688#error No support for TSAN on IA32.
696 cmpl(
value, address);
771 if (immediate == 0) {
786 void Drop(intptr_t stack_elements);
797 bool movable_referent =
false);
875 bool enter_safepoint);
878 bool ignore_unwind_in_progress =
false);
886 bool movable_target =
false,
906 Label* target)
override;
922 bool can_be_null =
false)
override;
932 intptr_t index_scale);
936 intptr_t index_scale,
939 intptr_t extra_disp = 0);
943 intptr_t index_scale,
947 intptr_t extra_disp = 0);
953 target::Field::host_offset_or_field_id_offset());
954 const intptr_t field_table_offset =
955 compiler::target::Thread::field_table_values_offset();
957 static_assert(
kSmiTagShift == 1,
"adjust scale factor");
958 leal(address,
Address(address, scratch, TIMES_HALF_WORD_SIZE, 0));
963 Register offset_in_words_as_smi)
override {
964 static_assert(
kSmiTagShift == 1,
"adjust scale factor");
970 int32_t
offset)
override {
975 return Address(
THR, target::Thread::vm_tag_offset());
999 target::Mint::value_offset()));
1014 j(
ZERO, label, distance);
1028 jmp(label, distance);
1106 intptr_t instance_size,
1113 intptr_t instance_size,
1125 Stop(
"Allocation canary");
1174 void Alu(
int bytes, uint8_t opcode,
Register dst,
const Address& src);
1175 void Alu(
int bytes, uint8_t opcode,
const Address& dst,
Register src);
1178 inline void EmitUint8(uint8_t value);
1179 inline void EmitInt32(int32_t value);
1180 inline void EmitRegisterOperand(
int rm,
int reg);
1181 inline void EmitXmmRegisterOperand(
int rm,
XmmRegister reg);
1183 inline void EmitOperandSizeOverride();
1185 void EmitOperand(
int rm,
const Operand& operand);
1186 void EmitImmediate(
const Immediate& imm);
1187 void EmitComplex(
int rm,
const Operand& operand,
const Immediate& immediate);
1188 void EmitLabel(
Label* label, intptr_t instruction_size);
1189 void EmitLabelLink(
Label* label);
1190 void EmitNearLabelLink(
Label* label);
1193 void EmitGenericShift(
int rm,
const Operand& operand,
Register shifter);
1195 int32_t jit_cookie();
1197 int32_t jit_cookie_;
1200 DISALLOW_ALLOCATION();
1204inline void Assembler::EmitUint8(uint8_t value) {
1208inline void Assembler::EmitInt32(int32_t value) {
1212inline void Assembler::EmitRegisterOperand(
int rm,
int reg) {
1213 ASSERT(rm >= 0 && rm < 8);
1217inline void Assembler::EmitXmmRegisterOperand(
int rm,
XmmRegister reg) {
1218 EmitRegisterOperand(rm,
static_cast<Register>(reg));
1221inline void Assembler::EmitFixup(AssemblerFixup* fixup) {
1225inline void Assembler::EmitOperandSizeOverride() {
static void done(const char *config, const char *src, const char *srcOptions, const char *name)
static bool equals(T *a, T *b)
#define DECLARE_ALU(op, opcode, opcode2, modrm_opcode)
#define ASSERT_EQUAL(expected, actual)
#define COMPILE_ASSERT(expr)
static bool IsInt(intptr_t N, T value)
static constexpr int ShiftForPowerOfTwo(T x)
static bool IsUint(intptr_t N, T value)
static constexpr bool IsPowerOfTwo(T x)
Address(Register base, Register index, ScaleFactor scale, int32_t disp)
Address(Register index, ScaleFactor scale, int32_t disp)
Address & operator=(const Address &other)
Address(Register base, int32_t disp)
Address(Register base, Register index, ScaleFactor scale, Register r)
Address(Register index, ScaleFactor scale, Register r)
static Address Absolute(const uword addr)
Address(const Address &other)
void Stop(const char *message)
ObjectPoolBuilder & object_pool_builder()
void EmitFixup(AssemblerFixup *fixup)
void PushRegistersInOrder(std::initializer_list< Register > regs)
void mull(const Address &address)
void maxps(XmmRegister dst, XmmRegister src)
void PopRegisterPair(Register r0, Register r1)
void MoveUnboxedDouble(FpuRegister dst, FpuRegister src)
void LoadClassId(Register result, Register object)
void imull(Register reg, const Address &address)
void Call(Address target)
void unpcklpd(XmmRegister dst, XmmRegister src)
void FloatNegate(XmmRegister f)
void AndImmediate(Register dst, Register src, int32_t value)
void cvtdq2pd(XmmRegister dst, XmmRegister src)
void StoreUnboxedDouble(FpuRegister src, Register base, int32_t offset)
void CompareObject(Register reg, const Object &object)
void movsd(XmmRegister dst, XmmRegister src)
void MoveUnboxedSimd128(FpuRegister dst, FpuRegister src)
void minpd(XmmRegister dst, XmmRegister src)
void fildl(const Address &src)
void LoadImmediate(Register reg, int32_t immediate) override
void CombineHashes(Register dst, Register other) override
void cmovns(Register dst, Register src)
void MonomorphicCheckedEntryJIT()
void BranchIfSmi(Register reg, Label *label, JumpDistance distance=kFarJump) override
void Jmp(const Code &code)
void LoadTaggedClassIdMayBeSmi(Register result, Register object)
void AndImmediate(Register dst, int32_t value) override
void movups(XmmRegister dst, const Address &src)
void shrdl(Register dst, Register src, const Immediate &imm)
void TransitionNativeToGenerated(Register scratch, bool exit_safepoint, bool ignore_unwind_in_progress=false)
static constexpr intptr_t kEnterStubFramePushedWords
void LoadSImmediate(XmmRegister dst, float value)
void LoadStaticFieldAddress(Register address, Register field, Register scratch)
void Load(Register reg, const Address &address, OperandSize type, Condition cond)
void BranchIfZero(Register src, Label *label, JumpDistance distance=kFarJump)
void unpckhpd(XmmRegister dst, XmmRegister src)
void movq(const Address &dst, XmmRegister src)
void PushRegisterPair(Register r0, Register r1)
void StoreZero(const Address &address, Register temp=kNoRegister)
void shldl(Register dst, Register src, Register shifter)
void CompareClassId(Register object, intptr_t class_id, Register scratch)
void movl(Register dst, const Address &src)
void EmitEntryFrameVerification()
void mulss(XmmRegister dst, XmmRegister src)
void IncrementSmiField(const Address &dest, int32_t increment)
void movd(Register dst, XmmRegister src)
void pxor(XmmRegister dst, XmmRegister src)
Assembler(ObjectPoolBuilder *object_pool_builder, intptr_t far_branch_level=0)
void jmp(const ExternalLabel *label)
void movlhps(XmmRegister dst, XmmRegister src)
void Load(Register dst, const Address &address, OperandSize sz=kFourBytes) override
void CallVmStub(const Code &code)
void movzxw(Register dst, const Address &src)
void movl(const Address &dst, Register src)
void ZeroInitSmiField(const Address &dest)
void pcmpeqq(XmmRegister dst, XmmRegister src)
void LoadDImmediate(XmmRegister dst, double value)
void lzcntl(Register dst, Register src)
void LoadFieldFromOffset(Register reg, Register base, int32_t offset, OperandSize type=kFourBytes) override
void cvtss2si(Register dst, XmmRegister src)
void movl(const Address &dst, const Immediate &imm)
void movd(XmmRegister dst, Register src)
void negateps(XmmRegister dst)
void movl(Register dst, const Immediate &src)
void cvtsi2ss(XmmRegister dst, Register src)
void filds(const Address &src)
void j(Condition condition, Label *label, JumpDistance distance=kFarJump)
void bt(Register base, int bit)
void SmiUntag(Register reg)
void TryAllocateObject(intptr_t cid, intptr_t instance_size, Label *failure, JumpDistance distance, Register instance_reg, Register temp_reg) override
void Jump(Label *label, JumpDistance distance=kFarJump)
void LoadAcquire(Register dst, const Address &address, OperandSize size=kFourBytes) override
void maxpd(XmmRegister dst, XmmRegister src)
void addpd(XmmRegister dst, XmmRegister src)
void LoadFromStack(Register dst, intptr_t depth)
void movss(const Address &dst, XmmRegister src)
void movmskpd(Register dst, XmmRegister src)
void leal(Register dst, const Address &src)
void shufps(XmmRegister dst, XmmRegister src, const Immediate &mask)
void zerowps(XmmRegister dst)
void shll(Register reg, const Immediate &imm)
void movb(const Address &dst, const Immediate &imm)
void shufpd(XmmRegister dst, XmmRegister src, const Immediate &mask)
void ret(const Immediate &imm)
void J(Condition condition, const Code &code)
void CompareWithMemoryValue(Register value, Address address, OperandSize size=kFourBytes) override
void imull(const Address &address)
void PushRegister(Register r)
void Store(Register src, const Address &address, OperandSize sz=kFourBytes) override
void LoadMemoryValue(Register dst, Register base, int32_t offset)
void movups(const Address &dst, XmmRegister src)
void cvtpd2ps(XmmRegister dst, XmmRegister src)
void set1ps(XmmRegister dst, Register tmp, const Immediate &imm)
void orps(XmmRegister dst, XmmRegister src)
void mulps(XmmRegister dst, XmmRegister src)
void divsd(XmmRegister dst, XmmRegister src)
void roundsd(XmmRegister dst, XmmRegister src, RoundingMode mode)
void cmove(Register dst, Register src)
void FinalizeHashForSize(intptr_t bit_size, Register dst, Register scratch=kNoRegister) override
void pextrd(Register dst, XmmRegister src, const Immediate &imm)
void cvtps2pd(XmmRegister dst, XmmRegister src)
void pushl(const Immediate &imm)
void Align(intptr_t alignment, intptr_t offset)
void subpl(XmmRegister dst, XmmRegister src)
void movsxw(Register dst, const Address &src)
void movw(Register dst, const Address &src)
void Call(const Code &code, bool movable_target=false, CodeEntryKind entry_kind=CodeEntryKind::kNormal)
void cmppsneq(XmmRegister dst, XmmRegister src)
void mulsd(XmmRegister dst, XmmRegister src)
void divpd(XmmRegister dst, XmmRegister src)
void movmskps(Register dst, XmmRegister src)
void Store(const Object &value, const Address &address)
void movsxb(Register dst, const Address &src)
void sqrtss(XmmRegister dst, XmmRegister src)
void jmp(Label *label, JumpDistance distance=kFarJump)
void rsqrtps(XmmRegister dst)
static bool AddressCanHoldConstantIndex(const Object &constant, bool is_external, intptr_t cid, intptr_t index_scale)
void testl(const Address &address, const Immediate &imm)
void cmppseq(XmmRegister dst, XmmRegister src)
void testl(const Address &address, Register reg)
void EnterFullSafepoint(Register scratch)
void LoadClassById(Register result, Register class_id)
void cvtss2sd(XmmRegister dst, XmmRegister src)
void movzxw(Register dst, Register src)
void cmovs(Register dst, Register src)
void movw(const Address &dst, Register src)
void addsd(XmmRegister dst, const Address &src)
void LoadQImmediate(XmmRegister dst, simd128_value_t value)
void MoveMemoryToMemory(Address to, Address from, Register tmp)
void andps(XmmRegister dst, const Address &src)
void PushValueAtOffset(Register base, int32_t offset)
void LoadIsolate(Register dst)
void xorpd(XmmRegister dst, const Address &src)
void imull(Register reg, const Immediate &imm)
void movsd(XmmRegister dst, const Address &src)
void sarl(const Address &address, Register shifter)
void fistpl(const Address &dst)
void shll(const Address &operand, Register shifter)
void CheckAllocationCanary(Register top)
void addss(XmmRegister dst, const Address &src)
void cmppsnle(XmmRegister dst, XmmRegister src)
void shll(Register operand, Register shifter)
void SetReturnAddress(Register value)
void flds(const Address &src)
void LoadInt32FromBoxOrSmi(Register result, Register value) override
void incl(const Address &address)
void BranchIf(Condition condition, Label *label, JumpDistance distance=kFarJump)
void EnterOsrFrame(intptr_t extra_size)
void divss(XmmRegister dst, const Address &src)
void popl(const Address &address)
void bt(Register base, Register offset)
void comisd(XmmRegister a, XmmRegister b)
void fstps(const Address &dst)
void PushObject(const Object &object)
void pmovsxdq(XmmRegister dst, XmmRegister src)
void AddImmediate(Register reg, const Immediate &imm)
void andpd(XmmRegister dst, XmmRegister src)
void AndRegisters(Register dst, Register src1, Register src2=kNoRegister) override
void sqrtpd(XmmRegister dst)
void testb(const Address &address, const Immediate &imm)
void sarl(Register reg, const Immediate &imm)
void movzxb(Register dst, const Address &src)
void LoadUnboxedSimd128(FpuRegister dst, Register base, int32_t offset)
void StoreMemoryValue(Register src, Register base, int32_t offset)
void divss(XmmRegister dst, XmmRegister src)
void shrdl(const Address &dst, Register src, Register shifter)
void testl(Register reg1, Register reg2)
void TransitionGeneratedToNative(Register destination_address, Register new_exit_frame, Register new_exit_through_ffi, bool enter_safepoint)
void LoadImmediate(Register reg, Immediate immediate)
void mulss(XmmRegister dst, const Address &src)
void cvttsd2si(Register dst, XmmRegister src)
void cmpw(const Address &address, const Immediate &imm)
void AddImmediate(Register dest, Register src, int32_t value)
void mulsd(XmmRegister dst, const Address &src)
void PushImmediate(int32_t value)
void StoreToStack(Register src, intptr_t depth)
void subpd(XmmRegister dst, XmmRegister src)
void movw(const Address &dst, const Immediate &imm)
void divsd(XmmRegister dst, const Address &src)
void SubRegisters(Register dest, Register src)
void StoreInternalPointer(Register object, const Address &dest, Register value)
void movb(const Address &dst, ByteRegister src)
void CompareRegisters(Register a, Register b)
void MulImmediate(Register reg, int32_t imm, OperandSize width=kFourBytes) override
void StoreObjectIntoObjectNoBarrier(Register object, const Address &dest, const Object &value, MemoryOrder memory_order=kRelaxedNonAtomic, OperandSize size=kFourBytes) override
void AddRegisters(Register dest, Register src)
void cmppslt(XmmRegister dst, XmmRegister src)
void sqrtsd(XmmRegister dst, XmmRegister src)
void andps(XmmRegister dst, XmmRegister src)
void Bind(Label *label) override
void ReserveAlignedFrameSpace(intptr_t frame_space)
void cmppsle(XmmRegister dst, XmmRegister src)
static intptr_t EntryPointToPcMarkerOffset()
void ExtendValue(Register to, Register from, OperandSize sz) override
void MonomorphicCheckedEntryAOT()
void cmovno(Register dst, Register src)
void xorpd(XmmRegister dst, XmmRegister src)
void andpd(XmmRegister dst, const Address &src)
void RangeCheck(Register value, Register temp, intptr_t low, intptr_t high, RangeCheckCondition condition, Label *target) override
void cmovne(Register dst, Register src)
void enter(const Immediate &imm)
void setcc(Condition condition, ByteRegister dst)
void cvtsi2sd(XmmRegister dst, Register src)
void PopRegister(Register r)
void ArrayStoreBarrier(Register object, Register slot, Register value, CanBeSmi can_be_smi, Register scratch) override
void LslRegister(Register dst, Register shift) override
void movl(Register dst, Register src)
void xchgl(Register dst, Register src)
void subss(XmmRegister dst, XmmRegister src)
void OrImmediate(Register dst, int32_t value)
void StoreRelease(Register src, const Address &address, OperandSize size=kFourBytes) override
void movq(XmmRegister dst, const Address &src)
void xorps(XmmRegister dst, const Address &src)
void shrl(Register operand, Register shifter)
void subps(XmmRegister dst, XmmRegister src)
void SmiUntagOrCheckClass(Register object, intptr_t class_id, Register scratch, Label *is_smi)
void Call(Address target, Condition cond=AL)
void popcntl(Register dst, Register src)
void TryAllocateArray(intptr_t cid, intptr_t instance_size, Label *failure, JumpDistance distance, Register instance, Register end_address, Register temp)
void CallCFunction(Register target)
void WriteAllocationCanary(Register top)
void subss(XmmRegister dst, const Address &src)
void addpl(XmmRegister dst, XmmRegister src)
void subsd(XmmRegister dst, const Address &src)
void CallRuntime(const RuntimeEntry &entry, intptr_t argument_count)
void LockCmpxchgl(const Address &address, Register reg)
void LoadObject(Register rd, const Object &object, Condition cond=AL)
void CompareRegisters(Register rn, Register rm)
void CopyMemoryWords(Register src, Register dst, Register size, Register temp=kNoRegister)
void fnstcw(const Address &dst)
void negatepd(XmmRegister dst)
void CompareToStack(Register src, intptr_t depth)
void EnterDartFrame(intptr_t frame_size)
void LoadImmediate(Register rd, Immediate value, Condition cond=AL)
void addsd(XmmRegister dst, XmmRegister src)
void LoadObject(Register dst, const Object &object, bool movable_referent=false)
void fldcw(const Address &src)
static Address ElementAddressForRegIndex(bool is_external, intptr_t cid, intptr_t index_scale, bool index_unboxed, Register array, Register index, intptr_t extra_disp=0)
void movb(const Address &dst, Register src)
static Address VMTagAddress()
void LoadUniqueObject(Register dst, const Object &object)
void xorps(XmmRegister dst, XmmRegister src)
void cvtsd2ss(XmmRegister dst, XmmRegister src)
void CompareObjectRegisters(Register a, Register b)
void cvtsd2si(Register dst, XmmRegister src)
void bsfl(Register dst, Register src)
void notps(XmmRegister dst)
void MaybeTraceAllocation(intptr_t cid, Label *trace, Register temp_reg, JumpDistance distance=JumpDistance::kFarJump)
void j(Condition condition, const ExternalLabel *label)
void absps(XmmRegister dst)
void subsd(XmmRegister dst, XmmRegister src)
static bool IsSafeSmi(const Object &object)
void movsxb(Register dst, ByteRegister src)
void Drop(intptr_t stack_elements)
void imull(Register dst, Register src)
void DoubleAbs(XmmRegister reg)
void reciprocalps(XmmRegister dst)
void minps(XmmRegister dst, XmmRegister src)
void EnterCFrame(intptr_t frame_space)
void StoreBarrier(Register object, Register value, CanBeSmi can_be_smi, Register scratch) override
void testb(const Address &address, ByteRegister reg)
void AddImmediate(Register reg, int32_t value)
void call(const Address &address)
void AddScaled(Register dest, Register src, ScaleFactor scale, int32_t value)
void VerifyStoreNeedsNoWriteBarrier(Register object, Register value) override
void CompareWords(Register reg1, Register reg2, intptr_t offset, Register count, Register temp, Label *equals) override
Object & GetSelfHandle() const
void addss(XmmRegister dst, XmmRegister src)
void shldl(Register dst, Register src, const Immediate &imm)
void testl(Register reg, const Immediate &imm)
void SubImmediate(Register reg, const Immediate &imm)
void mulpd(XmmRegister dst, XmmRegister src)
void pmovmskb(Register dst, XmmRegister src)
void movhlps(XmmRegister dst, XmmRegister src)
void movb(Register dst, const Address &src)
void BranchIfNotSmi(Register reg, Label *label, JumpDistance distance=kFarJump)
void CallCFunction(Address target)
void LslImmediate(Register dst, int32_t shift)
void divps(XmmRegister dst, XmmRegister src)
void EnterFrame(intptr_t frame_space)
static bool IsSafe(const Object &object)
void jmp(const Address &address)
void BranchIfBit(Register rn, intptr_t bit_number, Condition condition, Label *label, JumpDistance distance=kFarJump)
void abspd(XmmRegister dst)
void StoreIntoSmiField(const Address &dest, Register value)
void Jump(Register target)
void addps(XmmRegister dst, XmmRegister src)
void call(const ExternalLabel *label)
void fistps(const Address &dst)
void LoadClassIdMayBeSmi(Register result, Register object)
void sarl(Register operand, Register shifter)
void DoubleNegate(XmmRegister d)
void LoadUnboxedDouble(FpuRegister dst, Register base, int32_t offset)
void LoadIndexedPayload(Register dst, Register base, int32_t payload_offset, Register index, ScaleFactor scale, OperandSize sz=kFourBytes) override
void shrl(Register reg, const Immediate &imm)
void cvttss2si(Register dst, XmmRegister src)
void movss(XmmRegister dst, XmmRegister src)
void LoadIsolateGroup(Register dst)
void LoadFieldAddressForRegOffset(Register address, Register instance, Register offset_in_words_as_smi) override
void cmovgel(Register dst, Register src)
void movsd(const Address &dst, XmmRegister src)
void BranchOnMonomorphicCheckedEntryJIT(Label *label)
void Store(Register reg, const Address &address, OperandSize type, Condition cond)
void movzxb(Register dst, ByteRegister src)
void SmiUntag(Register reg, Condition cond=AL)
void movss(XmmRegister dst, const Address &src)
void cmpxchgl(const Address &address, Register reg)
void MoveRegister(Register rd, Register rm, Condition cond)
void Breakpoint() override
void LoadFieldAddressForOffset(Register address, Register instance, int32_t offset) override
void decl(const Address &address)
static constexpr intptr_t kCallExternalLabelSize
void StoreUnboxedSimd128(FpuRegister dst, Register base, int32_t offset)
void sqrtps(XmmRegister dst)
void fldl(const Address &src)
void unpckhps(XmmRegister dst, XmmRegister src)
void cmovlessl(Register dst, Register src)
void EnsureHasClassIdInDEBUG(intptr_t cid, Register src, Register scratch, bool can_be_null=false) override
void orpd(XmmRegister dst, XmmRegister src)
void cmpb(const Address &address, const Immediate &imm)
void LoadObjectSafely(Register dst, const Object &object)
void shrdl(Register dst, Register src, Register shifter)
void pushl(const Address &address)
void AddImmediate(Register rd, int32_t value, Condition cond=AL)
static Address ElementAddressForIntIndex(bool is_external, intptr_t cid, intptr_t index_scale, Register array, intptr_t index, intptr_t extra_disp=0)
void cmppsnlt(XmmRegister dst, XmmRegister src)
void LsrImmediate(Register dst, int32_t shift) override
void ExitFullSafepoint(Register scratch, bool ignore_unwind_in_progress)
void movsxw(Register dst, Register src)
void shldl(const Address &operand, Register src, Register shifter)
void fstpl(const Address &dst)
void bsrl(Register dst, Register src)
static constexpr intptr_t kEntryPointToPcMarkerOffset
void SmiTag(Register reg) override
void unpcklps(XmmRegister dst, XmmRegister src)
void CompareImmediate(Register reg, int32_t immediate, OperandSize width=kFourBytes) override
void comiss(XmmRegister a, XmmRegister b)
void ffree(intptr_t value)
void ArithmeticShiftRightImmediate(Register reg, intptr_t shift) override
void movaps(XmmRegister dst, XmmRegister src)
FieldAddress & operator=(const FieldAddress &other)
FieldAddress(Register base, Register r)
FieldAddress(Register base, Register index, ScaleFactor scale, Register r)
FieldAddress(const FieldAddress &other)
FieldAddress(Register base, Register index, ScaleFactor scale, int32_t disp)
FieldAddress(Register base, int32_t disp)
intptr_t far_branch_level() const
bool Equals(const Operand &other) const
void SetSIB(ScaleFactor scale, Register index, Register base)
Operand(const Operand &other)
void SetDisp8(int8_t disp)
Operand & operator=(const Operand &other)
void SetModRM(int mod, Register rm)
void SetDisp32(int32_t disp)
ScaleFactor scale() const
VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE auto & d
Object & NewZoneHandle(Zone *zone)
bool HasIntegerValue(const dart::Object &object, int64_t *value)
static constexpr intptr_t kAllocationCanary