tiny.choir.ir.dialects

1pub const AttributeSpec = struct {2    name: []const u8,3    storage: AttributeStorage = .any,4};

1pub const AttributeStorage = union(enum) {2    any,3    i64,4    bool,5    string,6    dialect: []const u8,7};

1pub const DialectSpec = struct {2    name: []const u8,3    operations: []const OperationSpec = &.{},4    types: []const TypeSpec = &.{},5    dialect_attributes: []const []const u8 = &.{},6    interfaces: []const interfaces.InterfaceEntry = &.{},7    op_interface_fallbacks: []const OpInterfaceFallbackEntry = &.{},8    type_interface_fallbacks: []const TypeInterfaceFallbackEntry = &.{},9};

1pub const DialectSpecOptions = struct {2    types: []const TypeSpec = &.{},3    dialect_attributes: []const []const u8 = &.{},4    interfaces: []const interfaces.InterfaceEntry = &.{},5    op_interface_fallbacks: []const OpInterfaceFallbackEntry = &.{},6    type_interface_fallbacks: []const TypeInterfaceFallbackEntry = &.{},7};

1pub const OperationSpec = struct {2    name: []const u8,3    traits: interfaces.OperationTraits = .{},4    shape: interfaces.OperationShape = .{},5    operand_names: []const []const u8 = &.{},6    result_names: []const []const u8 = &.{},7    region_names: []const []const u8 = &.{},8    successor_names: []const []const u8 = &.{},9    inherent_attribute_names: []const []const u8 = &.{},10    required_attribute_names: []const []const u8 = &.{},11    attribute_specs: []const AttributeSpec = &.{},12    operand_segments: ?interfaces.OperationSegmentSpec = null,13    result_segments: ?interfaces.OperationSegmentSpec = null,14    operand_type_constraints: []const interfaces.OperationTypeConstraint = &.{},15    result_type_constraints: []const interfaces.OperationTypeConstraint = &.{},16    properties_model: ?interfaces.OperationPropertiesModel = null,17    interfaces: []const interfaces.InterfaceEntry = &.{},18    dynamic_traits: []const OperationTraitSpec = &.{},19};

1pub const OperationTraitSpec = struct {2    id: interfaces.TraitId,3    entry: ?interfaces.TraitEntry = null,4    traits: interfaces.OperationTraits = .{},5};

1pub const TypeSpec = struct {2    name: []const u8,3    interfaces: []const interfaces.InterfaceEntry = &.{},4};

1pub fn dialectSpec(comptime DialectType: type, comptime options: DialectSpecOptions) DialectSpec {2    if (!@hasDecl(DialectType, "name")) @compileError("dialect type must declare name");3    return .{4        .name = DialectType.name,5        .operations = operations(DialectType),6        .types = options.types,7        .dialect_attributes = options.dialect_attributes,8        .interfaces = options.interfaces,9        .op_interface_fallbacks = options.op_interface_fallbacks,10        .type_interface_fallbacks = options.type_interface_fallbacks,11    };12}

1pub fn loadDialectSpec(ctx: *Context, spec: DialectSpec) !void {2    if (dialectSpecLoaded(ctx, spec)) return;3    try ensureDialectSpecLoaded(ctx, spec);4    try ctx.prepareDialectLoadRecordStorage(spec.name, spec.operations.len, spec.types.len);5    try registerDialectAttributes(ctx, spec.dialect_attributes);6    try ctx.registerOperationBatch(spec.operations);78    for (spec.operations) |op| try registerOperationDetails(ctx, op);910    try ctx.registerTypeBatch(spec.types);11    for (spec.types) |typ| {12        for (typ.interfaces) |entry| {13            ctx.registerTypeInterface(typ.name, entry) catch |err| switch (err) {14                error.DuplicateInterface => {},15                else => return err,16            };17        }18    }1920    for (spec.interfaces) |entry| {21        ctx.registerDialectInterface(spec.name, entry) catch |err| switch (err) {22            error.DuplicateInterface => {},23            else => return err,24        };25    }2627    for (spec.op_interface_fallbacks) |entry| {28        ctx.registerDialectOpInterfaceFallback(spec.name, entry.id, entry.fallback) catch |err| switch (err) {29            error.DuplicateInterface => {},30            else => return err,31        };32    }3334    for (spec.type_interface_fallbacks) |entry| {35        ctx.registerDialectTypeInterfaceFallback(spec.name, entry.id, entry.fallback) catch |err| switch (err) {36            error.DuplicateInterface => {},37            else => return err,38        };39    }40}

1pub fn operand(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) *IrValue {2    return op.getOperand(operandIndex(spec, component_name)).?;3}

1pub fn operandIndex(comptime spec: OperationSpec, comptime component_name: []const u8) usize {2    return componentIndex(spec.operand_names, "operand", component_name);3}

1pub fn operandSegmentValue(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*IrValue {2    const values = operandSegmentValues(spec, op, component_name) orelse return null;3    if (values.len != 1) return null;4    return values[0];5}

1pub fn operandSegmentValues(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?[]const *IrValue {2    const segment_spec = spec.operand_segments orelse @compileError("operation has no operand segments: " ++ spec.name);3    const index = comptime operandIndex(spec, component_name);4    const bounds = segmentBounds(segment_spec, op, index) orelse return null;5    if (bounds.offset > op.operand_values.len) return null;6    if (bounds.size > op.operand_values.len - bounds.offset) return null;7    return op.operand_values[bounds.offset .. bounds.offset + bounds.size];8}

1pub fn operation(comptime OpType: type) OperationSpec {2    return operationSpecWithName(operationNameFor(OpType), OpType);3}

1pub fn operationAttribute(comptime spec: OperationSpec, comptime attr_name: []const u8) AttributeSpec {2    inline for (spec.attribute_specs) |attribute_spec| {3        if (comptime std.mem.eql(u8, attribute_spec.name, attr_name)) return attribute_spec;4    }5    @compileError("unknown operation attribute: " ++ attr_name);6}

1pub fn operationDialectAttributeName(comptime spec: OperationSpec, comptime attr_name: []const u8) []const u8 {2    const attribute_spec = comptime operationAttribute(spec, attr_name);3    return switch (attribute_spec.storage) {4        .dialect => |dialect_attr_name| dialect_attr_name,5        .any => @compileError("operation attribute does not declare dialect storage: " ++ attr_name),6        else => @compileError("operation attribute is not dialect-backed: " ++ attr_name),7    };8}

1pub fn operationName(comptime dialect_name: []const u8, comptime mnemonic: []const u8) []const u8 {2    if (dialect_name.len == 0) @compileError("dialect name cannot be empty");3    if (mnemonic.len == 0) @compileError("operation mnemonic cannot be empty");4    return dialect_name ++ "." ++ mnemonic;5}

1pub fn operationNameFor(comptime OpType: type) []const u8 {2    if (@hasDecl(OpType, "operation_name")) return OpType.operation_name;3    if (@hasDecl(OpType, "operation_spec")) return OpType.operation_spec.name;4    if (nestedOperationSpec(OpType)) |spec| return spec.name;5    @compileError("operation type must declare operation_name, operation_spec, or a nested operation template");6}

1pub fn operationNames(comptime DialectType: type) type {2    return struct {3        pub fn name(comptime mnemonic: []const u8) []const u8 {4            return operationName(DialectType.name, mnemonic);5        }67        pub fn state(comptime OpType: type, loc: Location) Operation.State {8            return Operation.State.init(operationNameFor(OpType), loc);9        }10    };11}

1pub fn operations(comptime DialectType: type) []const OperationSpec {2    const decls = comptime std.meta.declarations(DialectType);3    comptime var count: usize = 0;4    inline for (decls) |decl_name| {5        if (comptime std.mem.eql(u8, decl_name, "spec")) continue;6        const decl_value = @field(DialectType, decl_name);7        if (comptime isDialectOperationValue(decl_value)) count += 1;8    }9    return &operation_spec_storage(DialectType, count).values;10}

1pub fn optionalOperand(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*IrValue {2    return op.getOperand(operandIndex(spec, component_name));3}

1pub fn optionalRegion(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*Region {2    return op.getRegion(regionIndex(spec, component_name));3}

1pub fn optionalResult(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*IrValue {2    return op.getResult(resultIndex(spec, component_name));3}

1pub fn optionalSuccessor(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*Block {2    return op.getSuccessor(successorIndex(spec, component_name));3}

1pub fn region(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) *Region {2    return op.getRegion(regionIndex(spec, component_name)).?;3}

1pub fn regionIndex(comptime spec: OperationSpec, comptime component_name: []const u8) usize {2    return componentIndex(spec.region_names, "region", component_name);3}

1pub fn result(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) *IrValue {2    return op.getResult(resultIndex(spec, component_name)).?;3}

1pub fn resultIndex(comptime spec: OperationSpec, comptime component_name: []const u8) usize {2    return componentIndex(spec.result_names, "result", component_name);3}

1pub fn resultSegmentValue(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?*IrValue {2    const values = resultSegmentValues(spec, op, component_name) orelse return null;3    if (values.len != 1) return null;4    return &values[0];5}

1pub fn resultSegmentValues(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) ?[]IrValue {2    const segment_spec = spec.result_segments orelse @compileError("operation has no result segments: " ++ spec.name);3    const index = comptime resultIndex(spec, component_name);4    const bounds = segmentBounds(segment_spec, op, index) orelse return null;5    if (bounds.offset > op.results.items.len) return null;6    if (bounds.size > op.results.items.len - bounds.offset) return null;7    return op.results.items[bounds.offset .. bounds.offset + bounds.size];8}

1pub fn segmentSizeAttribute(comptime segment_spec: interfaces.OperationSegmentSpec, ctx: *Context, sizes: []const usize) !Attribute {2    if (sizes.len != segment_spec.segments.len) return error.OperationSegmentSizeCountMismatch;3    var attrs: [segment_spec.segments.len]Attribute = undefined;4    for (sizes, 0..) |size, index| {5        if (!segment_spec.segments[index].allows(size)) return error.OperationSegmentSizeOutOfRange;6        const value = std.math.cast(i64, size) orelse return error.OperationSegmentSizeOverflow;7        attrs[index] = try ctx.getI64Attr(value);8    }9    return ctx.getArrayAttr(attrs[0..]);10}

1pub fn setOperandSegmentSizes(comptime spec: OperationSpec, op: *Operation, sizes: []const usize) !void {2    const segment_spec = spec.operand_segments orelse @compileError("operation has no operand segments: " ++ spec.name);3    try setSegmentSizes(segment_spec, op, sizes);4}

1pub fn setResultSegmentSizes(comptime spec: OperationSpec, op: *Operation, sizes: []const usize) !void {2    const segment_spec = spec.result_segments orelse @compileError("operation has no result segments: " ++ spec.name);3    try setSegmentSizes(segment_spec, op, sizes);4}

1pub fn setSegmentSizes(comptime segment_spec: interfaces.OperationSegmentSpec, op: *Operation, sizes: []const usize) !void {2    try op.setAttr(segment_spec.attribute_name, try segmentSizeAttribute(segment_spec, op.getContext(), sizes));3}

1pub fn successor(comptime spec: OperationSpec, op: *Operation, comptime component_name: []const u8) *Block {2    return op.getSuccessor(successorIndex(spec, component_name)).?;3}

1pub fn successorIndex(comptime spec: OperationSpec, comptime component_name: []const u8) usize {2    return componentIndex(spec.successor_names, "successor", component_name);3}

1pub fn trait(comptime Trait: type) OperationTraitSpec {2    return .{3        .id = Trait.id,4        .entry = Trait.entry(),5        .traits = if (@hasDecl(Trait, "traits")) Trait.traits else .{},6    };7}

1pub fn typeName(name: []const u8) TypeSpec {2    return .{ .name = name };3}

1pub fn typeNames(comptime Names: type) []const TypeSpec {2    const decls = comptime std.meta.declarations(Names);3    comptime var count: usize = 0;4    inline for (decls) |decl_name| {5        const decl_value = @field(Names, decl_name);6        if (comptime typeSpecFromValue(decl_value) != null) count += 1;7    }89    const values = comptime blk: {10        var out: [count]TypeSpec = undefined;11        var index: usize = 0;12        for (decls) |decl_name| {13            const decl_value = @field(Names, decl_name);14            if (typeSpecFromValue(decl_value)) |spec| {15                out[index] = spec;16                index += 1;17            }18        }19        break :blk out;20    };21    return &values;22}

1const spec = @import("spec.zig");23pub const registry = @import("registry.zig");4pub const DialectLoaderFn = registry.DialectLoaderFn;5pub const DialectExtensionFn = registry.DialectExtensionFn;6pub const DialectRegistryEntry = registry.DialectRegistryEntry;7pub const DialectRegistrySpec = registry.DialectRegistrySpec;8pub const OpInterfaceFallbackFn = registry.OpInterfaceFallbackFn;9pub const OpInterfaceFallbackEntry = registry.OpInterfaceFallbackEntry;10pub const TypeInterfaceFallbackFn = registry.TypeInterfaceFallbackFn;11pub const TypeInterfaceFallbackEntry = registry.TypeInterfaceFallbackEntry;12pub const DialectLoadState = registry.DialectLoadState;13pub const Dialect = registry.Dialect;14pub const DialectRegistry = registry.DialectRegistry;1516pub const OperationTraitSpec = spec.OperationTraitSpec;17pub const AttributeStorage = spec.AttributeStorage;18pub const AttributeSpec = spec.AttributeSpec;19pub const OperationSpec = spec.OperationSpec;20pub const operand = spec.operand;21pub const optionalOperand = spec.optionalOperand;22pub const result = spec.result;23pub const optionalResult = spec.optionalResult;24pub const region = spec.region;25pub const optionalRegion = spec.optionalRegion;26pub const successor = spec.successor;27pub const optionalSuccessor = spec.optionalSuccessor;28pub const setOperandSegmentSizes = spec.setOperandSegmentSizes;29pub const setResultSegmentSizes = spec.setResultSegmentSizes;30pub const setSegmentSizes = spec.setSegmentSizes;31pub const segmentSizeAttribute = spec.segmentSizeAttribute;32pub const operandSegmentValues = spec.operandSegmentValues;33pub const operandSegmentValue = spec.operandSegmentValue;34pub const resultSegmentValues = spec.resultSegmentValues;35pub const resultSegmentValue = spec.resultSegmentValue;36pub const operandIndex = spec.operandIndex;37pub const resultIndex = spec.resultIndex;38pub const regionIndex = spec.regionIndex;39pub const successorIndex = spec.successorIndex;40pub const attribute = spec.attribute;41pub const TypeSpec = spec.TypeSpec;42pub const DialectSpec = spec.DialectSpec;43pub const DialectSpecOptions = spec.DialectSpecOptions;44pub const dialectSpec = spec.dialectSpec;45pub const operationName = spec.operationName;46pub const shape = spec.shape;47pub const segments = spec.segments;48pub const opSpec = spec.opSpec;49pub const typeConstraint = spec.typeConstraint;50pub const operationAttribute = spec.operationAttribute;51pub const operationDialectAttributeName = spec.operationDialectAttributeName;52pub const operationTemplate = spec.operationTemplate;53pub const operationNames = spec.operationNames;54pub const operationNameFor = spec.operationNameFor;55pub const trait = spec.trait;56pub const operation = spec.operation;57pub const operations = spec.operations;58pub const typeName = spec.typeName;59pub const typeNames = spec.typeNames;60pub const loadDialectSpec = spec.loadDialectSpec;

1pub const dialects = @import("dialects/root.zig");