tiny.choir.backends.aarch64.encoding

1pub const AddSubExtend = enum(u3) {2    uxtb = 0b000,3    uxth = 0b001,4    uxtw = 0b010,5    uxtx = 0b011,6    sxtb = 0b100,7    sxth = 0b101,8    sxtw = 0b110,9    sxtx = 0b111,10};

1pub const AddSubExtendedRegister = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    imm3: u3,5    option: AddSubExtend,6    rm: Encoded,7    fixed0: u1 = 1,8    fixed1: u2 = 0b01,9    fixed2: u5 = 0b01011,10    s: u1,11    op: u1,12    sf: u1,13};

1pub const AddSubImmediate = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    imm12: u12,5    sh: u1,6    fixed: u6 = 0b100010,7    s: u1,8    op: AddSubOp,9    sf: u1,1011    pub const AddSubOp = enum(u1) { add = 0, sub = 1 };1213    pub fn add(rd: Encoded, rn: Encoded, imm: u12, size: GPRSize) Instruction {14        return .{15            .data_processing_imm = .{16                .add_sub_imm = .{17                    .rd = rd,18                    .rn = rn,19                    .imm12 = imm,20                    .sh = 0,21                    .s = 0,22                    .op = .add,23                    .sf = @backingInt(size),24                },25            },26        };27    }2829    pub fn adds(rd: Encoded, rn: Encoded, imm: u12, size: GPRSize) Instruction {30        return .{31            .data_processing_imm = .{32                .add_sub_imm = .{33                    .rd = rd,34                    .rn = rn,35                    .imm12 = imm,36                    .sh = 0,37                    .s = 1,38                    .op = .add,39                    .sf = @backingInt(size),40                },41            },42        };43    }4445    pub fn sub(rd: Encoded, rn: Encoded, imm: u12, size: GPRSize) Instruction {46        return .{47            .data_processing_imm = .{48                .add_sub_imm = .{49                    .rd = rd,50                    .rn = rn,51                    .imm12 = imm,52                    .sh = 0,53                    .s = 0,54                    .op = .sub,55                    .sf = @backingInt(size),56                },57            },58        };59    }6061    pub fn subs(rd: Encoded, rn: Encoded, imm: u12, size: GPRSize) Instruction {62        return .{63            .data_processing_imm = .{64                .add_sub_imm = .{65                    .rd = rd,66                    .rn = rn,67                    .imm12 = imm,68                    .sh = 0,69                    .s = 1,70                    .op = .sub,71                    .sf = @backingInt(size),72                },73            },74        };75    }7677    pub fn cmpImm(rn: Encoded, imm: u12, size: GPRSize) Instruction {78        return subs(registers.ZR.encoded, rn, imm, size);79    }80};

1pub const AddSubShift = enum(u2) {2    lsl = 0b00,3    lsr = 0b01,4    asr = 0b10,5    reserved = 0b11,6};

1pub const AddSubShiftedRegister = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    imm6: u6,5    rm: Encoded,6    fixed0: u1 = 0,7    shift: AddSubShift,8    fixed1: u5 = 0b01011,9    s: u1,10    op: u1,11    sf: u1,1213    pub fn addReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {14        return .{15            .data_processing_reg = .{16                .add_sub_shifted = .{17                    .rd = rd,18                    .rn = rn,19                    .imm6 = 0,20                    .rm = rm,21                    .shift = .lsl,22                    .s = 0,23                    .op = 0,24                    .sf = @backingInt(size),25                },26            },27        };28    }2930    pub fn addsReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {31        return .{32            .data_processing_reg = .{33                .add_sub_shifted = .{34                    .rd = rd,35                    .rn = rn,36                    .imm6 = 0,37                    .rm = rm,38                    .shift = .lsl,39                    .s = 1,40                    .op = 0,41                    .sf = @backingInt(size),42                },43            },44        };45    }4647    pub fn subReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {48        return .{49            .data_processing_reg = .{50                .add_sub_shifted = .{51                    .rd = rd,52                    .rn = rn,53                    .imm6 = 0,54                    .rm = rm,55                    .shift = .lsl,56                    .s = 0,57                    .op = 1,58                    .sf = @backingInt(size),59                },60            },61        };62    }6364    pub fn subsReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {65        return .{66            .data_processing_reg = .{67                .add_sub_shifted = .{68                    .rd = rd,69                    .rn = rn,70                    .imm6 = 0,71                    .rm = rm,72                    .shift = .lsl,73                    .s = 1,74                    .op = 1,75                    .sf = @backingInt(size),76                },77            },78        };79    }8081    pub fn cmpReg(rn: Encoded, rm: Encoded, size: GPRSize) Instruction {82        return subsReg(registers.ZR.encoded, rn, rm, size);83    }84};

1pub const Branch = packed union {2    unconditional_imm: UnconditionalBranchImm,3    conditional: ConditionalBranch,4    unconditional_reg: UnconditionalBranchReg,5    raw: u32,6};

1pub const Condition = enum(u4) {2    eq = 0b0000,3    ne = 0b0001,4    cs = 0b0010,5    cc = 0b0011,6    mi = 0b0100,7    pl = 0b0101,8    vs = 0b0110,9    vc = 0b0111,10    hi = 0b1000,11    ls = 0b1001,12    ge = 0b1010,13    lt = 0b1011,14    gt = 0b1100,15    le = 0b1101,16    al = 0b1110,17    nv = 0b1111,1819    pub const hs = Condition.cs;20    pub const lo = Condition.cc;2122    pub fn invert(self: Condition) Condition {23        return @fromBackingInt(@intCast(@backingInt(self) ^ 1));24    }25};

1pub const ConditionalBranch = packed struct(u32) {2    cond: Condition,3    fixed0: u1 = 0,4    imm19: i19,5    fixed1: u1 = 0,6    fixed2: u7 = 0b0101010,78    pub fn bCond(cond: Condition, offset: i19) Instruction {9        return .{10            .branch = .{11                .conditional = .{12                    .cond = cond,13                    .imm19 = offset,14                },15            },16        };17    }18};

1pub const ConditionalSelect = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    op2: u2,5    cond: Condition,6    rm: Encoded,7    fixed0: u1 = 0,8    fixed1: u2 = 0b10,9    fixed2: u5 = 0b11010,10    s: u1 = 0,11    op: u1,12    sf: u1,1314    pub fn csel(rd: Encoded, rn: Encoded, rm: Encoded, cond: Condition, size: GPRSize) Instruction {15        return .{16            .data_processing_reg = .{17                .conditional_select = .{18                    .rd = rd,19                    .rn = rn,20                    .op2 = 0b00,21                    .cond = cond,22                    .rm = rm,23                    .op = 0,24                    .sf = @backingInt(size),25                },26            },27        };28    }2930    pub fn cset(rd: Encoded, cond: Condition, size: GPRSize) Instruction {31        return .{32            .data_processing_reg = .{33                .conditional_select = .{34                    .rd = rd,35                    .rn = registers.ZR.encoded,36                    .op2 = 0b01,37                    .cond = cond.invert(),38                    .rm = registers.ZR.encoded,39                    .op = 0,40                    .sf = @backingInt(size),41                },42            },43        };44    }45};

1pub const DataProcessing2Source = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    opcode: DataProcessing2SourceOpcode,5    rm: Encoded,6    fixed: u8 = 0b11010110,7    s: u1 = 0,8    fixed2: u1 = 0,9    sf: u1,1011    pub fn udiv(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {12        return .{13            .data_processing_reg = .{14                .data_proc_2src = .{15                    .rd = rd,16                    .rn = rn,17                    .opcode = .udiv,18                    .rm = rm,19                    .sf = @backingInt(size),20                },21            },22        };23    }2425    pub fn sdiv(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {26        return .{27            .data_processing_reg = .{28                .data_proc_2src = .{29                    .rd = rd,30                    .rn = rn,31                    .opcode = .sdiv,32                    .rm = rm,33                    .sf = @backingInt(size),34                },35            },36        };37    }38};

1pub const DataProcessing2SourceOpcode = enum(u6) {2    udiv = 0b000010,3    sdiv = 0b000011,4    lslv = 0b001000,5    lsrv = 0b001001,6    asrv = 0b001010,7    rorv = 0b001011,8};

1pub const DataProcessing3Source = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    ra: Encoded,5    o0: u1,6    rm: Encoded,7    op31: u3,8    fixed: u5 = 0b11011,9    op54: u2,10    sf: u1,1112    pub fn mul(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {13        return madd(rd, rn, rm, registers.ZR.encoded, size);14    }1516    pub fn madd(rd: Encoded, rn: Encoded, rm: Encoded, ra: Encoded, size: GPRSize) Instruction {17        return .{18            .data_processing_reg = .{19                .data_proc_3src = .{20                    .rd = rd,21                    .rn = rn,22                    .ra = ra,23                    .o0 = 0,24                    .rm = rm,25                    .op31 = 0b000,26                    .op54 = 0b00,27                    .sf = @backingInt(size),28                },29            },30        };31    }3233    pub fn msub(rd: Encoded, rn: Encoded, rm: Encoded, ra: Encoded, size: GPRSize) Instruction {34        return .{35            .data_processing_reg = .{36                .data_proc_3src = .{37                    .rd = rd,38                    .rn = rn,39                    .ra = ra,40                    .o0 = 1,41                    .rm = rm,42                    .op31 = 0b000,43                    .op54 = 0b00,44                    .sf = @backingInt(size),45                },46            },47        };48    }49};

1pub const DataProcessingImmediate = packed union {2    add_sub_imm: AddSubImmediate,3    move_wide: MoveWide,4    logical_imm: LogicalImmediate,5    raw: u32,6};

1pub const DataProcessingRegister = packed union {2    add_sub_shifted: AddSubShiftedRegister,3    add_sub_extended: AddSubExtendedRegister,4    logical_shifted: LogicalShiftedRegister,5    data_proc_2src: DataProcessing2Source,6    data_proc_3src: DataProcessing3Source,7    conditional_select: ConditionalSelect,8    raw: u32,9};

1pub const FMovGeneral = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    fixed0: u6 = 0b000000,5    opcode: u3,6    rmode: u2,7    fixed1: u1 = 1,8    ptype: u2,9    fixed2: u5 = 0b11110,10    s: u1 = 0,11    fixed3: u1 = 0,12    sf: u1,1314    pub fn fmovToFprSingle(rd: Encoded, rn: Encoded) Instruction {15        return .{16            .fp_data_processing = .{17                .fmov_general = .{18                    .rd = rd,19                    .rn = rn,20                    .opcode = 0b111,21                    .rmode = 0b00,22                    .ptype = 0b00,23                    .sf = 0,24                },25            },26        };27    }2829    pub fn fmovToFprDouble(rd: Encoded, rn: Encoded) Instruction {30        return .{31            .fp_data_processing = .{32                .fmov_general = .{33                    .rd = rd,34                    .rn = rn,35                    .opcode = 0b111,36                    .rmode = 0b00,37                    .ptype = 0b01,38                    .sf = 1,39                },40            },41        };42    }4344    pub fn fmovFromFprSingle(rd: Encoded, rn: Encoded) Instruction {45        return .{46            .fp_data_processing = .{47                .fmov_general = .{48                    .rd = rd,49                    .rn = rn,50                    .opcode = 0b110,51                    .rmode = 0b00,52                    .ptype = 0b00,53                    .sf = 0,54                },55            },56        };57    }5859    pub fn fmovFromFprDouble(rd: Encoded, rn: Encoded) Instruction {60        return .{61            .fp_data_processing = .{62                .fmov_general = .{63                    .rd = rd,64                    .rn = rn,65                    .opcode = 0b110,66                    .rmode = 0b00,67                    .ptype = 0b01,68                    .sf = 1,69                },70            },71        };72    }73};

1pub const FP1Source = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    fixed0: u5 = 0b10000,5    opcode: FP1SourceOpcode,6    fixed1: u1 = 1,7    ptype: FP2Source.FPType,8    fixed2: u5 = 0b11110,9    s: u1 = 0,10    fixed3: u1 = 0,11    m: u1 = 0,1213    pub fn fabs(rd: Encoded, rn: Encoded, ftype: FP2Source.FPType) Instruction {14        return .{15            .fp_data_processing = .{16                .fp_1src = .{17                    .rd = rd,18                    .rn = rn,19                    .opcode = .fabs,20                    .ptype = ftype,21                },22            },23        };24    }2526    pub fn fneg(rd: Encoded, rn: Encoded, ftype: FP2Source.FPType) Instruction {27        return .{28            .fp_data_processing = .{29                .fp_1src = .{30                    .rd = rd,31                    .rn = rn,32                    .opcode = .fneg,33                    .ptype = ftype,34                },35            },36        };37    }3839    pub fn fsqrt(rd: Encoded, rn: Encoded, ftype: FP2Source.FPType) Instruction {40        return .{41            .fp_data_processing = .{42                .fp_1src = .{43                    .rd = rd,44                    .rn = rn,45                    .opcode = .fsqrt,46                    .ptype = ftype,47                },48            },49        };50    }5152    pub fn fmov(rd: Encoded, rn: Encoded, ftype: FP2Source.FPType) Instruction {53        return .{54            .fp_data_processing = .{55                .fp_1src = .{56                    .rd = rd,57                    .rn = rn,58                    .opcode = .fmov,59                    .ptype = ftype,60                },61            },62        };63    }64};

1pub const FP1SourceOpcode = enum(u6) {2    fmov = 0b000000,3    fabs = 0b000001,4    fneg = 0b000010,5    fsqrt = 0b000011,6};

1pub const FP2Source = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    fixed0: u2 = 0b10,5    opcode: FP2SourceOpcode,6    rm: Encoded,7    fixed1: u1 = 1,8    ptype: FPType,9    fixed2: u5 = 0b11110,10    m: u1 = 0,11    fixed3: u1 = 0,12    s: u1 = 0,1314    pub const FPType = enum(u2) {15        single = 0b00,16        double = 0b01,17        half = 0b11,18    };1920    pub fn fadd(rd: Encoded, rn: Encoded, rm: Encoded, ftype: FPType) Instruction {21        return .{22            .fp_data_processing = .{23                .fp_2src = .{24                    .rd = rd,25                    .rn = rn,26                    .opcode = .fadd,27                    .rm = rm,28                    .ptype = ftype,29                },30            },31        };32    }3334    pub fn fsub(rd: Encoded, rn: Encoded, rm: Encoded, ftype: FPType) Instruction {35        return .{36            .fp_data_processing = .{37                .fp_2src = .{38                    .rd = rd,39                    .rn = rn,40                    .opcode = .fsub,41                    .rm = rm,42                    .ptype = ftype,43                },44            },45        };46    }4748    pub fn fmul(rd: Encoded, rn: Encoded, rm: Encoded, ftype: FPType) Instruction {49        return .{50            .fp_data_processing = .{51                .fp_2src = .{52                    .rd = rd,53                    .rn = rn,54                    .opcode = .fmul,55                    .rm = rm,56                    .ptype = ftype,57                },58            },59        };60    }6162    pub fn fdiv(rd: Encoded, rn: Encoded, rm: Encoded, ftype: FPType) Instruction {63        return .{64            .fp_data_processing = .{65                .fp_2src = .{66                    .rd = rd,67                    .rn = rn,68                    .opcode = .fdiv,69                    .rm = rm,70                    .ptype = ftype,71                },72            },73        };74    }75};

1pub const FP2SourceOpcode = enum(u4) {2    fmul = 0b0000,3    fdiv = 0b0001,4    fadd = 0b0010,5    fsub = 0b0011,6    fmax = 0b0100,7    fmin = 0b0101,8};

1pub const FPCompare = packed struct(u32) {2    opcode2: u5,3    rn: Encoded,4    fixed0: u4 = 0b1000,5    op: u2,6    rm: Encoded,7    fixed1: u1 = 1,8    ptype: FP2Source.FPType,9    fixed2: u5 = 0b11110,10    m: u1 = 0,11    fixed3: u1 = 0,12    s: u1 = 0,1314    pub fn fcmp(rn: Encoded, rm: Encoded, ftype: FP2Source.FPType) Instruction {15        return .{16            .fp_data_processing = .{17                .fp_compare = .{18                    .opcode2 = 0b00000,19                    .rn = rn,20                    .op = 0b00,21                    .rm = rm,22                    .ptype = ftype,23                },24            },25        };26    }2728    pub fn fcmpZero(rn: Encoded, ftype: FP2Source.FPType) Instruction {29        return .{30            .fp_data_processing = .{31                .fp_compare = .{32                    .opcode2 = 0b01000,33                    .rn = rn,34                    .op = 0b00,35                    .rm = @fromBackingInt(@intCast(0)),36                    .ptype = ftype,37                },38            },39        };40    }41};

1pub const FPConversion = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    fixed0: u6 = 0b000000,5    opcode: u3,6    rmode: u2,7    fixed1: u1 = 0,8    ptype: u2,9    fixed2: u5 = 0b11110,10    s: u1 = 0,11    fixed3: u1 = 0,12    sf: u1,13};

1pub const FPDataProcessing = packed union {2    fp_1src: FP1Source,3    fp_2src: FP2Source,4    fp_compare: FPCompare,5    fp_conversion: FPConversion,6    fp_imm: FPImmediate,7    fmov_general: FMovGeneral,8    raw: u32,9};

1pub const FPImmediate = packed struct(u32) {2    rd: Encoded,3    fixed0: u5 = 0b00000,4    fixed1: u3 = 0b100,5    imm8: u8,6    ptype: FPImmediateType,7    fixed2: u5 = 0b11100,8    fixed3: u4 = 0b0001,910    fn immTypeFromFP(ftype: FP2Source.FPType) FPImmediateType {11        return switch (ftype) {12            .half => .half,13            .single => .single,14            .double => .double,15        };16    }1718    pub fn fmovImm(rd: Encoded, imm8: u8, ftype: FP2Source.FPType) Instruction {19        return .{20            .fp_data_processing = .{21                .fp_imm = .{22                    .rd = rd,23                    .imm8 = imm8,24                    .ptype = immTypeFromFP(ftype),25                },26            },27        };28    }2930    pub fn encodeF32(value: f32) ?u8 {31        const bits: u32 = @bitCast(value);32        const sign: u8 = @intCast(bits >> 31);33        const exp: u8 = @intCast((bits >> 23) & 0xFF);34        const frac: u32 = bits & 0x7FFFFF;3536        const exp_high: u8 = exp >> 3;37        if (exp_high != 0x0F and exp_high != 0x10) return null;38        if ((frac & 0x7FFFF) != 0) return null;3940        const exp_low: u8 = exp & 0x7;41        const frac_top: u8 = @intCast(frac >> 19);42        return (sign << 7) | (exp_low << 4) | frac_top;43    }4445    pub fn encodeF64(value: f64) ?u8 {46        const bits: u64 = @bitCast(value);47        const sign: u8 = @intCast(bits >> 63);48        const exp: u16 = @intCast((bits >> 52) & 0x7FF);49        const frac: u64 = bits & 0xFFFFFFFFFFFFF;5051        const exp_high: u16 = exp >> 3;52        if (exp_high != 0x7F and exp_high != 0x80) return null;53        if ((frac & 0xFFFFFFFFFFFF) != 0) return null;5455        const exp_low: u8 = @intCast(exp & 0x7);56        const frac_top: u8 = @intCast(frac >> 48);57        return (sign << 7) | (exp_low << 4) | frac_top;58    }59};

1pub const FPImmediateType = enum(u2) {2    half = 0b00,3    single = 0b01,4    double = 0b11,5};

1pub const Instruction = packed union {2    data_processing_imm: DataProcessingImmediate,3    data_processing_reg: DataProcessingRegister,4    load_store: LoadStore,5    branch: Branch,6    fp_data_processing: FPDataProcessing,7    raw: u32,89    pub const size = 4;1011    pub fn toBytes(self: Instruction) [4]u8 {12        var buf: [4]u8 = undefined;13        std.mem.writeInt(u32, buf[0..4], self.raw, .little);14        return buf;15    }1617    pub fn fromBytes(bytes: [4]u8) Instruction {18        return .{ .raw = std.mem.readInt(u32, bytes[0..4], .little) };19    }2021    pub fn write(self: Instruction, buf: []u8) void {22        std.mem.writeInt(u32, buf[0..4], self.raw, .little);23    }24};

1pub const LoadStore = packed union {2    load_store_reg_imm: LoadStoreRegImm,3    load_store_reg_imm_fp: LoadStoreRegImmFP,4    load_store_pair: LoadStorePair,5    load_store_pair_fp: LoadStorePairFP,6    raw: u32,7};

1pub const LoadStoreFPSize = enum(u2) {2    single = 0b10,3    double = 0b11,4};

1pub const LoadStorePair = packed struct(u32) {2    rt: Encoded,3    rn: Encoded,4    rt2: Encoded,5    imm7: i7,6    l: u1,7    op2: LoadStorePairMode,8    v: u1 = 0,9    fixed: u3 = 0b101,10    opc: u2,1112    pub fn stp(rt: Encoded, rt2: Encoded, rn: Encoded, offset: i7, gpr_size: GPRSize) Instruction {13        return .{14            .load_store = .{15                .load_store_pair = .{16                    .rt = rt,17                    .rn = rn,18                    .rt2 = rt2,19                    .imm7 = offset,20                    .l = 0,21                    .op2 = .signed_offset,22                    .opc = @as(u2, @backingInt(gpr_size)) << 1,23                },24            },25        };26    }2728    pub fn stpBytes(rt: Encoded, rt2: Encoded, rn: Encoded, byte_offset: i32, gpr_size: GPRSize) Instruction {29        const scale: i32 = switch (gpr_size) {30            .w => 4,31            .x => 8,32        };33        return stp(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), gpr_size);34    }3536    pub fn stpPre(rt: Encoded, rt2: Encoded, rn: Encoded, offset: i7, gpr_size: GPRSize) Instruction {37        return .{38            .load_store = .{39                .load_store_pair = .{40                    .rt = rt,41                    .rn = rn,42                    .rt2 = rt2,43                    .imm7 = offset,44                    .l = 0,45                    .op2 = .pre_index,46                    .opc = @as(u2, @backingInt(gpr_size)) << 1,47                },48            },49        };50    }5152    pub fn stpPreBytes(rt: Encoded, rt2: Encoded, rn: Encoded, byte_offset: i32, gpr_size: GPRSize) Instruction {53        const scale: i32 = switch (gpr_size) {54            .w => 4,55            .x => 8,56        };57        return stpPre(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), gpr_size);58    }5960    pub fn ldp(rt: Encoded, rt2: Encoded, rn: Encoded, offset: i7, gpr_size: GPRSize) Instruction {61        return .{62            .load_store = .{63                .load_store_pair = .{64                    .rt = rt,65                    .rn = rn,66                    .rt2 = rt2,67                    .imm7 = offset,68                    .l = 1,69                    .op2 = .signed_offset,70                    .opc = @as(u2, @backingInt(gpr_size)) << 1,71                },72            },73        };74    }7576    pub fn ldpBytes(rt: Encoded, rt2: Encoded, rn: Encoded, byte_offset: i32, gpr_size: GPRSize) Instruction {77        const scale: i32 = switch (gpr_size) {78            .w => 4,79            .x => 8,80        };81        return ldp(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), gpr_size);82    }8384    pub fn ldpPost(rt: Encoded, rt2: Encoded, rn: Encoded, offset: i7, gpr_size: GPRSize) Instruction {85        return .{86            .load_store = .{87                .load_store_pair = .{88                    .rt = rt,89                    .rn = rn,90                    .rt2 = rt2,91                    .imm7 = offset,92                    .l = 1,93                    .op2 = .post_index,94                    .opc = @as(u2, @backingInt(gpr_size)) << 1,95                },96            },97        };98    }99100    pub fn ldpPostBytes(rt: Encoded, rt2: Encoded, rn: Encoded, byte_offset: i32, gpr_size: GPRSize) Instruction {101        const scale: i32 = switch (gpr_size) {102            .w => 4,103            .x => 8,104        };105        return ldpPost(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), gpr_size);106    }107};

1pub const LoadStorePairFP = packed struct(u32) {2    rt: Encoded,3    rn: Encoded,4    rt2: Encoded,5    imm7: i7,6    l: u1,7    op2: LoadStorePairMode,8    v: u1 = 1,9    fixed: u3 = 0b101,10    opc: LoadStorePairFPSize,1112    pub fn stp(13        rt: Encoded,14        rt2: Encoded,15        rn: Encoded,16        offset: i7,17        size: LoadStorePairFPSize,18    ) Instruction {19        return .{20            .load_store = .{21                .load_store_pair_fp = .{22                    .rt = rt,23                    .rn = rn,24                    .rt2 = rt2,25                    .imm7 = offset,26                    .l = 0,27                    .op2 = .signed_offset,28                    .opc = size,29                },30            },31        };32    }3334    pub fn stpBytes(35        rt: Encoded,36        rt2: Encoded,37        rn: Encoded,38        byte_offset: i32,39        size: LoadStorePairFPSize,40    ) Instruction {41        const scale: i32 = switch (size) {42            .single => 4,43            .double => 8,44            .quad => 16,45        };46        return stp(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), size);47    }4849    pub fn stpPre(50        rt: Encoded,51        rt2: Encoded,52        rn: Encoded,53        offset: i7,54        size: LoadStorePairFPSize,55    ) Instruction {56        return .{57            .load_store = .{58                .load_store_pair_fp = .{59                    .rt = rt,60                    .rn = rn,61                    .rt2 = rt2,62                    .imm7 = offset,63                    .l = 0,64                    .op2 = .pre_index,65                    .opc = size,66                },67            },68        };69    }7071    pub fn stpPreBytes(72        rt: Encoded,73        rt2: Encoded,74        rn: Encoded,75        byte_offset: i32,76        size: LoadStorePairFPSize,77    ) Instruction {78        const scale: i32 = switch (size) {79            .single => 4,80            .double => 8,81            .quad => 16,82        };83        return stpPre(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), size);84    }8586    pub fn ldp(87        rt: Encoded,88        rt2: Encoded,89        rn: Encoded,90        offset: i7,91        size: LoadStorePairFPSize,92    ) Instruction {93        return .{94            .load_store = .{95                .load_store_pair_fp = .{96                    .rt = rt,97                    .rn = rn,98                    .rt2 = rt2,99                    .imm7 = offset,100                    .l = 1,101                    .op2 = .signed_offset,102                    .opc = size,103                },104            },105        };106    }107108    pub fn ldpBytes(109        rt: Encoded,110        rt2: Encoded,111        rn: Encoded,112        byte_offset: i32,113        size: LoadStorePairFPSize,114    ) Instruction {115        const scale: i32 = switch (size) {116            .single => 4,117            .double => 8,118            .quad => 16,119        };120        return ldp(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), size);121    }122123    pub fn ldpPost(124        rt: Encoded,125        rt2: Encoded,126        rn: Encoded,127        offset: i7,128        size: LoadStorePairFPSize,129    ) Instruction {130        return .{131            .load_store = .{132                .load_store_pair_fp = .{133                    .rt = rt,134                    .rn = rn,135                    .rt2 = rt2,136                    .imm7 = offset,137                    .l = 1,138                    .op2 = .post_index,139                    .opc = size,140                },141            },142        };143    }144145    pub fn ldpPostBytes(146        rt: Encoded,147        rt2: Encoded,148        rn: Encoded,149        byte_offset: i32,150        size: LoadStorePairFPSize,151    ) Instruction {152        const scale: i32 = switch (size) {153            .single => 4,154            .double => 8,155            .quad => 16,156        };157        return ldpPost(rt, rt2, rn, scalePairOffsetBytes(byte_offset, scale), size);158    }159};

1pub const LoadStorePairFPSize = enum(u2) {2    single = 0b00,3    double = 0b01,4    quad = 0b10,5};

1pub const LoadStorePairMode = enum(u3) {2    post_index = 0b001,3    signed_offset = 0b010,4    pre_index = 0b011,5};

1pub const LoadStoreRegImm = packed struct(u32) {2    rt: Encoded,3    rn: Encoded,4    imm12: u12,5    opc: u2,6    fixed_01: u2 = 0b01,7    v: u1 = 0,8    fixed_111: u3 = 0b111,9    size: u2,1011    pub fn ldr(rt: Encoded, rn: Encoded, offset: u12, gpr_size: GPRSize) Instruction {12        return .{13            .load_store = .{14                .load_store_reg_imm = .{15                    .rt = rt,16                    .rn = rn,17                    .imm12 = offset,18                    .opc = 0b01,19                    .size = switch (gpr_size) {20                        .w => 0b10,21                        .x => 0b11,22                    },23                },24            },25        };26    }2728    pub fn str(rt: Encoded, rn: Encoded, offset: u12, gpr_size: GPRSize) Instruction {29        return .{30            .load_store = .{31                .load_store_reg_imm = .{32                    .rt = rt,33                    .rn = rn,34                    .imm12 = offset,35                    .opc = 0b00,36                    .size = switch (gpr_size) {37                        .w => 0b10,38                        .x => 0b11,39                    },40                },41            },42        };43    }44};

1pub const LoadStoreRegImmFP = packed struct(u32) {2    rt: Encoded,3    rn: Encoded,4    imm12: u12,5    opc: u2,6    fixed_01: u2 = 0b01,7    v: u1 = 1,8    fixed_111: u3 = 0b111,9    size: u2,1011    pub fn ldr(rt: Encoded, rn: Encoded, offset: u12, fp_size: LoadStoreFPSize) Instruction {12        return .{13            .load_store = .{14                .load_store_reg_imm_fp = .{15                    .rt = rt,16                    .rn = rn,17                    .imm12 = offset,18                    .opc = 0b01,19                    .size = @backingInt(fp_size),20                },21            },22        };23    }2425    pub fn str(rt: Encoded, rn: Encoded, offset: u12, fp_size: LoadStoreFPSize) Instruction {26        return .{27            .load_store = .{28                .load_store_reg_imm_fp = .{29                    .rt = rt,30                    .rn = rn,31                    .imm12 = offset,32                    .opc = 0b00,33                    .size = @backingInt(fp_size),34                },35            },36        };37    }38};

1pub const LogicalImmediate = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    imms: u6,5    immr: u6,6    n: u1,7    fixed: u6 = 0b100100,8    opc: LogicalOpcode,9    sf: u1,10};

1pub const LogicalOpcode = enum(u2) {2    @"and" = 0b00,3    orr = 0b01,4    eor = 0b10,5    ands = 0b11,6};

1pub const LogicalShift = enum(u2) {2    lsl = 0b00,3    lsr = 0b01,4    asr = 0b10,5    ror = 0b11,6};

1pub const LogicalShiftedRegister = packed struct(u32) {2    rd: Encoded,3    rn: Encoded,4    imm6: u6,5    rm: Encoded,6    n: u1,7    shift: LogicalShift,8    fixed: u5 = 0b01010,9    opc: LogicalOpcode,10    sf: u1,1112    pub fn andReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {13        return .{14            .data_processing_reg = .{15                .logical_shifted = .{16                    .rd = rd,17                    .rn = rn,18                    .imm6 = 0,19                    .rm = rm,20                    .n = 0,21                    .shift = .lsl,22                    .opc = .@"and",23                    .sf = @backingInt(size),24                },25            },26        };27    }2829    pub fn orrReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {30        return .{31            .data_processing_reg = .{32                .logical_shifted = .{33                    .rd = rd,34                    .rn = rn,35                    .imm6 = 0,36                    .rm = rm,37                    .n = 0,38                    .shift = .lsl,39                    .opc = .orr,40                    .sf = @backingInt(size),41                },42            },43        };44    }4546    pub fn eorReg(rd: Encoded, rn: Encoded, rm: Encoded, size: GPRSize) Instruction {47        return .{48            .data_processing_reg = .{49                .logical_shifted = .{50                    .rd = rd,51                    .rn = rn,52                    .imm6 = 0,53                    .rm = rm,54                    .n = 0,55                    .shift = .lsl,56                    .opc = .eor,57                    .sf = @backingInt(size),58                },59            },60        };61    }6263    pub fn movReg(rd: Encoded, rm: Encoded, size: GPRSize) Instruction {64        return orrReg(rd, registers.ZR.encoded, rm, size);65    }66};

1pub const MoveWide = packed struct(u32) {2    rd: Encoded,3    imm16: u16,4    hw: u2,5    fixed: u6 = 0b100101,6    opc: MoveWideOpcode,7    sf: u1,89    pub fn movz(rd: Encoded, imm: u16, shift: u2, size: GPRSize) Instruction {10        return .{11            .data_processing_imm = .{12                .move_wide = .{13                    .rd = rd,14                    .imm16 = imm,15                    .hw = shift,16                    .opc = .movz,17                    .sf = @backingInt(size),18                },19            },20        };21    }2223    pub fn movk(rd: Encoded, imm: u16, shift: u2, size: GPRSize) Instruction {24        return .{25            .data_processing_imm = .{26                .move_wide = .{27                    .rd = rd,28                    .imm16 = imm,29                    .hw = shift,30                    .opc = .movk,31                    .sf = @backingInt(size),32                },33            },34        };35    }3637    pub fn movn(rd: Encoded, imm: u16, shift: u2, size: GPRSize) Instruction {38        return .{39            .data_processing_imm = .{40                .move_wide = .{41                    .rd = rd,42                    .imm16 = imm,43                    .hw = shift,44                    .opc = .movn,45                    .sf = @backingInt(size),46                },47            },48        };49    }50};

1pub const MoveWideOpcode = enum(u2) {2    movn = 0b00,3    movz = 0b10,4    movk = 0b11,5};

1pub const UnconditionalBranchImm = packed struct(u32) {2    imm26: i26,3    fixed: u5 = 0b00101,4    op: u1,56    pub fn b(offset: i26) Instruction {7        return .{8            .branch = .{9                .unconditional_imm = .{10                    .imm26 = offset,11                    .op = 0,12                },13            },14        };15    }1617    pub fn bl(offset: i26) Instruction {18        return .{19            .branch = .{20                .unconditional_imm = .{21                    .imm26 = offset,22                    .op = 1,23                },24            },25        };26    }27};

1pub const UnconditionalBranchReg = packed struct(u32) {2    fixed0: u5 = 0b00000,3    rn: Encoded,4    fixed1: u6 = 0b000000,5    op2: u5,6    opc: u4,7    fixed2: u7 = 0b1101011,89    pub fn ret(rn: Encoded) Instruction {10        return .{11            .branch = .{12                .unconditional_reg = .{13                    .rn = rn,14                    .op2 = 0b11111,15                    .opc = 0b0010,16                },17            },18        };19    }2021    pub fn retLr() Instruction {22        return ret(GPR.lr.encode());23    }2425    pub fn br(rn: Encoded) Instruction {26        return .{27            .branch = .{28                .unconditional_reg = .{29                    .rn = rn,30                    .op2 = 0b11111,31                    .opc = 0b0000,32                },33            },34        };35    }3637    pub fn blr(rn: Encoded) Instruction {38        return .{39            .branch = .{40                .unconditional_reg = .{41                    .rn = rn,42                    .op2 = 0b11111,43                    .opc = 0b0001,44                },45            },46        };47    }48};