tiny.choir.dialects.aarch64.AArch64Dialect

1pub const AArch64Dialect = struct {2    pub const name = "aarch64";3    const op_specs = ir.dialects.opSpec.dialect(@This());4    pub const spec = ir.dialects.dialectSpec(@This(), .{5        .types = ir.dialects.typeNames(type_names),6    });78    pub const GetRegOp = struct {9        op: *ir.Operation,1011        pub const operation_spec = op_specs.define(.{12            .mnemonic = "get_reg",13            .required_attrs = &.{"reg"},14        });15        pub const operation_name = operation_spec.name;1617        pub fn createGPR(ctx: *ir.Context, loc: ir.Location, reg: GPR) !GetRegOp {18            var builder = ir.OperationBuilder.init(ctx);19            const gpr_type = try getGPRType(ctx);20            var state = op_specs.state(@This(), loc);21            state.addTypes(&.{gpr_type});2223            const op = try builder.create(state);24            try op.setAttr("reg", try getGPRAttr(ctx, reg));25            return .{ .op = op };26        }2728        pub fn createFPR(ctx: *ir.Context, loc: ir.Location, reg: FPR) !GetRegOp {29            var builder = ir.OperationBuilder.init(ctx);30            const fpr_type = try getFPRType(ctx);31            var state = op_specs.state(@This(), loc);32            state.addTypes(&.{fpr_type});3334            const op = try builder.create(state);35            try op.setAttr("reg", try getFPRAttr(ctx, reg));36            return .{ .op = op };37        }3839        pub fn getResult(self: *const GetRegOp) *ir.Value {40            return self.op.getResult(0).?;41        }4243        pub fn getGPR(self: GetRegOp) ?GPR {44            if (self.op.getAttr("reg")) |attr| {45                return getGPRValue(attr);46            }47            return null;48        }4950        pub fn getFPR(self: GetRegOp) ?FPR {51            if (self.op.getAttr("reg")) |attr| {52                return getFPRValue(attr);53            }54            return null;55        }56    };5758    pub const AddOp = struct {59        op: *ir.Operation,6061        pub const operation_spec = op_specs.define(.{62            .mnemonic = "add",63            .required_attrs = &.{"size"},64        });65        pub const operation_name = operation_spec.name;6667        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !AddOp {68            var builder = ir.OperationBuilder.init(ctx);69            const gpr_type = try getGPRType(ctx);70            var state = op_specs.state(@This(), loc);71            state.addOperands(&.{ lhs, rhs });72            state.addTypes(&.{gpr_type});7374            const op = try builder.create(state);75            try op.setAttr("size", try getGPRSizeAttr(ctx, size));76            return .{ .op = op };77        }7879        pub fn getResult(self: *const AddOp) *ir.Value {80            return self.op.getResult(0).?;81        }8283        pub fn getLhs(self: AddOp) *ir.Value {84            return self.op.operands.items[0].value;85        }8687        pub fn getRhs(self: AddOp) *ir.Value {88            return self.op.operands.items[1].value;89        }9091        pub fn getSize(self: AddOp) GPRSize {92            if (self.op.getAttr("size")) |attr| {93                return getGPRSizeValue(attr) orelse .x;94            }95            return .x;96        }97    };9899    pub const AddImmOp = struct {100        op: *ir.Operation,101102        pub const operation_spec = op_specs.define(.{103            .mnemonic = "add_imm",104            .required_attrs = &.{ "imm", "size" },105        });106        pub const operation_name = operation_spec.name;107108        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, imm: u12, size: GPRSize) !AddImmOp {109            var builder = ir.OperationBuilder.init(ctx);110            const gpr_type = try getGPRType(ctx);111            var state = op_specs.state(@This(), loc);112            state.addOperands(&.{src});113            state.addTypes(&.{gpr_type});114115            const op = try builder.create(state);116            try op.setAttr("imm", try getImm12Attr(ctx, imm));117            try op.setAttr("size", try getGPRSizeAttr(ctx, size));118            return .{ .op = op };119        }120121        pub fn getResult(self: *const AddImmOp) *ir.Value {122            return self.op.getResult(0).?;123        }124125        pub fn getSrc(self: AddImmOp) *ir.Value {126            return self.op.operands.items[0].value;127        }128129        pub fn getImm(self: AddImmOp) u12 {130            if (self.op.getAttr("imm")) |attr| {131                return getImm12Value(attr) orelse 0;132            }133            return 0;134        }135136        pub fn getSize(self: AddImmOp) GPRSize {137            if (self.op.getAttr("size")) |attr| {138                return getGPRSizeValue(attr) orelse .x;139            }140            return .x;141        }142    };143144    pub const SubOp = struct {145        op: *ir.Operation,146147        pub const operation_spec = op_specs.define(.{148            .mnemonic = "sub",149            .required_attrs = &.{"size"},150        });151        pub const operation_name = operation_spec.name;152153        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !SubOp {154            var builder = ir.OperationBuilder.init(ctx);155            const gpr_type = try getGPRType(ctx);156            var state = op_specs.state(@This(), loc);157            state.addOperands(&.{ lhs, rhs });158            state.addTypes(&.{gpr_type});159160            const op = try builder.create(state);161            try op.setAttr("size", try getGPRSizeAttr(ctx, size));162            return .{ .op = op };163        }164165        pub fn getResult(self: *const SubOp) *ir.Value {166            return self.op.getResult(0).?;167        }168169        pub fn getLhs(self: SubOp) *ir.Value {170            return self.op.operands.items[0].value;171        }172173        pub fn getRhs(self: SubOp) *ir.Value {174            return self.op.operands.items[1].value;175        }176177        pub fn getSize(self: SubOp) GPRSize {178            if (self.op.getAttr("size")) |attr| {179                return getGPRSizeValue(attr) orelse .x;180            }181            return .x;182        }183    };184185    pub const MulOp = struct {186        op: *ir.Operation,187188        pub const operation_spec = op_specs.define(.{189            .mnemonic = "mul",190            .required_attrs = &.{"size"},191        });192        pub const operation_name = operation_spec.name;193194        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !MulOp {195            var builder = ir.OperationBuilder.init(ctx);196            const gpr_type = try getGPRType(ctx);197            var state = op_specs.state(@This(), loc);198            state.addOperands(&.{ lhs, rhs });199            state.addTypes(&.{gpr_type});200201            const op = try builder.create(state);202            try op.setAttr("size", try getGPRSizeAttr(ctx, size));203            return .{ .op = op };204        }205206        pub fn getResult(self: *const MulOp) *ir.Value {207            return self.op.getResult(0).?;208        }209    };210211    pub const SDivOp = struct {212        op: *ir.Operation,213214        pub const operation_spec = op_specs.define(.{215            .mnemonic = "sdiv",216            .required_attrs = &.{"size"},217        });218        pub const operation_name = operation_spec.name;219220        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !SDivOp {221            var builder = ir.OperationBuilder.init(ctx);222            const gpr_type = try getGPRType(ctx);223            var state = op_specs.state(@This(), loc);224            state.addOperands(&.{ lhs, rhs });225            state.addTypes(&.{gpr_type});226227            const op = try builder.create(state);228            try op.setAttr("size", try getGPRSizeAttr(ctx, size));229            return .{ .op = op };230        }231232        pub fn getResult(self: *const SDivOp) *ir.Value {233            return self.op.getResult(0).?;234        }235    };236237    pub const UDivOp = struct {238        op: *ir.Operation,239240        pub const operation_spec = op_specs.define(.{241            .mnemonic = "udiv",242            .required_attrs = &.{"size"},243        });244        pub const operation_name = operation_spec.name;245246        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !UDivOp {247            var builder = ir.OperationBuilder.init(ctx);248            const gpr_type = try getGPRType(ctx);249            var state = op_specs.state(@This(), loc);250            state.addOperands(&.{ lhs, rhs });251            state.addTypes(&.{gpr_type});252253            const op = try builder.create(state);254            try op.setAttr("size", try getGPRSizeAttr(ctx, size));255            return .{ .op = op };256        }257258        pub fn getResult(self: *const UDivOp) *ir.Value {259            return self.op.getResult(0).?;260        }261    };262263    pub const CmpOp = struct {264        op: *ir.Operation,265266        pub const operation_spec = op_specs.define(.{267            .mnemonic = "cmp",268            .required_attrs = &.{"size"},269        });270        pub const operation_name = operation_spec.name;271272        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, size: GPRSize) !CmpOp {273            var builder = ir.OperationBuilder.init(ctx);274            var state = op_specs.state(@This(), loc);275            state.addOperands(&.{ lhs, rhs });276277            const op = try builder.create(state);278            try op.setAttr("size", try getGPRSizeAttr(ctx, size));279            return .{ .op = op };280        }281    };282283    pub const CSetOp = struct {284        op: *ir.Operation,285286        pub const operation_spec = op_specs.define(.{287            .mnemonic = "cset",288            .required_attrs = &.{ "cond", "size" },289        });290        pub const operation_name = operation_spec.name;291292        pub fn create(ctx: *ir.Context, loc: ir.Location, cond: Condition, size: GPRSize) !CSetOp {293            var builder = ir.OperationBuilder.init(ctx);294            const gpr_type = try getGPRType(ctx);295            var state = op_specs.state(@This(), loc);296            state.addTypes(&.{gpr_type});297298            const op = try builder.create(state);299            try op.setAttr("cond", try getConditionAttr(ctx, cond));300            try op.setAttr("size", try getGPRSizeAttr(ctx, size));301            return .{ .op = op };302        }303304        pub fn getResult(self: *const CSetOp) *ir.Value {305            return self.op.getResult(0).?;306        }307308        pub fn getCondition(self: CSetOp) Condition {309            if (self.op.getAttr("cond")) |attr| {310                return getConditionValue(attr) orelse .al;311            }312            return .al;313        }314    };315316    pub const CSelOp = struct {317        op: *ir.Operation,318319        pub const operation_spec = op_specs.define(.{320            .mnemonic = "csel",321            .required_attrs = &.{ "cond", "size" },322        });323        pub const operation_name = operation_spec.name;324325        pub fn create(ctx: *ir.Context, loc: ir.Location, rn: *ir.Value, rm: *ir.Value, cond: Condition, size: GPRSize) !CSelOp {326            var builder = ir.OperationBuilder.init(ctx);327            const gpr_type = try getGPRType(ctx);328            var state = op_specs.state(@This(), loc);329            state.addOperands(&.{ rn, rm });330            state.addTypes(&.{gpr_type});331332            const op = try builder.create(state);333            try op.setAttr("cond", try getConditionAttr(ctx, cond));334            try op.setAttr("size", try getGPRSizeAttr(ctx, size));335            return .{ .op = op };336        }337338        pub fn getResult(self: *const CSelOp) *ir.Value {339            return self.op.getResult(0).?;340        }341342        pub fn getRn(self: CSelOp) *ir.Value {343            return self.op.operands.items[0].value;344        }345346        pub fn getRm(self: CSelOp) *ir.Value {347            return self.op.operands.items[1].value;348        }349350        pub fn getCondition(self: CSelOp) Condition {351            if (self.op.getAttr("cond")) |attr| {352                return getConditionValue(attr) orelse .al;353            }354            return .al;355        }356    };357358    pub const FAddOp = struct {359        op: *ir.Operation,360361        pub const operation_spec = op_specs.define(.{362            .mnemonic = "fadd",363            .required_attrs = &.{"ftype"},364        });365        pub const operation_name = operation_spec.name;366367        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, ftype: encoding.FP2Source.FPType) !FAddOp {368            var builder = ir.OperationBuilder.init(ctx);369            const fpr_type = try getFPRType(ctx);370            var state = op_specs.state(@This(), loc);371            state.addOperands(&.{ lhs, rhs });372            state.addTypes(&.{fpr_type});373374            const op = try builder.create(state);375            const type_payload = [_]u8{@backingInt(ftype)};376            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));377            return .{ .op = op };378        }379380        pub fn getResult(self: *const FAddOp) *ir.Value {381            return self.op.getResult(0).?;382        }383    };384385    pub const FSubOp = struct {386        op: *ir.Operation,387388        pub const operation_spec = op_specs.define(.{389            .mnemonic = "fsub",390            .required_attrs = &.{"ftype"},391        });392        pub const operation_name = operation_spec.name;393394        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, ftype: encoding.FP2Source.FPType) !FSubOp {395            var builder = ir.OperationBuilder.init(ctx);396            const fpr_type = try getFPRType(ctx);397            var state = op_specs.state(@This(), loc);398            state.addOperands(&.{ lhs, rhs });399            state.addTypes(&.{fpr_type});400401            const op = try builder.create(state);402            const type_payload = [_]u8{@backingInt(ftype)};403            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));404            return .{ .op = op };405        }406407        pub fn getResult(self: *const FSubOp) *ir.Value {408            return self.op.getResult(0).?;409        }410    };411412    pub const FMulOp = struct {413        op: *ir.Operation,414415        pub const operation_spec = op_specs.define(.{416            .mnemonic = "fmul",417            .required_attrs = &.{"ftype"},418        });419        pub const operation_name = operation_spec.name;420421        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, ftype: encoding.FP2Source.FPType) !FMulOp {422            var builder = ir.OperationBuilder.init(ctx);423            const fpr_type = try getFPRType(ctx);424            var state = op_specs.state(@This(), loc);425            state.addOperands(&.{ lhs, rhs });426            state.addTypes(&.{fpr_type});427428            const op = try builder.create(state);429            const type_payload = [_]u8{@backingInt(ftype)};430            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));431            return .{ .op = op };432        }433434        pub fn getResult(self: *const FMulOp) *ir.Value {435            return self.op.getResult(0).?;436        }437    };438439    pub const FDivOp = struct {440        op: *ir.Operation,441442        pub const operation_spec = op_specs.define(.{443            .mnemonic = "fdiv",444            .required_attrs = &.{"ftype"},445        });446        pub const operation_name = operation_spec.name;447448        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, ftype: encoding.FP2Source.FPType) !FDivOp {449            var builder = ir.OperationBuilder.init(ctx);450            const fpr_type = try getFPRType(ctx);451            var state = op_specs.state(@This(), loc);452            state.addOperands(&.{ lhs, rhs });453            state.addTypes(&.{fpr_type});454455            const op = try builder.create(state);456            const type_payload = [_]u8{@backingInt(ftype)};457            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));458            return .{ .op = op };459        }460461        pub fn getResult(self: *const FDivOp) *ir.Value {462            return self.op.getResult(0).?;463        }464    };465466    pub const FCmpOp = struct {467        op: *ir.Operation,468469        pub const operation_spec = op_specs.define(.{470            .mnemonic = "fcmp",471            .required_attrs = &.{"ftype"},472        });473        pub const operation_name = operation_spec.name;474475        pub fn create(ctx: *ir.Context, loc: ir.Location, lhs: *ir.Value, rhs: *ir.Value, ftype: encoding.FP2Source.FPType) !FCmpOp {476            var builder = ir.OperationBuilder.init(ctx);477            var state = op_specs.state(@This(), loc);478            state.addOperands(&.{ lhs, rhs });479480            const op = try builder.create(state);481            const type_payload = [_]u8{@backingInt(ftype)};482            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));483            return .{ .op = op };484        }485    };486487    pub const FMovImmOp = struct {488        op: *ir.Operation,489490        pub const operation_spec = op_specs.define(.{491            .mnemonic = "fmov_imm",492            .required_attrs = &.{ "ftype", "imm8" },493        });494        pub const operation_name = operation_spec.name;495496        pub fn create(ctx: *ir.Context, loc: ir.Location, imm8: u8, ftype: encoding.FP2Source.FPType) !FMovImmOp {497            var builder = ir.OperationBuilder.init(ctx);498            const fpr_type = try getFPRType(ctx);499            var state = op_specs.state(@This(), loc);500            state.addTypes(&.{fpr_type});501502            const op = try builder.create(state);503            const imm_payload = [_]u8{imm8};504            try op.setAttr("imm8", try ctx.getDialectAttr(attr_names.imm8, &imm_payload));505            const type_payload = [_]u8{@backingInt(ftype)};506            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));507            return .{ .op = op };508        }509510        pub fn getResult(self: *const FMovImmOp) *ir.Value {511            return self.op.getResult(0).?;512        }513514        pub fn getImm8(self: *const FMovImmOp) u8 {515            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "imm8")) |dialect_attr| {516                if (dialect_attr.payload.len > 0) {517                    return dialect_attr.payload[0];518                }519            }520            return 0;521        }522    };523524    pub const FMovFromGPROp = struct {525        op: *ir.Operation,526527        pub const operation_spec = op_specs.define(.{528            .mnemonic = "fmov_gpr",529            .required_attrs = &.{"ftype"},530        });531        pub const operation_name = operation_spec.name;532533        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FMovFromGPROp {534            var builder = ir.OperationBuilder.init(ctx);535            const fpr_type = try getFPRType(ctx);536            var state = op_specs.state(@This(), loc);537            state.addOperands(&.{src});538            state.addTypes(&.{fpr_type});539540            const op = try builder.create(state);541            const type_payload = [_]u8{@backingInt(ftype)};542            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));543            return .{ .op = op };544        }545546        pub fn getResult(self: *const FMovFromGPROp) *ir.Value {547            return self.op.getResult(0).?;548        }549550        pub fn getSrc(self: *const FMovFromGPROp) *ir.Value {551            return self.op.getOperand(0).?;552        }553    };554555    pub const FMovFromFPROp = struct {556        op: *ir.Operation,557558        pub const operation_spec = op_specs.define(.{559            .mnemonic = "fmov_fpr",560            .required_attrs = &.{"ftype"},561        });562        pub const operation_name = operation_spec.name;563564        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FMovFromFPROp {565            var builder = ir.OperationBuilder.init(ctx);566            const gpr_type = try getGPRType(ctx);567            var state = op_specs.state(@This(), loc);568            state.addOperands(&.{src});569            state.addTypes(&.{gpr_type});570571            const op = try builder.create(state);572            const type_payload = [_]u8{@backingInt(ftype)};573            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));574            return .{ .op = op };575        }576577        pub fn getResult(self: *const FMovFromFPROp) *ir.Value {578            return self.op.getResult(0).?;579        }580581        pub fn getSrc(self: *const FMovFromFPROp) *ir.Value {582            return self.op.getOperand(0).?;583        }584    };585586    pub const FMovOp = struct {587        op: *ir.Operation,588589        pub const operation_spec = op_specs.define(.{590            .mnemonic = "fmov",591            .required_attrs = &.{"ftype"},592        });593        pub const operation_name = operation_spec.name;594595        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FMovOp {596            var builder = ir.OperationBuilder.init(ctx);597            const fpr_type = try getFPRType(ctx);598            var state = op_specs.state(@This(), loc);599            state.addOperands(&.{src});600            state.addTypes(&.{fpr_type});601602            const op = try builder.create(state);603            const type_payload = [_]u8{@backingInt(ftype)};604            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));605            return .{ .op = op };606        }607608        pub fn getResult(self: *const FMovOp) *ir.Value {609            return self.op.getResult(0).?;610        }611612        pub fn getSrc(self: *const FMovOp) *ir.Value {613            return self.op.getOperand(0).?;614        }615616        pub fn getFType(self: FMovOp) encoding.FP2Source.FPType {617            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "ftype")) |dialect_attr| {618                if (dialect_attr.payload.len > 0) {619                    return @fromBackingInt(@intCast(dialect_attr.payload[0]));620                }621            }622            return .single;623        }624    };625626    pub const FSqrtOp = struct {627        op: *ir.Operation,628629        pub const operation_spec = op_specs.define(.{630            .mnemonic = "fsqrt",631            .required_attrs = &.{"ftype"},632        });633        pub const operation_name = operation_spec.name;634635        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FSqrtOp {636            var builder = ir.OperationBuilder.init(ctx);637            const fpr_type = try getFPRType(ctx);638            var state = op_specs.state(@This(), loc);639            state.addOperands(&.{src});640            state.addTypes(&.{fpr_type});641642            const op = try builder.create(state);643            const type_payload = [_]u8{@backingInt(ftype)};644            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));645            return .{ .op = op };646        }647648        pub fn getResult(self: *const FSqrtOp) *ir.Value {649            return self.op.getResult(0).?;650        }651652        pub fn getSrc(self: *const FSqrtOp) *ir.Value {653            return self.op.getOperand(0).?;654        }655    };656657    pub const FNegOp = struct {658        op: *ir.Operation,659660        pub const operation_spec = op_specs.define(.{661            .mnemonic = "fneg",662            .required_attrs = &.{"ftype"},663        });664        pub const operation_name = operation_spec.name;665666        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FNegOp {667            var builder = ir.OperationBuilder.init(ctx);668            const fpr_type = try getFPRType(ctx);669            var state = op_specs.state(@This(), loc);670            state.addOperands(&.{src});671            state.addTypes(&.{fpr_type});672673            const op = try builder.create(state);674            const type_payload = [_]u8{@backingInt(ftype)};675            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));676            return .{ .op = op };677        }678679        pub fn getResult(self: *const FNegOp) *ir.Value {680            return self.op.getResult(0).?;681        }682683        pub fn getSrc(self: *const FNegOp) *ir.Value {684            return self.op.getOperand(0).?;685        }686    };687688    pub const FAbsOp = struct {689        op: *ir.Operation,690691        pub const operation_spec = op_specs.define(.{692            .mnemonic = "fabs",693            .required_attrs = &.{"ftype"},694        });695        pub const operation_name = operation_spec.name;696697        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, ftype: encoding.FP2Source.FPType) !FAbsOp {698            var builder = ir.OperationBuilder.init(ctx);699            const fpr_type = try getFPRType(ctx);700            var state = op_specs.state(@This(), loc);701            state.addOperands(&.{src});702            state.addTypes(&.{fpr_type});703704            const op = try builder.create(state);705            const type_payload = [_]u8{@backingInt(ftype)};706            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));707            return .{ .op = op };708        }709710        pub fn getResult(self: *const FAbsOp) *ir.Value {711            return self.op.getResult(0).?;712        }713714        pub fn getSrc(self: *const FAbsOp) *ir.Value {715            return self.op.getOperand(0).?;716        }717    };718719    pub const LdrOp = struct {720        op: *ir.Operation,721722        pub const operation_spec = op_specs.define(.{723            .mnemonic = "ldr",724            .required_attrs = &.{ "offset", "size" },725        });726        pub const operation_name = operation_spec.name;727728        pub fn create(ctx: *ir.Context, loc: ir.Location, base: *ir.Value, offset: u12, size: GPRSize) !LdrOp {729            var builder = ir.OperationBuilder.init(ctx);730            const gpr_type = try getGPRType(ctx);731            var state = op_specs.state(@This(), loc);732            state.addOperands(&.{base});733            state.addTypes(&.{gpr_type});734735            const op = try builder.create(state);736            try op.setAttr("offset", try getImm12Attr(ctx, offset));737            try op.setAttr("size", try getGPRSizeAttr(ctx, size));738            return .{ .op = op };739        }740741        pub fn getResult(self: *const LdrOp) *ir.Value {742            return self.op.getResult(0).?;743        }744745        pub fn getBase(self: LdrOp) *ir.Value {746            return self.op.operands.items[0].value;747        }748749        pub fn getOffset(self: LdrOp) u12 {750            if (self.op.getAttr("offset")) |attr| {751                return getImm12Value(attr) orelse 0;752            }753            return 0;754        }755    };756757    pub const StrOp = struct {758        op: *ir.Operation,759760        pub const operation_spec = op_specs.define(.{761            .mnemonic = "str",762            .required_attrs = &.{ "offset", "size" },763        });764        pub const operation_name = operation_spec.name;765766        pub fn create(ctx: *ir.Context, loc: ir.Location, value: *ir.Value, base: *ir.Value, offset: u12, size: GPRSize) !StrOp {767            var builder = ir.OperationBuilder.init(ctx);768            var state = op_specs.state(@This(), loc);769            state.addOperands(&.{ value, base });770771            const op = try builder.create(state);772            try op.setAttr("offset", try getImm12Attr(ctx, offset));773            try op.setAttr("size", try getGPRSizeAttr(ctx, size));774            return .{ .op = op };775        }776777        pub fn getValue(self: StrOp) *ir.Value {778            return self.op.operands.items[0].value;779        }780781        pub fn getBase(self: StrOp) *ir.Value {782            return self.op.operands.items[1].value;783        }784785        pub fn getOffset(self: StrOp) u12 {786            if (self.op.getAttr("offset")) |attr| {787                return getImm12Value(attr) orelse 0;788            }789            return 0;790        }791    };792793    pub const BOp = struct {794        op: *ir.Operation,795796        pub const operation_spec = op_specs.define(.{ .mnemonic = "b" });797        pub const operation_name = operation_spec.name;798799        pub fn create(ctx: *ir.Context, loc: ir.Location, target: *ir.Block) !BOp {800            var builder = ir.OperationBuilder.init(ctx);801            var state = op_specs.state(@This(), loc);802            state.addSuccessors(&.{target});803804            const op = try builder.create(state);805            return .{ .op = op };806        }807808        pub fn getTarget(self: BOp) *ir.Block {809            return self.op.getSuccessor(0).?;810        }811    };812813    pub const BCondOp = struct {814        op: *ir.Operation,815816        pub const operation_spec = op_specs.define(.{817            .mnemonic = "b_cond",818            .required_attrs = &.{"cond"},819        });820        pub const operation_name = operation_spec.name;821822        pub fn create(ctx: *ir.Context, loc: ir.Location, cond: Condition, true_target: *ir.Block, false_target: *ir.Block) !BCondOp {823            var builder = ir.OperationBuilder.init(ctx);824            var state = op_specs.state(@This(), loc);825            state.addSuccessors(&.{ true_target, false_target });826827            const op = try builder.create(state);828            try op.setAttr("cond", try getConditionAttr(ctx, cond));829            return .{ .op = op };830        }831832        pub fn getCondition(self: BCondOp) Condition {833            if (self.op.getAttr("cond")) |attr| {834                return getConditionValue(attr) orelse .al;835            }836            return .al;837        }838839        pub fn getTrueTarget(self: BCondOp) *ir.Block {840            return self.op.getSuccessor(0).?;841        }842843        pub fn getFalseTarget(self: BCondOp) *ir.Block {844            return self.op.getSuccessor(1).?;845        }846    };847848    pub const RetOp = struct {849        op: *ir.Operation,850851        pub const operation_spec = op_specs.define(.{ .mnemonic = "ret" });852        pub const operation_name = operation_spec.name;853854        pub fn create(ctx: *ir.Context, loc: ir.Location) !RetOp {855            var builder = ir.OperationBuilder.init(ctx);856            const state = op_specs.state(@This(), loc);857858            const op = try builder.create(state);859            return .{ .op = op };860        }861    };862863    pub const BlOp = struct {864        op: *ir.Operation,865866        pub const operation_spec = op_specs.define(.{867            .mnemonic = "bl",868            .required_attrs = &.{"callee"},869        });870        pub const operation_name = operation_spec.name;871872        pub fn create(ctx: *ir.Context, loc: ir.Location, callee: []const u8, args: []const *ir.Value, result_types: []const ir.Type) !BlOp {873            var builder = ir.OperationBuilder.init(ctx);874            var state = op_specs.state(@This(), loc);875            state.addOperands(args);876            state.addTypes(result_types);877878            const op = try builder.create(state);879            const name_attr = try ctx.getDialectAttr("choir.string", callee);880            try op.setAttr("callee", name_attr);881            return .{ .op = op };882        }883    };884885    pub const PrologueOp = struct {886        op: *ir.Operation,887888        pub const operation_spec = op_specs.define(.{889            .mnemonic = "prologue",890            .required_attrs = &.{"frame_size"},891        });892        pub const operation_name = operation_spec.name;893894        pub fn create(ctx: *ir.Context, loc: ir.Location, frame_size: i32) !PrologueOp {895            try loadSpec(ctx);896            var builder = ir.OperationBuilder.init(ctx);897            const state = op_specs.state(@This(), loc);898899            const op = try builder.create(state);900            try op.setAttr("frame_size", try getFrameOffsetAttr(ctx, frame_size));901            return .{ .op = op };902        }903904        pub fn getFrameSize(self: PrologueOp) i32 {905            if (self.op.getAttr("frame_size")) |attr| {906                return getFrameOffsetValue(attr) orelse 0;907            }908            return 0;909        }910    };911912    pub const EpilogueOp = struct {913        op: *ir.Operation,914915        pub const operation_spec = op_specs.define(.{916            .mnemonic = "epilogue",917            .required_attrs = &.{"frame_size"},918        });919        pub const operation_name = operation_spec.name;920921        pub fn create(ctx: *ir.Context, loc: ir.Location, frame_size: i32) !EpilogueOp {922            var builder = ir.OperationBuilder.init(ctx);923            const state = op_specs.state(@This(), loc);924925            const op = try builder.create(state);926            try op.setAttr("frame_size", try getFrameOffsetAttr(ctx, frame_size));927            return .{ .op = op };928        }929930        pub fn getFrameSize(self: EpilogueOp) i32 {931            if (self.op.getAttr("frame_size")) |attr| {932                return getFrameOffsetValue(attr) orelse 0;933            }934            return 0;935        }936    };937938    pub const MovOp = struct {939        op: *ir.Operation,940941        pub const operation_spec = op_specs.define(.{942            .mnemonic = "mov",943            .required_attrs = &.{"size"},944        });945        pub const operation_name = operation_spec.name;946947        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, size: GPRSize) !MovOp {948            var builder = ir.OperationBuilder.init(ctx);949            const gpr_type = try getGPRType(ctx);950            var state = op_specs.state(@This(), loc);951            state.addOperands(&.{src});952            state.addTypes(&.{gpr_type});953954            const op = try builder.create(state);955            try op.setAttr("size", try getGPRSizeAttr(ctx, size));956            return .{ .op = op };957        }958959        pub fn getResult(self: *const MovOp) *ir.Value {960            return self.op.getResult(0).?;961        }962963        pub fn getSrc(self: MovOp) *ir.Value {964            return self.op.operands.items[0].value;965        }966    };967968    pub const MovzOp = struct {969        op: *ir.Operation,970971        pub const operation_spec = op_specs.define(.{972            .mnemonic = "movz",973            .required_attrs = &.{ "imm", "shift", "size" },974        });975        pub const operation_name = operation_spec.name;976977        pub fn create(ctx: *ir.Context, loc: ir.Location, imm: u16, shift: u2, size: GPRSize) !MovzOp {978            var builder = ir.OperationBuilder.init(ctx);979            const gpr_type = try getGPRType(ctx);980            var state = op_specs.state(@This(), loc);981            state.addTypes(&.{gpr_type});982983            const op = try builder.create(state);984            var buf: [8]u8 = undefined;985            const imm_payload = try ir.format.intPayload(buf[0..], imm);986            try op.setAttr("imm", try ctx.getDialectAttr(attr_names.imm16, imm_payload));987            const shift_payload = [_]u8{shift};988            try op.setAttr("shift", try ctx.getDialectAttr("aarch64.shift", &shift_payload));989            try op.setAttr("size", try getGPRSizeAttr(ctx, size));990            return .{ .op = op };991        }992993        pub fn getResult(self: *const MovzOp) *ir.Value {994            return self.op.getResult(0).?;995        }996    };997998    pub const MovnOp = struct {999        op: *ir.Operation,10001001        pub const operation_spec = op_specs.define(.{1002            .mnemonic = "movn",1003            .required_attrs = &.{ "imm", "shift", "size" },1004        });1005        pub const operation_name = operation_spec.name;10061007        pub fn create(ctx: *ir.Context, loc: ir.Location, imm: u16, shift: u2, size: GPRSize) !MovnOp {1008            var builder = ir.OperationBuilder.init(ctx);1009            const gpr_type = try getGPRType(ctx);1010            var state = op_specs.state(@This(), loc);1011            state.addTypes(&.{gpr_type});10121013            const op = try builder.create(state);1014            var buf: [8]u8 = undefined;1015            const imm_payload = try ir.format.intPayload(buf[0..], imm);1016            try op.setAttr("imm", try ctx.getDialectAttr(attr_names.imm16, imm_payload));1017            const shift_payload = [_]u8{shift};1018            try op.setAttr("shift", try ctx.getDialectAttr("aarch64.shift", &shift_payload));1019            try op.setAttr("size", try getGPRSizeAttr(ctx, size));1020            return .{ .op = op };1021        }10221023        pub fn getResult(self: *const MovnOp) *ir.Value {1024            return self.op.getResult(0).?;1025        }1026    };10271028    pub const MovkOp = struct {1029        op: *ir.Operation,10301031        pub const operation_spec = op_specs.define(.{1032            .mnemonic = "movk",1033            .required_attrs = &.{ "imm", "shift", "size" },1034        });1035        pub const operation_name = operation_spec.name;10361037        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, imm: u16, shift: u2, size: GPRSize) !MovkOp {1038            var builder = ir.OperationBuilder.init(ctx);1039            const gpr_type = try getGPRType(ctx);1040            var state = op_specs.state(@This(), loc);1041            state.addOperands(&.{src});1042            state.addTypes(&.{gpr_type});10431044            const op = try builder.create(state);1045            var buf: [8]u8 = undefined;1046            const imm_payload = try ir.format.intPayload(buf[0..], imm);1047            try op.setAttr("imm", try ctx.getDialectAttr(attr_names.imm16, imm_payload));1048            const shift_payload = [_]u8{shift};1049            try op.setAttr("shift", try ctx.getDialectAttr("aarch64.shift", &shift_payload));1050            try op.setAttr("size", try getGPRSizeAttr(ctx, size));1051            return .{ .op = op };1052        }10531054        pub fn getResult(self: *const MovkOp) *ir.Value {1055            return self.op.getResult(0).?;1056        }10571058        pub fn getSrc(self: *const MovkOp) *ir.Value {1059            return self.op.getOperand(0).?;1060        }1061    };10621063    pub const CopyToRegOp = struct {1064        op: *ir.Operation,10651066        pub const operation_spec = op_specs.define(.{1067            .mnemonic = "copy_to_reg",1068            .required_attrs = &.{ "dest_reg", "size" },1069        });1070        pub const operation_name = operation_spec.name;10711072        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, dest_reg: u8, size: GPRSize) !CopyToRegOp {1073            var builder = ir.OperationBuilder.init(ctx);1074            const gpr_type = try getGPRType(ctx);1075            var state = op_specs.state(@This(), loc);1076            state.addOperands(&.{src});1077            state.addTypes(&.{gpr_type});10781079            const op = try builder.create(state);1080            const reg_payload = [_]u8{dest_reg};1081            try op.setAttr("dest_reg", try ctx.getDialectAttr("aarch64.reg_num", &reg_payload));1082            try op.setAttr("size", try getGPRSizeAttr(ctx, size));1083            return .{ .op = op };1084        }10851086        pub fn getResult(self: *const CopyToRegOp) *ir.Value {1087            return self.op.getResult(0).?;1088        }10891090        pub fn getSrc(self: CopyToRegOp) *ir.Value {1091            return self.op.operands.items[0].value;1092        }10931094        pub fn getDestReg(self: CopyToRegOp) u8 {1095            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "dest_reg")) |dialect_attr| {1096                if (dialect_attr.payload.len > 0) {1097                    return dialect_attr.payload[0];1098                }1099            }1100            return 0;1101        }11021103        pub fn getSize(self: CopyToRegOp) GPRSize {1104            if (self.op.getAttr("size")) |attr| {1105                return getGPRSizeValue(attr) orelse .x;1106            }1107            return .x;1108        }1109    };11101111    pub const CopyToSameRegAsOp = struct {1112        op: *ir.Operation,11131114        pub const operation_spec = op_specs.define(.{1115            .mnemonic = "copy_to_same_reg",1116            .required_attrs = &.{"size"},1117        });1118        pub const operation_name = operation_spec.name;11191120        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, target_ref: *ir.Value, size: GPRSize) !CopyToSameRegAsOp {1121            var builder = ir.OperationBuilder.init(ctx);1122            const gpr_type = try getGPRType(ctx);1123            var state = op_specs.state(@This(), loc);1124            state.addOperands(&.{ src, target_ref });1125            state.addTypes(&.{gpr_type});11261127            const op = try builder.create(state);1128            try op.setAttr("size", try getGPRSizeAttr(ctx, size));1129            return .{ .op = op };1130        }11311132        pub fn getResult(self: *const CopyToSameRegAsOp) *ir.Value {1133            return self.op.getResult(0).?;1134        }11351136        pub fn getSrc(self: CopyToSameRegAsOp) *ir.Value {1137            return self.op.operands.items[0].value;1138        }11391140        pub fn getTargetRef(self: CopyToSameRegAsOp) *ir.Value {1141            return self.op.operands.items[1].value;1142        }11431144        pub fn getSize(self: CopyToSameRegAsOp) GPRSize {1145            if (self.op.getAttr("size")) |attr| {1146                return getGPRSizeValue(attr) orelse .x;1147            }1148            return .x;1149        }1150    };11511152    pub const CopyToSameFPRegAsOp = struct {1153        op: *ir.Operation,11541155        pub const operation_spec = op_specs.define(.{1156            .mnemonic = "copy_to_same_fpreg",1157            .required_attrs = &.{"ftype"},1158        });1159        pub const operation_name = operation_spec.name;11601161        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, target_ref: *ir.Value, ftype: encoding.FP2Source.FPType) !CopyToSameFPRegAsOp {1162            var builder = ir.OperationBuilder.init(ctx);1163            const fpr_type = try getFPRType(ctx);1164            var state = op_specs.state(@This(), loc);1165            state.addOperands(&.{ src, target_ref });1166            state.addTypes(&.{fpr_type});11671168            const op = try builder.create(state);1169            const type_payload = [_]u8{@backingInt(ftype)};1170            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));1171            return .{ .op = op };1172        }11731174        pub fn getResult(self: *const CopyToSameFPRegAsOp) *ir.Value {1175            return self.op.getResult(0).?;1176        }11771178        pub fn getSrc(self: CopyToSameFPRegAsOp) *ir.Value {1179            return self.op.operands.items[0].value;1180        }11811182        pub fn getTargetRef(self: CopyToSameFPRegAsOp) *ir.Value {1183            return self.op.operands.items[1].value;1184        }11851186        pub fn getFType(self: CopyToSameFPRegAsOp) encoding.FP2Source.FPType {1187            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "ftype")) |dialect_attr| {1188                if (dialect_attr.payload.len > 0) {1189                    return @fromBackingInt(@intCast(dialect_attr.payload[0]));1190                }1191            }1192            return .single;1193        }1194    };11951196    pub const CopyToFPRegOp = struct {1197        op: *ir.Operation,11981199        pub const operation_spec = op_specs.define(.{1200            .mnemonic = "copy_to_fpreg",1201            .required_attrs = &.{ "dest_reg", "ftype" },1202        });1203        pub const operation_name = operation_spec.name;12041205        pub fn create(ctx: *ir.Context, loc: ir.Location, src: *ir.Value, dest_reg: u8, ftype: encoding.FP2Source.FPType) !CopyToFPRegOp {1206            var builder = ir.OperationBuilder.init(ctx);1207            const fpr_type = try getFPRType(ctx);1208            var state = op_specs.state(@This(), loc);1209            state.addOperands(&.{src});1210            state.addTypes(&.{fpr_type});12111212            const op = try builder.create(state);1213            const reg_payload = [_]u8{dest_reg};1214            try op.setAttr("dest_reg", try ctx.getDialectAttr("aarch64.fpreg_num", &reg_payload));1215            const type_payload = [_]u8{@backingInt(ftype)};1216            try op.setAttr("ftype", try ctx.getDialectAttr(attr_names.fp_type, &type_payload));1217            return .{ .op = op };1218        }12191220        pub fn getResult(self: *const CopyToFPRegOp) *ir.Value {1221            return self.op.getResult(0).?;1222        }12231224        pub fn getSrc(self: CopyToFPRegOp) *ir.Value {1225            return self.op.operands.items[0].value;1226        }12271228        pub fn getDestReg(self: CopyToFPRegOp) u8 {1229            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "dest_reg")) |dialect_attr| {1230                if (dialect_attr.payload.len > 0) {1231                    return dialect_attr.payload[0];1232                }1233            }1234            return 0;1235        }12361237        pub fn getFType(self: CopyToFPRegOp) encoding.FP2Source.FPType {1238            if (self.op.getAttrAs(ir.Attribute.DialectAttr, "ftype")) |dialect_attr| {1239                if (dialect_attr.payload.len > 0) {1240                    return @fromBackingInt(@intCast(dialect_attr.payload[0]));1241                }1242            }1243            return .single;1244        }1245    };12461247    fn loadSpec(ctx: *ir.Context) !void {1248        try ir.dialects.loadDialectSpec(ctx, spec);1249    }12501251    pub fn getGPRType(ctx: *ir.Context) !ir.Type {1252        try loadSpec(ctx);1253        return ctx.getDialectTypeFromName(type_names.gpr);1254    }12551256    pub fn getFPRType(ctx: *ir.Context) !ir.Type {1257        try loadSpec(ctx);1258        return ctx.getDialectTypeFromName(type_names.fpr);1259    }12601261    pub fn getGPRAttr(ctx: *ir.Context, reg: GPR) !ir.Attribute {1262        var buf: [4]u8 = undefined;1263        const payload = try ir.format.intPayload(buf[0..], @backingInt(reg));1264        return ctx.getDialectAttr(attr_names.gpr_reg, payload);1265    }12661267    pub fn getGPRValue(attr: ir.Attribute) ?GPR {1268        if (!std.mem.eql(u8, attr.abstract.name, attr_names.gpr_reg)) return null;1269        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1270        const val = std.fmt.parseInt(u5, dialect_attr.payload, 10) catch return null;1271        return @fromBackingInt(@intCast(val));1272    }12731274    pub fn getFPRAttr(ctx: *ir.Context, reg: FPR) !ir.Attribute {1275        var buf: [4]u8 = undefined;1276        const payload = try ir.format.intPayload(buf[0..], @backingInt(reg));1277        return ctx.getDialectAttr(attr_names.fpr_reg, payload);1278    }12791280    pub fn getFPRValue(attr: ir.Attribute) ?FPR {1281        if (!std.mem.eql(u8, attr.abstract.name, attr_names.fpr_reg)) return null;1282        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1283        const val = std.fmt.parseInt(u5, dialect_attr.payload, 10) catch return null;1284        return @fromBackingInt(@intCast(val));1285    }12861287    pub fn getImm12Attr(ctx: *ir.Context, value: u12) !ir.Attribute {1288        var buf: [8]u8 = undefined;1289        const payload = try ir.format.intPayload(buf[0..], value);1290        return ctx.getDialectAttr(attr_names.imm12, payload);1291    }12921293    pub fn getImm12Value(attr: ir.Attribute) ?u12 {1294        if (!std.mem.eql(u8, attr.abstract.name, attr_names.imm12)) return null;1295        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1296        return std.fmt.parseInt(u12, dialect_attr.payload, 10) catch null;1297    }12981299    pub fn getConditionAttr(ctx: *ir.Context, cond: Condition) !ir.Attribute {1300        var buf: [4]u8 = undefined;1301        const payload = try ir.format.intPayload(buf[0..], @backingInt(cond));1302        return ctx.getDialectAttr(attr_names.condition, payload);1303    }13041305    pub fn getConditionValue(attr: ir.Attribute) ?Condition {1306        if (!std.mem.eql(u8, attr.abstract.name, attr_names.condition)) return null;1307        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1308        const val = std.fmt.parseInt(u4, dialect_attr.payload, 10) catch return null;1309        return @fromBackingInt(@intCast(val));1310    }13111312    pub fn getGPRSizeAttr(ctx: *ir.Context, size: GPRSize) !ir.Attribute {1313        const payload = [_]u8{@backingInt(size)};1314        return ctx.getDialectAttr(attr_names.gpr_size, &payload);1315    }13161317    pub fn getGPRSizeValue(attr: ir.Attribute) ?GPRSize {1318        if (!std.mem.eql(u8, attr.abstract.name, attr_names.gpr_size)) return null;1319        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1320        if (dialect_attr.payload.len != 1) return null;1321        return @fromBackingInt(@intCast(dialect_attr.payload[0]));1322    }13231324    pub fn getFrameOffsetAttr(ctx: *ir.Context, offset: i32) !ir.Attribute {1325        var buf: [16]u8 = undefined;1326        const payload = try ir.format.intPayload(buf[0..], offset);1327        return ctx.getDialectAttr(attr_names.frame_offset, payload);1328    }13291330    pub fn getFrameOffsetValue(attr: ir.Attribute) ?i32 {1331        if (!std.mem.eql(u8, attr.abstract.name, attr_names.frame_offset)) return null;1332        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return null;1333        return std.fmt.parseInt(i32, dialect_attr.payload, 10) catch null;1334    }1335};