tiny.accy.choir.dialect.AccyDialect

1pub const AccyDialect = struct {2    pub const name = "accy";3    const op_templates = ir.dialects.operationTemplate.dialect(@This());4    const op_attr = ir.dialects.attribute;5    pub const spec = ir.dialects.dialectSpec(@This(), .{6        .types = &.{ir.dialects.typeName(tensor_type_name)},7    });89    pub const IotaOp = struct {10        op: *ir.Operation,1112        pub const leaf = op_templates.explicitLeaf(@This(), .{13            .mnemonic = "iota",14            .interfaces = &.{accyEffectsEntry()},15            .operands = 0,16            .results = .{"result"},1718            .required_attrs = .{op_attr.integer("iota_dimension")},19        });20        pub const operation_name = leaf.operation_name;21        pub const getResult = leaf.getResult;22        pub const verify = verifyAccyChoirOp;2324        pub fn create(25            ctx: *ir.Context,26            loc: ir.Location,27            result_type: ir.Type,28            iota_dimension: i64,29        ) !IotaOp {30            const self = try leaf.createLeaf(ctx, loc, &.{}, &.{result_type});31            errdefer self.op.erase();32            try leaf.setI64Attr(self, "iota_dimension", iota_dimension);33            return self;34        }35    };3637    pub const ConstantOp = struct {38        op: *ir.Operation,3940        pub const leaf = op_templates.explicitLeaf(@This(), .{41            .mnemonic = "constant",42            .interfaces = &.{accyEffectsEntry()},43            .operands = 0,44            .results = .{"result"},4546            .required_attrs = .{op_attr.dialect("payload", "accy.constant_payload")},47        });48        pub const operation_name = leaf.operation_name;49        pub const getResult = leaf.getResult;50        pub const verify = verifyAccyChoirOp;51        pub const payload_attr_name = leaf.dialectAttrName("payload");5253        pub fn create(54            ctx: *ir.Context,55            loc: ir.Location,56            payload: []const u8,57            result_type: ir.Type,58        ) !ConstantOp {59            const self = try leaf.createLeaf(ctx, loc, &.{}, &.{result_type});60            errdefer self.op.erase();61            try leaf.setDialectAttrPayload(self, "payload", payload);62            return self;63        }6465        pub fn getPayload(self: ConstantOp) ?[]const u8 {66            return leaf.getDialectAttrPayload(self, "payload");67        }68    };6970    pub const AddOp: type = op_templates.binarySameType("add", verifiedOptions());71    pub const SubOp: type = op_templates.binarySameType("sub", verifiedOptions());72    pub const MulOp: type = op_templates.binarySameType("mul", verifiedOptions());73    pub const DivOp: type = op_templates.binarySameType("div", verifiedOptions());74    pub const MaxOp: type = op_templates.binarySameType("max", verifiedOptions());75    pub const MinOp: type = op_templates.binarySameType("min", verifiedOptions());76    pub const NegOp: type = op_templates.unarySameType("neg", verifiedOptions());77    pub const ExpOp: type = op_templates.unarySameType("exp", verifiedOptions());78    pub const LogOp: type = op_templates.unarySameType("log", verifiedOptions());79    pub const TanhOp: type = op_templates.unarySameType("tanh", verifiedOptions());80    pub const SqrtOp: type = op_templates.unarySameType("sqrt", verifiedOptions());8182    pub const ActivationOp = struct {83        op: *ir.Operation,8485        pub const leaf = op_templates.explicitLeaf(@This(), .{86            .mnemonic = "activation",87            .operands = .{"input"},88            .results = .{"result"},8990            .required_attrs = .{op_attr.dialect("activation_kind", "accy.activation_kind")},91            .interfaces = &.{ ir.dialects.opSpec.verifier(verifyAccyChoirOp), accyEffectsEntry() },92        });93        pub const operation_name = leaf.operation_name;94        pub const getResult = leaf.getResult;95        pub const verify = verifyAccyChoirOp;96        pub const dialectAttrName = leaf.dialectAttrName;97        pub const activation_kind_attr_name = leaf.dialectAttrName("activation_kind");9899        pub fn create(100            ctx: *ir.Context,101            loc: ir.Location,102            input: *ir.Value,103            result_type: ir.Type,104            kind: semantics.ActivationKind,105        ) !ActivationOp {106            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});107            errdefer self.op.erase();108            try leaf.setDialectAttrPayload(self, "activation_kind", @tagName(kind));109            return self;110        }111112        pub fn getKind(self: ActivationOp) ?[]const u8 {113            return leaf.getDialectAttrPayload(self, "activation_kind");114        }115    };116117    pub const AbsOp: type = op_templates.unarySameType("abs", verifiedOptions());118    pub const SinOp: type = op_templates.unarySameType("sin", verifiedOptions());119    pub const CosOp: type = op_templates.unarySameType("cos", verifiedOptions());120    pub const TanOp: type = op_templates.unarySameType("tan", verifiedOptions());121    pub const FloorOp: type = op_templates.unarySameType("floor", verifiedOptions());122    pub const RoundOp: type = op_templates.unarySameType("round", verifiedOptions());123    pub const TruncOp: type = op_templates.unarySameType("trunc", verifiedOptions());124    pub const PowOp: type = op_templates.binarySameType("pow", verifiedOptions());125    pub const Atan2Op: type = op_templates.binarySameType("atan2", verifiedOptions());126127    pub const CompareOp = struct {128        op: *ir.Operation,129130        pub const leaf = op_templates.explicitLeaf(@This(), .{131            .mnemonic = "compare",132            .interfaces = &.{accyEffectsEntry()},133            .operands = .{ "lhs", "rhs" },134            .results = .{"result"},135136            .required_attrs = .{op_attr.dialect("compare_direction", "accy.compare_direction")},137        });138        pub const operation_name = leaf.operation_name;139        pub const getResult = leaf.getResult;140        pub const verify = verifyAccyChoirOp;141        pub const dialectAttrName = leaf.dialectAttrName;142143        pub fn create(144            ctx: *ir.Context,145            loc: ir.Location,146            lhs: *ir.Value,147            rhs: *ir.Value,148            result_type: ir.Type,149            direction: []const u8,150        ) !CompareOp {151            const self = try leaf.createLeaf(ctx, loc, &.{ lhs, rhs }, &.{result_type});152            errdefer self.op.erase();153            try leaf.setDialectAttrPayload(self, "compare_direction", direction);154            return self;155        }156    };157158    pub const ConvertOp = struct {159        op: *ir.Operation,160161        pub const leaf = op_templates.explicitLeaf(@This(), .{162            .mnemonic = "convert",163            .interfaces = &.{accyEffectsEntry()},164            .operands = .{"input"},165            .results = .{"result"},166167            .required_attrs = .{op_attr.dialect("convert_to", "accy.convert_to")},168        });169        pub const operation_name = leaf.operation_name;170        pub const getResult = leaf.getResult;171        pub const verify = verifyAccyChoirOp;172        pub const dialectAttrName = leaf.dialectAttrName;173174        pub fn create(175            ctx: *ir.Context,176            loc: ir.Location,177            input: *ir.Value,178            result_type: ir.Type,179            target_dtype: []const u8,180        ) !ConvertOp {181            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});182            errdefer self.op.erase();183            try leaf.setDialectAttrPayload(self, "convert_to", target_dtype);184            return self;185        }186    };187188    pub const SelectOp: type = op_templates.selectSameType("select", verifiedOptions());189190    pub const ReduceOp = struct {191        op: *ir.Operation,192193        pub const leaf = op_templates.explicitLeaf(@This(), .{194            .mnemonic = "reduce",195            .interfaces = &.{accyEffectsEntry()},196            .operands = .{ "operand", "init" },197            .results = .{"result"},198199            .required_attrs = .{200                op_attr.dialect("dimensions", "accy.reduce_dimensions"),201                op_attr.dialect("reducer_kind", "accy.reducer_kind"),202            },203        });204        pub const operation_name = leaf.operation_name;205        pub const getResult = leaf.getResult;206        pub const verify = verifyAccyChoirOp;207        pub const dialectAttrName = leaf.dialectAttrName;208209        pub fn create(210            ctx: *ir.Context,211            loc: ir.Location,212            operand: *ir.Value,213            init: *ir.Value,214            result_type: ir.Type,215            reducer_kind: []const u8,216            dimensions: []const i64,217        ) !ReduceOp {218            const self = try leaf.createLeaf(ctx, loc, &.{ operand, init }, &.{result_type});219            errdefer self.op.erase();220            try leaf.setDialectAttrPayload(self, "reducer_kind", reducer_kind);221            try leaf.setDialectAttrPayload(self, "dimensions", std.mem.sliceAsBytes(dimensions));222            return self;223        }224    };225226    pub const DotGeneralOp = struct {227        op: *ir.Operation,228229        pub const leaf = op_templates.explicitLeaf(@This(), .{230            .mnemonic = "dot_general",231            .interfaces = &.{accyEffectsEntry()},232            .operands = .{ "lhs", "rhs" },233            .results = .{"result"},234235            .required_attrs = .{236                op_attr.dialect("lhs_batch", "accy.dot_lhs_batch"),237                op_attr.dialect("lhs_contract", "accy.dot_lhs_contract"),238                op_attr.dialect("rhs_batch", "accy.dot_rhs_batch"),239                op_attr.dialect("rhs_contract", "accy.dot_rhs_contract"),240            },241        });242        pub const operation_name = leaf.operation_name;243        pub const getResult = leaf.getResult;244        pub const verify = verifyAccyChoirOp;245        pub const dialectAttrName = leaf.dialectAttrName;246247        pub fn create(248            ctx: *ir.Context,249            loc: ir.Location,250            lhs: *ir.Value,251            rhs: *ir.Value,252            result_type: ir.Type,253            lhs_batch: []const i64,254            rhs_batch: []const i64,255            lhs_contract: []const i64,256            rhs_contract: []const i64,257        ) !DotGeneralOp {258            const self = try leaf.createLeaf(ctx, loc, &.{ lhs, rhs }, &.{result_type});259            errdefer self.op.erase();260            try leaf.setDialectAttrPayload(self, "lhs_batch", std.mem.sliceAsBytes(lhs_batch));261            try leaf.setDialectAttrPayload(self, "rhs_batch", std.mem.sliceAsBytes(rhs_batch));262            try leaf.setDialectAttrPayload(self, "lhs_contract", std.mem.sliceAsBytes(lhs_contract));263            try leaf.setDialectAttrPayload(self, "rhs_contract", std.mem.sliceAsBytes(rhs_contract));264            return self;265        }266267        pub fn getLhsBatchPayload(self: DotGeneralOp) ?[]const u8 {268            return leaf.getDialectAttrPayload(self, "lhs_batch");269        }270271        pub fn getRhsBatchPayload(self: DotGeneralOp) ?[]const u8 {272            return leaf.getDialectAttrPayload(self, "rhs_batch");273        }274275        pub fn getLhsContractPayload(self: DotGeneralOp) ?[]const u8 {276            return leaf.getDialectAttrPayload(self, "lhs_contract");277        }278279        pub fn getRhsContractPayload(self: DotGeneralOp) ?[]const u8 {280            return leaf.getDialectAttrPayload(self, "rhs_contract");281        }282    };283284    pub const EinsumOp = struct {285        op: *ir.Operation,286287        pub const leaf = op_templates.explicitLeaf(@This(), .{288            .mnemonic = "einsum",289            .operands = ir.dialects.shape.atLeast(1),290            .results = .{"result"},291292            .required_attrs = .{op_attr.dialect("equation", "accy.einsum_equation")},293            .interfaces = &.{ ir.dialects.opSpec.verifier(verifyAccyChoirOp), accyEffectsEntry() },294        });295        pub const operation_name = leaf.operation_name;296        pub const getResult = leaf.getResult;297        pub const verify = verifyAccyChoirOp;298        pub const dialectAttrName = leaf.dialectAttrName;299        pub const equation_attr_name = leaf.dialectAttrName("equation");300301        pub fn create(302            ctx: *ir.Context,303            loc: ir.Location,304            operands: []const *ir.Value,305            result_type: ir.Type,306            equation: []const u8,307        ) !EinsumOp {308            const self = try leaf.createLeaf(ctx, loc, operands, &.{result_type});309            errdefer self.op.erase();310            try leaf.setDialectAttrPayload(self, "equation", equation);311            return self;312        }313314        pub fn getEquation(self: EinsumOp) ?[]const u8 {315            return leaf.getDialectAttrPayload(self, "equation");316        }317    };318319    pub const BroadcastOp = struct {320        op: *ir.Operation,321322        pub const leaf = op_templates.explicitLeaf(@This(), .{323            .mnemonic = "broadcast",324            .interfaces = &.{accyEffectsEntry()},325            .operands = .{"input"},326            .results = .{"result"},327328            .required_attrs = .{op_attr.dialect("sizes", "accy.broadcast_sizes")},329        });330        pub const operation_name = leaf.operation_name;331        pub const getResult = leaf.getResult;332        pub const verify = verifyAccyChoirOp;333        pub const dialectAttrName = leaf.dialectAttrName;334335        pub fn create(336            ctx: *ir.Context,337            loc: ir.Location,338            input: *ir.Value,339            result_type: ir.Type,340            sizes: []const i64,341        ) !BroadcastOp {342            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});343            errdefer self.op.erase();344            try leaf.setDialectAttrPayload(self, "sizes", std.mem.sliceAsBytes(sizes));345            return self;346        }347    };348349    pub const BroadcastInDimOp = struct {350        op: *ir.Operation,351352        pub const leaf = op_templates.explicitLeaf(@This(), .{353            .mnemonic = "broadcast_in_dim",354            .interfaces = &.{accyEffectsEntry()},355            .operands = .{"input"},356            .results = .{"result"},357358            .required_attrs = .{359                op_attr.dialect("broadcast_dims", "accy.broadcast_dims"),360                op_attr.dialect("result_shape", "accy.broadcast_result_shape"),361            },362        });363        pub const operation_name = leaf.operation_name;364        pub const getResult = leaf.getResult;365        pub const verify = verifyAccyChoirOp;366        pub const dialectAttrName = leaf.dialectAttrName;367368        pub fn create(369            ctx: *ir.Context,370            loc: ir.Location,371            input: *ir.Value,372            result_type: ir.Type,373            broadcast_dims: []const i64,374            result_shape: []const i64,375        ) !BroadcastInDimOp {376            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});377            errdefer self.op.erase();378            try leaf.setDialectAttrPayload(self, "broadcast_dims", std.mem.sliceAsBytes(broadcast_dims));379            try leaf.setDialectAttrPayload(self, "result_shape", std.mem.sliceAsBytes(result_shape));380            return self;381        }382    };383384    pub const ReshapeOp = struct {385        op: *ir.Operation,386387        pub const leaf = op_templates.explicitLeaf(@This(), .{388            .mnemonic = "reshape",389            .interfaces = &.{accyEffectsEntry()},390            .operands = .{"input"},391            .results = .{"result"},392393            .required_attrs = .{op_attr.dialect("new_shape", "accy.reshape_new_shape")},394        });395        pub const operation_name = leaf.operation_name;396        pub const getResult = leaf.getResult;397        pub const verify = verifyAccyChoirOp;398        pub const dialectAttrName = leaf.dialectAttrName;399400        pub fn create(401            ctx: *ir.Context,402            loc: ir.Location,403            input: *ir.Value,404            result_type: ir.Type,405            new_shape: []const i64,406        ) !ReshapeOp {407            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});408            errdefer self.op.erase();409            try leaf.setDialectAttrPayload(self, "new_shape", std.mem.sliceAsBytes(new_shape));410            return self;411        }412    };413414    pub const TransposeOp = struct {415        op: *ir.Operation,416417        pub const leaf = op_templates.explicitLeaf(@This(), .{418            .mnemonic = "transpose",419            .interfaces = &.{accyEffectsEntry()},420            .operands = .{"input"},421            .results = .{"result"},422423            .required_attrs = .{op_attr.dialect("permutation", "accy.transpose_permutation")},424        });425        pub const operation_name = leaf.operation_name;426        pub const getResult = leaf.getResult;427        pub const verify = verifyAccyChoirOp;428        pub const dialectAttrName = leaf.dialectAttrName;429430        pub fn create(431            ctx: *ir.Context,432            loc: ir.Location,433            input: *ir.Value,434            result_type: ir.Type,435            permutation: []const i64,436        ) !TransposeOp {437            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});438            errdefer self.op.erase();439            try leaf.setDialectAttrPayload(self, "permutation", std.mem.sliceAsBytes(permutation));440            return self;441        }442    };443444    pub const SliceOp = struct {445        op: *ir.Operation,446447        pub const leaf = op_templates.explicitLeaf(@This(), .{448            .mnemonic = "slice",449            .interfaces = &.{accyEffectsEntry()},450            .operands = .{"input"},451            .results = .{"result"},452453            .required_attrs = .{454                op_attr.dialect("limits", "accy.slice_limits"),455                op_attr.dialect("starts", "accy.slice_starts"),456                op_attr.dialect("strides", "accy.slice_strides"),457            },458        });459        pub const operation_name = leaf.operation_name;460        pub const getResult = leaf.getResult;461        pub const verify = verifyAccyChoirOp;462        pub const dialectAttrName = leaf.dialectAttrName;463464        pub fn create(465            ctx: *ir.Context,466            loc: ir.Location,467            input: *ir.Value,468            result_type: ir.Type,469            starts: []const i64,470            limits: []const i64,471            strides: []const i64,472        ) !SliceOp {473            const self = try leaf.createLeaf(ctx, loc, &.{input}, &.{result_type});474            errdefer self.op.erase();475            try leaf.setDialectAttrPayload(self, "starts", std.mem.sliceAsBytes(starts));476            try leaf.setDialectAttrPayload(self, "limits", std.mem.sliceAsBytes(limits));477            try leaf.setDialectAttrPayload(self, "strides", std.mem.sliceAsBytes(strides));478            return self;479        }480    };481482    pub const GatherOp = struct {483        op: *ir.Operation,484485        pub const leaf = op_templates.explicitLeaf(@This(), .{486            .mnemonic = "gather",487            .interfaces = &.{accyEffectsEntry()},488            .operands = .{ "input", "indices" },489            .results = .{"result"},490491            .required_attrs = .{op_attr.integer("axis")},492        });493        pub const operation_name = leaf.operation_name;494        pub const getResult = leaf.getResult;495        pub const verify = verifyAccyChoirOp;496497        pub fn create(498            ctx: *ir.Context,499            loc: ir.Location,500            input: *ir.Value,501            indices: *ir.Value,502            result_type: ir.Type,503            axis: i64,504        ) !GatherOp {505            const self = try leaf.createLeaf(ctx, loc, &.{ input, indices }, &.{result_type});506            errdefer self.op.erase();507            try leaf.setI64Attr(self, "axis", axis);508            return self;509        }510511        pub fn getAxis(self: GatherOp) ?i64 {512            const attr = self.op.getAttrAs(ir.Attribute.IntegerAttr, "axis") orelse return null;513            return attr.getValue();514        }515    };516517    pub const ScatterOp = struct {518        op: *ir.Operation,519520        pub const leaf = op_templates.explicitLeaf(@This(), .{521            .mnemonic = "scatter",522            .interfaces = &.{accyEffectsEntry()},523            .operands = .{ "input", "indices", "updates" },524            .results = .{"result"},525526            .required_attrs = .{op_attr.integer("axis")},527        });528        pub const operation_name = leaf.operation_name;529        pub const getResult = leaf.getResult;530        pub const verify = verifyAccyChoirOp;531532        pub fn create(533            ctx: *ir.Context,534            loc: ir.Location,535            input: *ir.Value,536            indices: *ir.Value,537            updates: *ir.Value,538            result_type: ir.Type,539            axis: i64,540        ) !ScatterOp {541            const self = try leaf.createLeaf(ctx, loc, &.{ input, indices, updates }, &.{result_type});542            errdefer self.op.erase();543            try leaf.setI64Attr(self, "axis", axis);544            return self;545        }546547        pub fn getAxis(self: ScatterOp) ?i64 {548            const attr = self.op.getAttrAs(ir.Attribute.IntegerAttr, "axis") orelse return null;549            return attr.getValue();550        }551    };552553    pub const ScatterAddOp = struct {554        op: *ir.Operation,555556        pub const leaf = op_templates.explicitLeaf(@This(), .{557            .mnemonic = "scatter_add",558            .interfaces = &.{accyEffectsEntry()},559            .operands = .{ "input", "indices", "updates" },560            .results = .{"result"},561562            .required_attrs = .{op_attr.integer("axis")},563        });564        pub const operation_name = leaf.operation_name;565        pub const getResult = leaf.getResult;566        pub const verify = verifyAccyChoirOp;567568        pub fn create(569            ctx: *ir.Context,570            loc: ir.Location,571            input: *ir.Value,572            indices: *ir.Value,573            updates: *ir.Value,574            result_type: ir.Type,575            axis: i64,576        ) !ScatterAddOp {577            const self = try leaf.createLeaf(ctx, loc, &.{ input, indices, updates }, &.{result_type});578            errdefer self.op.erase();579            try leaf.setI64Attr(self, "axis", axis);580            return self;581        }582583        pub fn getAxis(self: ScatterAddOp) ?i64 {584            const attr = self.op.getAttrAs(ir.Attribute.IntegerAttr, "axis") orelse return null;585            return attr.getValue();586        }587    };588589    pub const SparseCrossEntropyOp = struct {590        op: *ir.Operation,591592        pub const leaf = op_templates.explicitLeaf(@This(), .{593            .mnemonic = "sparse_cross_entropy",594            .interfaces = &.{accyEffectsEntry()},595            .operands = .{ "logits", "targets" },596            .results = .{"result"},597        });598        pub const operation_name = leaf.operation_name;599        pub const getResult = leaf.getResult;600        pub const verify = verifyAccyChoirOp;601602        pub fn create(603            ctx: *ir.Context,604            loc: ir.Location,605            logits: *ir.Value,606            targets: *ir.Value,607            result_type: ir.Type,608        ) !SparseCrossEntropyOp {609            return try leaf.createLeaf(ctx, loc, &.{ logits, targets }, &.{result_type});610        }611    };612613    pub const PadOp = struct {614        op: *ir.Operation,615616        pub const leaf = op_templates.explicitLeaf(@This(), .{617            .mnemonic = "pad",618            .interfaces = &.{accyEffectsEntry()},619            .operands = .{ "input", "padding_value" },620            .results = .{"result"},621622            .required_attrs = .{623                op_attr.dialect("edge_high", "accy.pad_edge_high"),624                op_attr.dialect("edge_low", "accy.pad_edge_low"),625                op_attr.dialect("interior", "accy.pad_interior"),626            },627        });628        pub const operation_name = leaf.operation_name;629        pub const getResult = leaf.getResult;630        pub const verify = verifyAccyChoirOp;631        pub const dialectAttrName = leaf.dialectAttrName;632633        pub fn create(634            ctx: *ir.Context,635            loc: ir.Location,636            input: *ir.Value,637            padding_value: *ir.Value,638            result_type: ir.Type,639            edge_low: []const i64,640            edge_high: []const i64,641            interior: []const i64,642        ) !PadOp {643            const self = try leaf.createLeaf(ctx, loc, &.{ input, padding_value }, &.{result_type});644            errdefer self.op.erase();645            try leaf.setDialectAttrPayload(self, "edge_low", std.mem.sliceAsBytes(edge_low));646            try leaf.setDialectAttrPayload(self, "edge_high", std.mem.sliceAsBytes(edge_high));647            try leaf.setDialectAttrPayload(self, "interior", std.mem.sliceAsBytes(interior));648            return self;649        }650    };651652    pub const ConcatenateOp = struct {653        op: *ir.Operation,654655        pub const leaf = op_templates.explicitLeaf(@This(), .{656            .mnemonic = "concatenate",657            .interfaces = &.{accyEffectsEntry()},658            .operands = ir.dialects.shape.atLeast(1),659            .results = .{"result"},660661            .required_attrs = .{op_attr.integer("dimension")},662        });663        pub const operation_name = leaf.operation_name;664        pub const getResult = leaf.getResult;665        pub const verify = verifyAccyChoirOp;666667        pub fn create(668            ctx: *ir.Context,669            loc: ir.Location,670            operands: []const *ir.Value,671            result_type: ir.Type,672            dimension: i64,673        ) !ConcatenateOp {674            const self = try leaf.createLeaf(ctx, loc, operands, &.{result_type});675            errdefer self.op.erase();676            try leaf.setI64Attr(self, "dimension", dimension);677            return self;678        }679    };680681    pub const KernelCallOp = struct {682        op: *ir.Operation,683684        pub const leaf = op_templates.explicitLeaf(@This(), .{685            .mnemonic = "kernel_call",686            .results = ir.dialects.shape.atLeast(1),687            .required_attrs = .{688                op_attr.dialect("target", "accy.kernel_call_target"),689                op_attr.integer("version"),690                op_attr.boolean("has_side_effects"),691                op_attr.dialect("operand_effects", "accy.kernel_call_operand_effects"),692                op_attr.dialect("result_aliases", "accy.kernel_call_result_aliases"),693            },694            .interfaces = &.{695                ir.dialects.opSpec.verifier(verifyAccyChoirOp),696                effect_facts.EffectOpInterface.entryFor(.{697                    .capacity = .{ .entries = 2, .per_operand = 2, .per_result = 1 },698                    .enumerate = kernelCallEffects,699                }),700            },701        });702        pub const operation_name = leaf.operation_name;703        pub const verify = verifyAccyChoirOp;704        pub const target_attr_name = leaf.dialectAttrName("target");705        pub const operand_effects_attr_name = leaf.dialectAttrName("operand_effects");706        pub const result_aliases_attr_name = leaf.dialectAttrName("result_aliases");707        pub const runtime_scalars_attr_name = "accy.kernel_call_runtime_scalars";708        pub const dialectAttrName = leaf.dialectAttrName;709710        pub fn create(711            ctx: *ir.Context,712            loc: ir.Location,713            operands: []const *ir.Value,714            result_types: []const ir.Type,715            target: []const u8,716            version: u32,717            has_side_effects: bool,718            operand_effects: []const semantics.KernelOperandEffect,719            result_aliases: []const ?usize,720        ) !KernelCallOp {721            const kernel_call = try leaf.createLeaf(ctx, loc, operands, result_types);722            errdefer kernel_call.op.erase();723            try leaf.setDialectAttrPayload(kernel_call, "target", target);724            try leaf.setI64Attr(kernel_call, "version", @intCast(version));725            try leaf.setBoolAttr(kernel_call, "has_side_effects", has_side_effects);726            try leaf.setDialectAttrPayload(kernel_call, "operand_effects", std.mem.sliceAsBytes(operand_effects));727            try setKernelCallResultAliasesAttr(ctx, kernel_call.op, result_aliases);728            return kernel_call;729        }730731        pub fn getResult(self: KernelCallOp, index: usize) ?*ir.Value {732            return self.op.getResult(index);733        }734735        pub fn getFirstResult(self: KernelCallOp) *ir.Value {736            return self.op.getResult(0).?;737        }738    };739740    pub const KernelCallScalarKind = enum(u64) {741        i32,742        u32,743        i64,744        u64,745        f32,746        f64,747    };748749    pub const KernelCallScalar = extern struct {750        kind: KernelCallScalarKind,751        bits: u64,752    };753754    pub const max_kernel_call_runtime_scalars = 16;755756    pub const KernelCallRuntimeScalars = struct {757        count: usize = 0,758        items: [max_kernel_call_runtime_scalars]KernelCallScalar = undefined,759760        pub fn slice(self: *const KernelCallRuntimeScalars) []const KernelCallScalar {761            return self.items[0..self.count];762        }763    };764765    pub const ScratchOp = struct {766        op: *ir.Operation,767768        pub const leaf = op_templates.explicitLeaf(@This(), .{769            .mnemonic = "scratch",770            .interfaces = &.{accyEffectsEntry()},771            .results = .{"result"},772            .required_attrs = .{op_attr.integer("words")},773        });774        pub const operation_name = leaf.operation_name;775        pub const getResult = leaf.getResult;776        pub const verify = verifyAccyChoirOp;777778        pub fn create(779            ctx: *ir.Context,780            loc: ir.Location,781            result_type: ir.Type,782            words: i64,783        ) !ScratchOp {784            const self = try leaf.createLeaf(ctx, loc, &.{}, &.{result_type});785            errdefer self.op.erase();786            try leaf.setI64Attr(self, "words", words);787            return self;788        }789    };790791    pub const CumsumOp = struct {792        op: *ir.Operation,793794        pub const leaf = op_templates.explicitLeaf(@This(), .{795            .mnemonic = "cumsum",796            .interfaces = &.{accyEffectsEntry()},797            .operands = ir.dialects.shape.between(1, 2),798            .results = .{"result"},799800            .required_attrs = .{op_attr.integer("axis")},801        });802        pub const operation_name = leaf.operation_name;803        pub const getResult = leaf.getResult;804        pub const verify = verifyAccyChoirOp;805806        pub fn create(807            ctx: *ir.Context,808            loc: ir.Location,809            operand: *ir.Value,810            result_type: ir.Type,811            axis: i64,812        ) !CumsumOp {813            const self = try leaf.createLeaf(ctx, loc, &.{operand}, &.{result_type});814            errdefer self.op.erase();815            try leaf.setI64Attr(self, "axis", axis);816            return self;817        }818819        pub fn createWithScratch(820            ctx: *ir.Context,821            loc: ir.Location,822            operand: *ir.Value,823            scratch: *ir.Value,824            result_type: ir.Type,825            axis: i64,826        ) !CumsumOp {827            const self = try leaf.createLeaf(ctx, loc, &.{ operand, scratch }, &.{result_type});828            errdefer self.op.erase();829            try leaf.setI64Attr(self, "axis", axis);830            return self;831        }832    };833834    pub const IterateOp = struct {835        op: *ir.Operation,836837        pub const template = op_templates.explicit(@This(), .{838            .mnemonic = "iterate",839            .interfaces = &.{accyEffectsEntry()},840            .operands = ir.dialects.shape.atLeast(1),841            .results = ir.dialects.shape.atLeast(1),842            .regions = ir.dialects.shape.exactly(1),843            .region_names = .{"body"},844845            .required_attrs = .{op_attr.integer("max_iters")},846        });847        pub const operation_name = template.operation_name;848        pub const verify = verifyAccyChoirOp;849        pub const getRegion = template.getRegion;850851        pub fn create(852            ctx: *ir.Context,853            loc: ir.Location,854            carries: []const *ir.Value,855            max_iters: i64,856        ) !IterateOp {857            var body = ir.context.initRegion(ctx);858            defer body.deinit();859            var body_builder = ir.OperationBuilder.init(ctx);860            var carry_types_buffer: [8]ir.Type = undefined;861            if (carries.len > carry_types_buffer.len) return error.OutOfMemory;862            for (carries, 0..) |carry, index| {863                carry_types_buffer[index] = carry.type;864            }865            _ = try body_builder.createBlockWithLoc(&body, carry_types_buffer[0..carries.len], loc);866            var regions = [_]*ir.Region{&body};867            const self = try template.createOperation(ctx, loc, carries, carry_types_buffer[0..carries.len], &regions, &.{});868            errdefer self.op.erase();869            try template.setI64Attr(self, "max_iters", max_iters);870            return self;871        }872873        pub fn bodyBlock(self: IterateOp) ?*ir.Block {874            const region = self.op.getRegion(0) orelse return null;875            return region.getEntryBlock();876        }877878        pub fn getMaxIters(self: IterateOp) ?i64 {879            return template.getI64Attr(self, "max_iters");880        }881882        pub fn getResult(self: IterateOp, index: usize) ?*ir.Value {883            return self.op.getResult(index);884        }885    };886887    pub const IterateYieldOp = struct {888        op: *ir.Operation,889890        pub const term = op_templates.explicitTerminator(@This(), .{891            .mnemonic = "iterate_yield",892            .interfaces = &.{accyEffectsEntry()},893        });894        pub const operation_name = term.operation_name;895        pub const verify = verifyAccyChoirOp;896897        pub fn create(898            ctx: *ir.Context,899            loc: ir.Location,900            predicate: *ir.Value,901            carries: []const *ir.Value,902        ) !IterateYieldOp {903            var operands_buffer: [9]*ir.Value = undefined;904            if (carries.len + 1 > operands_buffer.len) return error.OutOfMemory;905            operands_buffer[0] = predicate;906            for (carries, 0..) |carry, index| {907                operands_buffer[index + 1] = carry;908            }909            return try term.createTerminator(ctx, loc, operands_buffer[0 .. carries.len + 1], &.{});910        }911    };912913    pub const ReturnOp = struct {914        op: *ir.Operation,915916        pub const term = op_templates.explicitTerminator(@This(), .{917            .mnemonic = "return",918        });919        pub const operation_name = term.operation_name;920        pub const verify = verifyAccyChoirOp;921922        pub fn create(923            ctx: *ir.Context,924            loc: ir.Location,925            operands: []const *ir.Value,926        ) !ReturnOp {927            return try term.createTerminator(ctx, loc, operands, &.{});928        }929    };930931    fn verifiedOptions() ir.dialects.opSpec.Options {932        return .{933            .interfaces = &.{ ir.dialects.opSpec.verifier(verifyAccyChoirOp), accyEffectsEntry() },934        };935    }936937    pub fn setKernelCallRuntimeScalars(938        ctx: *ir.Context,939        op: *ir.Operation,940        scalars: []const KernelCallScalar,941    ) !void {942        if (scalars.len > max_kernel_call_runtime_scalars) return error.InvalidKernelCallContract;943        try op.setAttr(944            "runtime_scalars",945            try ctx.getDialectAttr(KernelCallOp.runtime_scalars_attr_name, std.mem.sliceAsBytes(scalars)),946        );947    }948949    pub fn kernelCallRuntimeScalars(op: *const ir.Operation) !?KernelCallRuntimeScalars {950        const attr = op.getAttr("runtime_scalars") orelse return null;951        if (!std.mem.eql(u8, attr.abstract.name, KernelCallOp.runtime_scalars_attr_name)) {952            return error.InvalidKernelCallContract;953        }954        const dialect_attr = attr.cast(ir.Attribute.DialectAttr) orelse return error.InvalidKernelCallContract;955        const payload = dialect_attr.payload;956        const record_size = @sizeOf(KernelCallScalar);957        if (payload.len % record_size != 0) return error.InvalidKernelCallContract;958        const count = payload.len / record_size;959        if (count > max_kernel_call_runtime_scalars) return error.InvalidKernelCallContract;960961        var decoded = KernelCallRuntimeScalars{ .count = count };962        for (0..count) |index| {963            const record = payload[index * record_size ..][0..record_size];964            const kind_bits = std.mem.readInt(u64, record[0..8], native_endian);965            const kind = std.enums.fromInt(KernelCallScalarKind, kind_bits) orelse {966                return error.InvalidKernelCallContract;967            };968            decoded.items[index] = .{969                .kind = kind,970                .bits = std.mem.readInt(u64, record[8..16], native_endian),971            };972        }973        return decoded;974    }975};