tiny.choir.dialects.memref.MemrefDialect

1pub const MemrefDialect = struct {2    pub const name = "memref";3    const op_specs = ir.dialects.opSpec.dialect(@This());4    const op_templates = ir.dialects.operationTemplate.dialect(@This());5    pub const spec = ir.dialects.dialectSpec(@This(), .{6        .types = &.{ir.dialects.typeName(name)},7        .type_interface_fallbacks = &.{8            .{ .id = interfaces.TypeParamInterface.id, .fallback = typeParamFallback },9            .{ .id = interfaces.ShapedTypeInterface.id, .fallback = shapedTypeFallback },10        },11    });1213    pub const MemrefTypePayload = struct {14        size: ?u64,15        element_type_name: []const u8,16        element_type: ?ir.Type,17        addr_space: AddressSpace,18        alignment: ?u64,19        exclusive: ?bool,20        indexing: ?Indexing,21        shape_storage: [1]u64 = [_]u64{0},22        shape: ?[]const u64 = null,23    };2425    const type_param_vtable = interfaces.TypeParamInterface.VTable{26        .parse = parseTypeParams,27    };2829    const shaped_type_vtable = interfaces.ShapedTypeInterface.VTable{30        .getRank = shapedGetRank,31        .getShape = shapedGetShape,32        .getElementType = shapedGetElementType,33        .getAddressSpaceTag = shapedGetAddressSpaceTag,34    };3536    pub const MemrefTypeAttrs = struct {37        alignment: ?u64 = null,38        exclusive: ?bool = null,39        indexing: ?Indexing = null,40    };4142    pub const MemrefParams = struct {43        size: ?u64,44        element_type_name: []const u8,45        addr_space: AddressSpace,46        alignment: ?u64 = null,47        exclusive: ?bool = null,48        indexing: ?Indexing = null,49    };5051    pub const LayoutAttrs = struct {52        offset: ?u64 = null,53        shape: ?[]const u64 = null,54        stride: ?[]const u64 = null,55    };5657    pub const AllocOp = struct {58        op: *ir.Operation,5960        const leaf = op_templates.explicitLeaf(@This(), .{61            .mnemonic = "alloc",62            .interfaces = &.{allocationEffects("heap")},63            .operands = ir.dialects.shape.atMost(1),64            .operand_names = .{"dynamic_size"},65            .results = .{"memref"},66        });67        pub const operation_spec = leaf.operation_spec;68        pub const operation_name = leaf.operation_name;69        pub const createLeaf = leaf.createLeaf;70        pub const getOptionalOperand = leaf.getOptionalOperand;7172        pub fn createStatic(73            ctx: *ir.Context,74            loc: ir.Location,75            result_type: ir.Type,76        ) !AllocOp {77            return @This().createLeaf(ctx, loc, &.{}, &.{result_type});78        }7980        pub fn createDynamic(81            ctx: *ir.Context,82            loc: ir.Location,83            size: *ir.Value,84            result_type: ir.Type,85        ) !AllocOp {86            return @This().createLeaf(ctx, loc, &.{size}, &.{result_type});87        }8889        pub fn getResult(self: *const AllocOp) *ir.Value {90            return leaf.getResult(self.*);91        }9293        pub fn getDynamicSize(self: AllocOp) ?*ir.Value {94            return self.getOptionalOperand("dynamic_size");95        }96    };9798    /// Allocates per-invocation storage. Its contents are undefined until stored;99    /// loading an element before storing it has no defined result on any backend.100    /// The CPU twin maps a local alloca to host stack storage without zeroing it.101    pub const AllocaOp = struct {102        op: *ir.Operation,103104        const leaf = op_templates.explicitLeaf(@This(), .{105            .mnemonic = "alloca",106            .interfaces = &.{allocationEffects("stack")},107            .operands = ir.dialects.shape.atMost(1),108            .operand_names = .{"dynamic_size"},109            .results = .{"memref"},110        });111        pub const operation_spec = leaf.operation_spec;112        pub const operation_name = leaf.operation_name;113        pub const createLeaf = leaf.createLeaf;114        pub const getOptionalOperand = leaf.getOptionalOperand;115116        pub fn createStatic(117            ctx: *ir.Context,118            loc: ir.Location,119            result_type: ir.Type,120        ) !AllocaOp {121            return @This().createLeaf(ctx, loc, &.{}, &.{result_type});122        }123124        pub fn createDynamic(125            ctx: *ir.Context,126            loc: ir.Location,127            size: *ir.Value,128            result_type: ir.Type,129        ) !AllocaOp {130            return @This().createLeaf(ctx, loc, &.{size}, &.{result_type});131        }132133        pub fn getResult(self: *const AllocaOp) *ir.Value {134            return leaf.getResult(self.*);135        }136137        pub fn getDynamicSize(self: AllocaOp) ?*ir.Value {138            return self.getOptionalOperand("dynamic_size");139        }140    };141142    /// A module level declaration of storage that code addresses by name.143    ///144    /// The placement follows from two attributes rather than being spelled a third time.145    /// `constant` with `initial` bytes is storage nothing writes, `initial` bytes without146    /// `constant` is storage code may write, and neither is an extent the loader fills with147    /// zeroes and the image carries no bytes for. `constant` with nothing to be constant about148    /// is refused, because the only thing it could mean is a read only run of zeroes that no149    /// one can ever have written.150    ///151    /// The type travels as a one element type list because the builtin attributes carry a list152    /// of types and not a single one, and this operation has no result to carry it on.153    pub const GlobalOp = struct {154        op: *ir.Operation,155156        pub const attr_names = struct {157            pub const sym_name = "sym_name";158            pub const memref_type = "type";159            pub const alignment = "alignment";160            pub const constant = "constant";161            pub const initial = "initial";162        };163164        const leaf = op_templates.explicitLeaf(@This(), .{165            .mnemonic = "global",166            .operands = 0,167            .results = 0,168            .required_attrs = .{169                ir.dialects.attribute.string(attr_names.sym_name),170                ir.dialects.attribute.any(attr_names.memref_type),171                ir.dialects.attribute.integer(attr_names.alignment),172                ir.dialects.attribute.boolean(attr_names.constant),173            },174            .attrs = .{ir.dialects.attribute.string(attr_names.initial)},175            .interfaces = &.{effects.EffectOpInterface.entryFor(.{ .complete = true })},176        });177        pub const operation_spec = leaf.operation_spec;178        pub const operation_name = leaf.operation_name;179        pub const createLeaf = leaf.createLeaf;180        pub const verify = verifyGlobalOp;181182        pub const Declaration = struct {183            sym_name: []const u8,184            memref_type: ir.Type,185            alignment: u64 = 1,186            constant: bool = false,187            /// Bytes the image carries. Absent declares an extent of zeroes instead.188            initial: ?[]const u8 = null,189        };190191        pub fn create(192            ctx: *ir.Context,193            loc: ir.Location,194            declaration: Declaration,195        ) !GlobalOp {196            try loadSpec(ctx);197            if (declaration.alignment > std.math.maxInt(i64)) {198                return MemrefVerifyError.GlobalInvalidAlignment;199            }200            const self = try @This().createLeaf(ctx, loc, &.{}, &.{});201            errdefer self.op.erase();202            const names = attr_names;203            try self.op.setAttr(names.sym_name, try ctx.getStringAttr(declaration.sym_name));204            try self.op.setAttr(205                names.memref_type,206                try ctx.getTypeListAttr(&.{declaration.memref_type}),207            );208            try self.op.setAttr(209                names.alignment,210                try ctx.getI64Attr(@intCast(declaration.alignment)),211            );212            try self.op.setAttr(names.constant, try ctx.getBoolAttr(declaration.constant));213            if (declaration.initial) |bytes| {214                try self.op.setAttr(names.initial, try ctx.getStringAttr(bytes));215            }216            try verifyGlobal(self.op);217            return self;218        }219220        pub fn getSymName(self: GlobalOp) ?[]const u8 {221            const attr = self.op.getAttrAs(ir.Attribute.StringAttr, attr_names.sym_name) orelse222                return null;223            return attr.getValue();224        }225226        pub fn getType(self: GlobalOp) ?ir.Type {227            const attr = self.op.getAttrAs(228                ir.Attribute.TypeListAttr,229                attr_names.memref_type,230            ) orelse return null;231            const values = attr.getValues();232            if (values.len != 1) return null;233            return values[0];234        }235236        pub fn getAlignment(self: GlobalOp) ?u64 {237            const attr = self.op.getAttrAs(ir.Attribute.IntegerAttr, attr_names.alignment) orelse238                return null;239            const value = attr.getValue();240            if (value < 0) return null;241            return @intCast(value);242        }243244        pub fn isConstant(self: GlobalOp) ?bool {245            const attr = self.op.getAttrAs(ir.Attribute.BoolAttr, attr_names.constant) orelse246                return null;247            return attr.getValue();248        }249250        pub fn getInitial(self: GlobalOp) ?[]const u8 {251            const attr = self.op.getAttrAs(ir.Attribute.StringAttr, attr_names.initial) orelse252                return null;253            return attr.getValue();254        }255256        /// Where this global's storage comes from, or null when the attributes do not decide it.257        pub fn getPlacement(self: GlobalOp) ?GlobalPlacement {258            const constant = self.isConstant() orelse return null;259            if (self.getInitial() == null) {260                if (constant) return null;261                return .zeroed;262            }263            return if (constant) .read_only else .writable;264        }265    };266267    /// The address of a global, as a memref value of that global's declared type.268    ///269    /// This computes an address and touches nothing, so it declares one result and no event.270    /// Reading or writing through the result is what `memref.load` and `memref.store` declare.271    pub const GetGlobalOp = struct {272        op: *ir.Operation,273274        pub const attr_names = struct {275            pub const sym_name = "sym_name";276        };277278        const leaf = op_templates.explicitLeaf(@This(), .{279            .mnemonic = "get_global",280            .operands = 0,281            .results = .{"memref"},282            .required_attrs = .{ir.dialects.attribute.string(attr_names.sym_name)},283            .interfaces = &.{effects.EffectOpInterface.entryFor(.{284                .complete = true,285                .facts = &.{.{ .result = .{ .index = 0, .ownership = .none } }},286            })},287        });288        pub const operation_spec = leaf.operation_spec;289        pub const operation_name = leaf.operation_name;290        pub const createLeaf = leaf.createLeaf;291        pub const verify = verifyGetGlobalOp;292293        pub fn create(294            ctx: *ir.Context,295            loc: ir.Location,296            sym_name: []const u8,297            result_type: ir.Type,298        ) !GetGlobalOp {299            try loadSpec(ctx);300            const self = try @This().createLeaf(ctx, loc, &.{}, &.{result_type});301            errdefer self.op.erase();302            try self.op.setAttr(attr_names.sym_name, try ctx.getStringAttr(sym_name));303            try verifyGetGlobal(self.op);304            return self;305        }306307        pub fn getResult(self: *const GetGlobalOp) *ir.Value {308            return self.op.getResult(0).?;309        }310311        pub fn getSymName(self: GetGlobalOp) ?[]const u8 {312            const attr = self.op.getAttrAs(ir.Attribute.StringAttr, attr_names.sym_name) orelse313                return null;314            return attr.getValue();315        }316    };317318    pub const DeallocOp = struct {319        op: *ir.Operation,320321        pub const operation_spec = op_specs.leaf(.{322            .mnemonic = "dealloc",323            .interfaces = &.{effects.EffectOpInterface.entryFor(.{ .facts = &.{324                .{ .requirement = .{ .kind = .live, .subject = .{ .operand = 0 } } },325                .{ .event = .{ .kind = .free, .resource = .{ .subject = .{ .operand = 0 } } } },326            } })},327            .operands = 1,328            .results = 0,329        });330        pub const operation_name = operation_spec.name;331332        pub fn create(333            ctx: *ir.Context,334            loc: ir.Location,335            memref: *ir.Value,336        ) !DeallocOp {337            var builder = ir.OperationBuilder.init(ctx);338            var state = op_specs.state(@This(), loc);339            state.addOperands(&.{memref});340341            const op = try builder.create(state);342            return .{ .op = op };343        }344345        pub fn getMemref(self: DeallocOp) *ir.Value {346            return self.op.operands.items[0].value;347        }348    };349350    pub const FenceOp = struct {351        op: *ir.Operation,352353        pub const operation_spec = op_specs.leaf(.{354            .mnemonic = "fence",355            .interfaces = &.{effects.EffectOpInterface.entryFor(.{ .facts = &.{.{356                .event = .{ .kind = .synchronize, .ordered = true },357            }} })},358            .operands = 0,359            .results = 0,360            .attrs = &.{ "scope", "ordering" },361            .traits = ir.OperationTraits{},362        });363        pub const operation_name = operation_spec.name;364365        pub fn create(366            ctx: *ir.Context,367            loc: ir.Location,368            scope: FenceScope,369            ordering: FenceOrdering,370        ) !FenceOp {371            var builder = ir.OperationBuilder.init(ctx);372            const op = try builder.create(op_specs.state(@This(), loc));373            errdefer op.erase();374            try setFenceScopeAttr(op, ctx, scope);375            try setFenceOrderingAttr(op, ctx, ordering);376            return .{ .op = op };377        }378379        pub fn getScope(self: FenceOp) ?FenceScope {380            return getFenceScopeAttr(self.op);381        }382383        pub fn getOrdering(self: FenceOp) ?FenceOrdering {384            return getFenceOrderingAttr(self.op);385        }386    };387388    pub const LoadOp = struct {389        op: *ir.Operation,390391        pub const operation_spec = op_specs.leaf(.{392            .mnemonic = "load",393            .interfaces = &.{accessEffects(0, 1, true, false, false)},394            .operands = 2,395            .results = 1,396            .attrs = &.{ "cache", "eviction" },397            .traits = ir.OperationTraits{},398        });399        pub const operation_name = operation_spec.name;400401        pub fn create(402            ctx: *ir.Context,403            loc: ir.Location,404            memref: *ir.Value,405            index: *ir.Value,406            result_type: ir.Type,407        ) !LoadOp {408            var builder = ir.OperationBuilder.init(ctx);409            var state = op_specs.state(@This(), loc);410            state.addOperands(&.{ memref, index });411            state.addTypes(&.{result_type});412413            const op = try builder.create(state);414            return .{ .op = op };415        }416417        pub fn createWithCache(418            ctx: *ir.Context,419            loc: ir.Location,420            memref: *ir.Value,421            index: *ir.Value,422            result_type: ir.Type,423            cache: ?CacheOperation,424            eviction: ?CacheEviction,425        ) !LoadOp {426            const load = try create(ctx, loc, memref, index, result_type);427            errdefer load.op.erase();428            if (cache) |hint| {429                try setCacheOperationAttr(load.op, ctx, hint);430            }431            if (eviction) |hint| {432                try setCacheEvictionAttr(load.op, ctx, hint);433            }434            return load;435        }436437        pub fn getResult(self: *const LoadOp) *ir.Value {438            return self.op.getResult(0).?;439        }440441        pub fn getMemref(self: LoadOp) *ir.Value {442            return self.op.operands.items[0].value;443        }444445        pub fn getIndex(self: LoadOp) *ir.Value {446            return self.op.operands.items[1].value;447        }448449        pub fn getCacheOperation(self: LoadOp) ?CacheOperation {450            return getCacheOperationAttr(self.op);451        }452453        pub fn getCacheEviction(self: LoadOp) ?CacheEviction {454            return getCacheEvictionAttr(self.op);455        }456    };457458    pub const StoreOp = struct {459        op: *ir.Operation,460461        pub const operation_spec = op_specs.leaf(.{462            .mnemonic = "store",463            .interfaces = &.{accessEffects(1, 2, false, true, false)},464            .operands = 3,465            .results = 0,466            .attrs = &.{ "cache", "eviction" },467            .traits = ir.OperationTraits{},468        });469        pub const operation_name = operation_spec.name;470471        pub fn create(472            ctx: *ir.Context,473            loc: ir.Location,474            value: *ir.Value,475            memref: *ir.Value,476            index: *ir.Value,477        ) !StoreOp {478            var builder = ir.OperationBuilder.init(ctx);479            var state = op_specs.state(@This(), loc);480            state.addOperands(&.{ value, memref, index });481482            const op = try builder.create(state);483            return .{ .op = op };484        }485486        pub fn createWithCache(487            ctx: *ir.Context,488            loc: ir.Location,489            value: *ir.Value,490            memref: *ir.Value,491            index: *ir.Value,492            cache: ?CacheOperation,493            eviction: ?CacheEviction,494        ) !StoreOp {495            const store = try create(ctx, loc, value, memref, index);496            errdefer store.op.erase();497            if (cache) |hint| {498                try setCacheOperationAttr(store.op, ctx, hint);499            }500            if (eviction) |hint| {501                try setCacheEvictionAttr(store.op, ctx, hint);502            }503            return store;504        }505506        pub fn getValue(self: StoreOp) *ir.Value {507            return self.op.operands.items[0].value;508        }509510        pub fn getMemref(self: StoreOp) *ir.Value {511            return self.op.operands.items[1].value;512        }513514        pub fn getIndex(self: StoreOp) *ir.Value {515            return self.op.operands.items[2].value;516        }517518        pub fn getCacheOperation(self: StoreOp) ?CacheOperation {519            return getCacheOperationAttr(self.op);520        }521522        pub fn getCacheEviction(self: StoreOp) ?CacheEviction {523            return getCacheEvictionAttr(self.op);524        }525    };526527    pub const AtomicRmwOp = struct {528        op: *ir.Operation,529530        pub const operation_spec = op_specs.leaf(.{531            .mnemonic = "atomic_rmw",532            .interfaces = &.{accessEffects(1, 2, true, true, true)},533            .operands = 3,534            .results = 1,535            .attrs = &.{"kind"},536            .traits = ir.OperationTraits{},537        });538        pub const operation_name = operation_spec.name;539540        pub fn create(541            ctx: *ir.Context,542            loc: ir.Location,543            kind: AtomicRmwKind,544            value: *ir.Value,545            memref: *ir.Value,546            index: *ir.Value,547            result_type: ir.Type,548        ) !AtomicRmwOp {549            var builder = ir.OperationBuilder.init(ctx);550            var state = op_specs.state(@This(), loc);551            state.addOperands(&.{ value, memref, index });552            state.addTypes(&.{result_type});553554            const op = try builder.create(state);555            errdefer op.erase();556            const kind_attr = try ctx.getDialectAttr("memref.atomic_kind", kind.toString());557            try op.setAttr("kind", kind_attr);558            return .{ .op = op };559        }560561        pub fn getKind(self: AtomicRmwOp) ?AtomicRmwKind {562            const dialect_attr = self.op.getAttrAs(ir.Attribute.DialectAttr, "kind") orelse return null;563            return AtomicRmwKind.fromString(dialect_attr.payload);564        }565566        pub fn getValue(self: AtomicRmwOp) *ir.Value {567            return self.op.operands.items[0].value;568        }569570        pub fn getMemref(self: AtomicRmwOp) *ir.Value {571            return self.op.operands.items[1].value;572        }573574        pub fn getIndex(self: AtomicRmwOp) *ir.Value {575            return self.op.operands.items[2].value;576        }577578        pub fn getResult(self: *const AtomicRmwOp) *ir.Value {579            return self.op.getResult(0).?;580        }581    };582583    /// Reads one element atomically: no other thread observes a torn word, and the read is584    /// ordered by `ordering`, which is `acquire` or `seq_cst` because a load cannot release.585    pub const AtomicLoadOp = struct {586        op: *ir.Operation,587588        pub const operation_spec = op_specs.leaf(.{589            .mnemonic = "atomic_load",590            .interfaces = &.{accessEffects(0, 1, true, false, true)},591            .operands = 2,592            .results = 1,593            .required_attrs = .{ir.dialects.attribute.dialect("ordering", "memref.fence_ordering")},594            .traits = ir.OperationTraits{},595        });596        pub const operation_name = operation_spec.name;597        pub const verify = verifyAtomicLoadOp;598599        pub fn create(600            ctx: *ir.Context,601            loc: ir.Location,602            memref: *ir.Value,603            index: *ir.Value,604            result_type: ir.Type,605            ordering: FenceOrdering,606        ) !AtomicLoadOp {607            var builder = ir.OperationBuilder.init(ctx);608            var state = op_specs.state(@This(), loc);609            state.addOperands(&.{ memref, index });610            state.addTypes(&.{result_type});611612            const op = try builder.create(state);613            errdefer op.erase();614            try setFenceOrderingAttr(op, ctx, ordering);615            try verifyAtomicLoad(op);616            return .{ .op = op };617        }618619        pub fn getMemref(self: AtomicLoadOp) *ir.Value {620            return self.op.operands.items[0].value;621        }622623        pub fn getIndex(self: AtomicLoadOp) *ir.Value {624            return self.op.operands.items[1].value;625        }626627        pub fn getOrdering(self: AtomicLoadOp) ?FenceOrdering {628            return getFenceOrderingAttr(self.op);629        }630631        pub fn getResult(self: *const AtomicLoadOp) *ir.Value {632            return self.op.getResult(0).?;633        }634    };635636    /// Writes one element atomically, ordered by `ordering`, which is `release` or `seq_cst`637    /// because a store cannot acquire.638    pub const AtomicStoreOp = struct {639        op: *ir.Operation,640641        pub const operation_spec = op_specs.leaf(.{642            .mnemonic = "atomic_store",643            .interfaces = &.{accessEffects(1, 2, false, true, true)},644            .operands = 3,645            .results = 0,646            .required_attrs = .{ir.dialects.attribute.dialect("ordering", "memref.fence_ordering")},647            .traits = ir.OperationTraits{},648        });649        pub const operation_name = operation_spec.name;650        pub const verify = verifyAtomicStoreOp;651652        pub fn create(653            ctx: *ir.Context,654            loc: ir.Location,655            value: *ir.Value,656            memref: *ir.Value,657            index: *ir.Value,658            ordering: FenceOrdering,659        ) !AtomicStoreOp {660            var builder = ir.OperationBuilder.init(ctx);661            var state = op_specs.state(@This(), loc);662            state.addOperands(&.{ value, memref, index });663664            const op = try builder.create(state);665            errdefer op.erase();666            try setFenceOrderingAttr(op, ctx, ordering);667            try verifyAtomicStore(op);668            return .{ .op = op };669        }670671        pub fn getValue(self: AtomicStoreOp) *ir.Value {672            return self.op.operands.items[0].value;673        }674675        pub fn getMemref(self: AtomicStoreOp) *ir.Value {676            return self.op.operands.items[1].value;677        }678679        pub fn getIndex(self: AtomicStoreOp) *ir.Value {680            return self.op.operands.items[2].value;681        }682683        pub fn getOrdering(self: AtomicStoreOp) ?FenceOrdering {684            return getFenceOrderingAttr(self.op);685        }686    };687688    pub const AtomicCasOp = struct {689        op: *ir.Operation,690691        pub const operation_spec = op_specs.leaf(.{692            .mnemonic = "atomic_cas",693            .interfaces = &.{accessEffects(2, 3, true, true, true)},694            .operands = 4,695            .results = 1,696            .attrs = .{ir.dialects.attribute.dialect("ordering", "memref.fence_ordering")},697            .traits = ir.OperationTraits{},698        });699        pub const operation_name = operation_spec.name;700        pub const verify = verifyAtomicCasOp;701702        pub fn create(703            ctx: *ir.Context,704            loc: ir.Location,705            expected: *ir.Value,706            desired: *ir.Value,707            memref: *ir.Value,708            index: *ir.Value,709            result_type: ir.Type,710        ) !AtomicCasOp {711            var builder = ir.OperationBuilder.init(ctx);712            var state = op_specs.state(@This(), loc);713            state.addOperands(&.{ expected, desired, memref, index });714            state.addTypes(&.{result_type});715716            const op = try builder.create(state);717            return .{ .op = op };718        }719720        pub fn getExpected(self: AtomicCasOp) *ir.Value {721            return self.op.operands.items[0].value;722        }723724        pub fn getDesired(self: AtomicCasOp) *ir.Value {725            return self.op.operands.items[1].value;726        }727728        pub fn getMemref(self: AtomicCasOp) *ir.Value {729            return self.op.operands.items[2].value;730        }731732        pub fn getIndex(self: AtomicCasOp) *ir.Value {733            return self.op.operands.items[3].value;734        }735736        /// The same exchange with its ordering spelled. Every ordering is legal on a compare737        /// and swap, which both reads and writes.738        pub fn createOrdered(739            ctx: *ir.Context,740            loc: ir.Location,741            expected: *ir.Value,742            desired: *ir.Value,743            memref: *ir.Value,744            index: *ir.Value,745            result_type: ir.Type,746            ordering: FenceOrdering,747        ) !AtomicCasOp {748            const cas = try create(ctx, loc, expected, desired, memref, index, result_type);749            errdefer cas.op.erase();750            try setFenceOrderingAttr(cas.op, ctx, ordering);751            return cas;752        }753754        /// The ordering the exchange carries, `seq_cst` when none is spelled.755        pub fn getOrdering(self: AtomicCasOp) FenceOrdering {756            return getFenceOrderingAttr(self.op) orelse .seq_cst;757        }758759        pub fn getResult(self: *const AtomicCasOp) *ir.Value {760            return self.op.getResult(0).?;761        }762    };763764    pub const CopyOp = struct {765        op: *ir.Operation,766767        pub const operation_spec = op_specs.leaf(.{768            .mnemonic = "copy",769            .interfaces = &.{effects.EffectOpInterface.entryFor(.{ .facts = &.{770                .{ .event = .{ .kind = .read, .resource = .{ .subject = .{ .operand = 0 } } } },771                .{ .event = .{ .kind = .write, .resource = .{ .subject = .{ .operand = 1 } } } },772            } })},773            .operands = 2,774            .results = 0,775        });776        pub const operation_name = operation_spec.name;777778        pub fn create(779            ctx: *ir.Context,780            loc: ir.Location,781            src: *ir.Value,782            dst: *ir.Value,783        ) !CopyOp {784            var builder = ir.OperationBuilder.init(ctx);785            var state = op_specs.state(@This(), loc);786            state.addOperands(&.{ src, dst });787788            const op = try builder.create(state);789            return .{ .op = op };790        }791792        pub fn getSrc(self: CopyOp) *ir.Value {793            return self.op.operands.items[0].value;794        }795796        pub fn getDst(self: CopyOp) *ir.Value {797            return self.op.operands.items[1].value;798        }799    };800801    pub const SubviewOp = struct {802        op: *ir.Operation,803804        pub const operation_spec = op_specs.leaf(.{805            .mnemonic = "subview",806            .interfaces = &.{aliasEffects()},807            .operands = 1,808            .results = 1,809            .attrs = &.{ "offset", "shape", "stride" },810        });811        pub const operation_name = operation_spec.name;812813        pub fn create(814            ctx: *ir.Context,815            loc: ir.Location,816            source: *ir.Value,817            result_type: ir.Type,818        ) !SubviewOp {819            var builder = ir.OperationBuilder.init(ctx);820            var state = op_specs.state(@This(), loc);821            state.addOperands(&.{source});822            state.addTypes(&.{result_type});823824            const op = try builder.create(state);825            return .{ .op = op };826        }827828        pub fn getResult(self: *const SubviewOp) *ir.Value {829            return self.op.getResult(0).?;830        }831832        pub fn getSource(self: SubviewOp) *ir.Value {833            return self.op.operands.items[0].value;834        }835836        pub fn getShapePayload(self: SubviewOp) ?[]const u8 {837            return getLayoutPayload(self.op, "shape");838        }839840        pub fn getStridePayload(self: SubviewOp) ?[]const u8 {841            return getLayoutPayload(self.op, "stride");842        }843844        pub fn getOffsetPayload(self: SubviewOp) ?[]const u8 {845            return getLayoutPayload(self.op, "offset");846        }847    };848849    /// A memref over a byte offset into a byte addressed base, with the offset unscaled.850    ///851    /// This is the one spelling for reaching a value inside an arena. `memref.load` and852    /// `memref.store` scale their index by the element size of the memref they are given, so a853    /// byte offset cannot be expressed as an index into a base of wider elements, and854    /// `memref.subview` carries a static offset attribute rather than a value. Here the base is855    /// 8 bit elements, the offset is one `index` operand added to the base unscaled, and loads856    /// and stores through the result scale by the RESULT's element size.857    ///858    /// The result type is the result's own type rather than a repeated attribute, so there is859    /// one statement of it that cannot disagree with itself.860    ///861    /// The arithmetic is one add and touches no memory, but the VALUE is a borrow: the result862    /// points inside the base's storage. So this declares the base borrowed and the result an863    /// alias of it, the same as `memref.subview` and `memref.transpose`. Declaring an864    /// independent result instead would tell a consumer that a write through the view cannot865    /// reach the base, which is the one thing that is never true here.866    ///867    /// Aligning the offset is the producer's duty. This operation does not check it, at868    /// verification or at run time, because the offset is a value and the alignment a value869    /// must satisfy is a property of what the producer intends to store there.870    pub const ViewOp = struct {871        op: *ir.Operation,872873        pub const operation_spec = op_specs.leaf(.{874            .mnemonic = "view",875            .interfaces = &.{aliasEffects()},876            .operands = 2,877            .results = 1,878        });879        pub const operation_name = operation_spec.name;880        pub const verify = verifyViewOp;881882        pub fn create(883            ctx: *ir.Context,884            loc: ir.Location,885            base: *ir.Value,886            byte_offset: *ir.Value,887            result_type: ir.Type,888        ) !ViewOp {889            var builder = ir.OperationBuilder.init(ctx);890            var state = op_specs.state(@This(), loc);891            state.addOperands(&.{ base, byte_offset });892            state.addTypes(&.{result_type});893894            const op = try builder.create(state);895            errdefer op.erase();896            try verifyView(op);897            return .{ .op = op };898        }899900        pub fn getResult(self: *const ViewOp) *ir.Value {901            return self.op.getResult(0).?;902        }903904        pub fn getBase(self: ViewOp) *ir.Value {905            return self.op.operands.items[0].value;906        }907908        pub fn getByteOffset(self: ViewOp) *ir.Value {909            return self.op.operands.items[1].value;910        }911    };912913    pub const TransposeOp = struct {914        op: *ir.Operation,915916        pub const operation_spec = op_specs.leaf(.{917            .mnemonic = "transpose",918            .interfaces = &.{aliasEffects()},919            .operands = 1,920            .results = 1,921            .attrs = &.{ "shape", "stride" },922        });923        pub const operation_name = operation_spec.name;924925        pub fn create(926            ctx: *ir.Context,927            loc: ir.Location,928            source: *ir.Value,929            result_type: ir.Type,930        ) !TransposeOp {931            var builder = ir.OperationBuilder.init(ctx);932            var state = op_specs.state(@This(), loc);933            state.addOperands(&.{source});934            state.addTypes(&.{result_type});935936            const op = try builder.create(state);937            return .{ .op = op };938        }939940        pub fn getResult(self: *const TransposeOp) *ir.Value {941            return self.op.getResult(0).?;942        }943944        pub fn getSource(self: TransposeOp) *ir.Value {945            return self.op.operands.items[0].value;946        }947948        pub fn getShapePayload(self: TransposeOp) ?[]const u8 {949            return getLayoutPayload(self.op, "shape");950        }951952        pub fn getStridePayload(self: TransposeOp) ?[]const u8 {953            return getLayoutPayload(self.op, "stride");954        }955    };956957    fn deinitPayload(allocator: std.mem.Allocator, ptr: *anyopaque) void {958        const payload: *MemrefTypePayload = @ptrCast(@alignCast(ptr));959        allocator.destroy(payload);960    }961962    fn typeParamFallback(ctx: *const ir.Context, typ: ir.Type) ?*const anyopaque {963        _ = ctx;964        const type_name = typ.getDialectTypeName() orelse return null;965        if (!std.mem.eql(u8, type_name, name)) return null;966        return &type_param_vtable;967    }968969    fn shapedTypeFallback(ctx: *const ir.Context, typ: ir.Type) ?*const anyopaque {970        _ = ctx;971        const type_name = typ.getDialectTypeName() orelse return null;972        if (!std.mem.eql(u8, type_name, name)) return null;973        return &shaped_type_vtable;974    }975976    fn loadSpec(ctx: *ir.Context) !void {977        ir.dialects.loadDialectSpec(ctx, spec) catch |err| switch (err) {978            error.ContextFrozen => {},979            else => return err,980        };981    }982983    fn payloadFromTypePtr(ctx: *ir.Context, type_ptr: *const anyopaque) ?*const MemrefTypePayload {984        loadSpec(ctx) catch return null;985986        const storage: *const ir.Type.DialectTypeStorage = @ptrCast(@alignCast(type_ptr));987        const typ = ir.Type{988            .type_id = .dialect_type,989            .impl = storage,990        };991        return ctx.getTypeParamPayload(typ, MemrefTypePayload) catch null;992    }993994    fn parseTypeParams(type_ptr: *const anyopaque, ctx_opaque: *const interfaces.ContextOpaque) anyerror!?interfaces.TypeParamPayload {995        const ctx = interfaces.castContext(ir.Context, ctx_opaque);996        const storage: *const ir.Type.DialectTypeStorage = @ptrCast(@alignCast(type_ptr));997        if (storage.param_key.len == 0) return null;998999        const params = parseMemrefParams(storage.param_key) orelse return null;10001001        const payload = try ir.context.typePayloadAllocator(ctx).create(MemrefTypePayload);1002        payload.* = .{1003            .size = params.size,1004            .element_type_name = params.element_type_name,1005            .element_type = ctx.getDialectTypeFromName(params.element_type_name) catch null,1006            .addr_space = params.addr_space,1007            .alignment = params.alignment,1008            .exclusive = params.exclusive,1009            .indexing = params.indexing,1010        };10111012        if (params.size) |size| {1013            payload.shape_storage[0] = size;1014            payload.shape = payload.shape_storage[0..1];1015        } else {1016            payload.shape = null;1017        }10181019        return .{ .ptr = payload, .deinit = deinitPayload };1020    }10211022    fn shapedGetRank(type_ptr: *const anyopaque, ctx_opaque: *const interfaces.ContextOpaque) ?usize {1023        const ctx = interfaces.castContext(ir.Context, ctx_opaque);1024        const payload = payloadFromTypePtr(ctx, type_ptr) orelse return null;1025        _ = payload;1026        return 1;1027    }10281029    fn shapedGetShape(type_ptr: *const anyopaque, ctx_opaque: *const interfaces.ContextOpaque) ?[]const u64 {1030        const ctx = interfaces.castContext(ir.Context, ctx_opaque);1031        const payload = payloadFromTypePtr(ctx, type_ptr) orelse return null;1032        return payload.shape;1033    }10341035    fn shapedGetElementType(type_ptr: *const anyopaque, ctx_opaque: *const interfaces.ContextOpaque) ?ir.Type {1036        const ctx = interfaces.castContext(ir.Context, ctx_opaque);1037        const payload = payloadFromTypePtr(ctx, type_ptr) orelse return null;1038        return payload.element_type;1039    }10401041    fn shapedGetAddressSpaceTag(type_ptr: *const anyopaque, ctx_opaque: *const interfaces.ContextOpaque) ?u8 {1042        const ctx = interfaces.castContext(ir.Context, ctx_opaque);1043        const payload = payloadFromTypePtr(ctx, type_ptr) orelse return null;1044        return @backingInt(payload.addr_space);1045    }10461047    pub fn getMemrefType1D(1048        ctx: *ir.Context,1049        size: u64,1050        element_type: ir.Type,1051        addr_space: AddressSpace,1052    ) !ir.Type {1053        return getMemrefType1DWithAttrs(ctx, size, element_type, addr_space, .{});1054    }10551056    pub fn getMemrefTypeDynamic(1057        ctx: *ir.Context,1058        element_type: ir.Type,1059        addr_space: AddressSpace,1060    ) !ir.Type {1061        return getMemrefTypeDynamicWithAttrs(ctx, element_type, addr_space, .{});1062    }10631064    pub fn getMemrefType1DWithAttrs(1065        ctx: *ir.Context,1066        size: u64,1067        element_type: ir.Type,1068        addr_space: AddressSpace,1069        attrs: MemrefTypeAttrs,1070    ) !ir.Type {1071        try loadSpec(ctx);1072        var buf: [512]u8 = undefined;1073        const elem_name = element_type.getDialectTypeName() orelse "unknown";1074        var pos: usize = 0;1075        pos = try ir.format.appendFmt(buf[0..], pos, "{d},{s},{s}", .{1076            size,1077            elem_name,1078            addr_space.toString(),1079        });1080        pos = try appendTypeAttrs(buf[0..], pos, attrs);1081        return ctx.getDialectTypeFromNameWithKey("memref", buf[0..pos]);1082    }10831084    pub fn getMemrefTypeDynamicWithAttrs(1085        ctx: *ir.Context,1086        element_type: ir.Type,1087        addr_space: AddressSpace,1088        attrs: MemrefTypeAttrs,1089    ) !ir.Type {1090        try loadSpec(ctx);1091        var buf: [512]u8 = undefined;1092        const elem_name = element_type.getDialectTypeName() orelse "unknown";1093        var pos: usize = 0;1094        pos = try ir.format.appendFmt(buf[0..], pos, "?,{s},{s}", .{1095            elem_name,1096            addr_space.toString(),1097        });1098        pos = try appendTypeAttrs(buf[0..], pos, attrs);1099        return ctx.getDialectTypeFromNameWithKey("memref", buf[0..pos]);1100    }11011102    pub fn parseMemrefParams(param_key: []const u8) ?MemrefParams {1103        var section_iter = std.mem.splitScalar(u8, param_key, ';');1104        const base = section_iter.next() orelse return null;1105        var iter = std.mem.splitScalar(u8, base, ',');11061107        const size_str = iter.next() orelse return null;1108        const size: ?u64 = if (std.mem.eql(u8, size_str, "?"))1109            null1110        else1111            std.fmt.parseInt(u64, size_str, 10) catch return null;11121113        const elem_type = iter.next() orelse return null;1114        const addr_space_str = iter.next() orelse return null;1115        const addr_space = AddressSpace.fromString(addr_space_str) orelse return null;11161117        var alignment: ?u64 = null;1118        var exclusive: ?bool = null;1119        var indexing: ?Indexing = null;11201121        while (section_iter.next()) |section| {1122            if (section.len == 0) continue;1123            var kv_iter = std.mem.splitScalar(u8, section, '=');1124            const key = kv_iter.next() orelse continue;1125            const value = kv_iter.next() orelse continue;1126            if (kv_iter.next() != null) return null;11271128            if (std.mem.eql(u8, key, "alignment") or std.mem.eql(u8, key, "align")) {1129                alignment = std.fmt.parseInt(u64, value, 10) catch return null;1130                continue;1131            }11321133            if (std.mem.eql(u8, key, "exclusive")) {1134                if (std.mem.eql(u8, value, "true")) {1135                    exclusive = true;1136                } else if (std.mem.eql(u8, value, "false")) {1137                    exclusive = false;1138                } else {1139                    return null;1140                }1141                continue;1142            }11431144            if (std.mem.eql(u8, key, "indexing")) {1145                indexing = Indexing.fromString(value) orelse return null;1146                continue;1147            }1148        }11491150        return .{1151            .size = size,1152            .element_type_name = elem_type,1153            .addr_space = addr_space,1154            .alignment = alignment,1155            .exclusive = exclusive,1156            .indexing = indexing,1157        };1158    }11591160    fn formatDims(buf: *std.ArrayListUnmanaged(u8), allocator: std.mem.Allocator, dims: []const u64) !void {1161        if (dims.len == 0) return;1162        for (dims, 0..) |dim, i| {1163            if (i > 0) try buf.append(allocator, ',');1164            var tmp: [32]u8 = undefined;1165            const text = try std.fmt.bufPrint(&tmp, "{d}", .{dim});1166            try buf.appendSlice(allocator, text);1167        }1168    }11691170    fn setLayoutDimsAttr(op: *ir.Operation, ctx: *ir.Context, attr_name: []const u8, full_name: []const u8, dims: []const u64) !void {1171        var buf: std.ArrayListUnmanaged(u8) = .empty;1172        const allocator = ir.context.transientAllocator(ctx);1173        defer buf.deinit(allocator);1174        try formatDims(&buf, allocator, dims);1175        const attr = try ctx.getDialectAttr(full_name, buf.items);1176        try op.setAttr(attr_name, attr);1177    }11781179    fn setLayoutOffsetAttr(op: *ir.Operation, ctx: *ir.Context, offset: u64) !void {1180        var buf: [32]u8 = undefined;1181        const payload = try std.fmt.bufPrint(&buf, "{d}", .{offset});1182        const attr = try ctx.getDialectAttr("memref.offset", payload);1183        try op.setAttr("offset", attr);1184    }11851186    fn getLayoutPayload(op: *const ir.Operation, attr_name: []const u8) ?[]const u8 {1187        const dialect_attr = op.getAttrAs(ir.Attribute.DialectAttr, attr_name) orelse return null;1188        return dialect_attr.payload;1189    }11901191    pub fn setLayoutAttrs(op: *ir.Operation, ctx: *ir.Context, attrs: LayoutAttrs) !void {1192        if (attrs.offset) |offset| {1193            try setLayoutOffsetAttr(op, ctx, offset);1194        }1195        if (attrs.shape) |shape| {1196            try setLayoutDimsAttr(op, ctx, "shape", "memref.shape", shape);1197        }1198        if (attrs.stride) |stride| {1199            try setLayoutDimsAttr(op, ctx, "stride", "memref.stride", stride);1200        }1201    }12021203    fn setCacheOperationAttr(op: *ir.Operation, ctx: *ir.Context, cache: CacheOperation) !void {1204        const cache_attr = try ctx.getDialectAttr("memref.cache", cache.toString());1205        try op.setAttr("cache", cache_attr);1206    }12071208    fn getCacheOperationAttr(op: *const ir.Operation) ?CacheOperation {1209        const dialect_attr = op.getAttrAs(ir.Attribute.DialectAttr, "cache") orelse return null;1210        return CacheOperation.fromString(dialect_attr.payload);1211    }12121213    fn setCacheEvictionAttr(op: *ir.Operation, ctx: *ir.Context, eviction: CacheEviction) !void {1214        const eviction_attr = try ctx.getDialectAttr("memref.eviction", eviction.toString());1215        try op.setAttr("eviction", eviction_attr);1216    }12171218    fn getCacheEvictionAttr(op: *const ir.Operation) ?CacheEviction {1219        const dialect_attr = op.getAttrAs(ir.Attribute.DialectAttr, "eviction") orelse return null;1220        return CacheEviction.fromString(dialect_attr.payload);1221    }12221223    fn setFenceScopeAttr(op: *ir.Operation, ctx: *ir.Context, scope: FenceScope) !void {1224        const attr = try ctx.getDialectAttr("memref.fence_scope", scope.toString());1225        try op.setAttr("scope", attr);1226    }12271228    fn getFenceScopeAttr(op: *const ir.Operation) ?FenceScope {1229        const dialect_attr = op.getAttrAs(ir.Attribute.DialectAttr, "scope") orelse return null;1230        return FenceScope.fromString(dialect_attr.payload);1231    }12321233    fn setFenceOrderingAttr(op: *ir.Operation, ctx: *ir.Context, ordering: FenceOrdering) !void {1234        const attr = try ctx.getDialectAttr("memref.fence_ordering", ordering.toString());1235        try op.setAttr("ordering", attr);1236    }12371238    fn getFenceOrderingAttr(op: *const ir.Operation) ?FenceOrdering {1239        const dialect_attr = op.getAttrAs(ir.Attribute.DialectAttr, "ordering") orelse return null;1240        return FenceOrdering.fromString(dialect_attr.payload);1241    }12421243    fn appendTypeAttrs(buf: []u8, start: usize, attrs: MemrefTypeAttrs) !usize {1244        var pos = start;1245        if (attrs.alignment) |alignment| {1246            pos = try ir.format.appendFmt(buf, pos, ";alignment={d}", .{alignment});1247        }1248        if (attrs.exclusive) |exclusive| {1249            pos = try ir.format.appendFmt(1250                buf,1251                pos,1252                ";exclusive={s}",1253                .{if (exclusive) "true" else "false"},1254            );1255        }1256        if (attrs.indexing) |indexing| {1257            pos = try ir.format.appendFmt(buf, pos, ";indexing={s}", .{indexing.toString()});1258        }1259        return pos;1260    }1261};