tiny.choir.Operation

1pub const Operation = struct {2    allocator: std.mem.Allocator,34    storage: operation_storage.Storage,56    operand_storage: ?operation_storage.Handle,78    context: *Context,910    name: OperationName,1112    location: Location,1314    operands: operation_storage.List(OpOperand),1516    operand_values: []*Value,1718    results: operation_storage.List(Value),1920    result_types: []const Type,2122    raw_dictionary_attrs: NamedAttributeList,2324    properties: PropertyStorage,2526    regions: operation_storage.List(Region),2728    successors: operation_storage.List(*Block),2930    parent_block: ?*Block,3132    prev_op: ?*Operation,33    next_op: ?*Operation,3435    order: u32,36    lifecycle_state: LifecycleState,3738    tracking_prev: ?*Operation,39    tracking_next: ?*Operation,4041    pub const WalkOrder = enum {42        pre_order,43        post_order,44    };4546    pub const WalkResult = enum {47        advance,48        skip,49        interrupt,5051        pub fn wasSkipped(self: WalkResult) bool {52            return self == .skip;53        }5455        pub fn wasInterrupted(self: WalkResult) bool {56            return self == .interrupt;57        }58    };5960    pub const WalkOptions = struct {61        order: WalkOrder = .post_order,62    };6364    pub const PropertyRef: type = operation_properties.Ref;65    pub const PropertyStorage: type = operation_properties.Storage(Operation);66    pub const StoragePlan: type = operation_storage.Plan(67        Operation,68        *Value,69        Type,70        OpOperand,71        Value,72        Region,73        *Block,74    );75    const leaf_property_storage_capacity = StoragePlan.Capacity.derive(.{76        .operands = 0,77        .results = 1,78        .regions = 0,79        .successors = 0,80        .properties = @sizeOf(?Attribute),81        .properties_alignment = .fromByteUnits(@alignOf(?Attribute)),82    }) catch unreachable;83    const nullary_storage_capacity = StoragePlan.Capacity.derive(.{84        .operands = 0,85        .results = 1,86        .regions = 0,87        .successors = 0,88        .properties = 0,89        .properties_alignment = .@"1",90    }) catch unreachable;91    const unary_storage_capacity = StoragePlan.Capacity.derive(.{92        .operands = 1,93        .results = 1,94        .regions = 0,95        .successors = 0,96        .properties = 0,97        .properties_alignment = .@"1",98    }) catch unreachable;99    const binary_storage_capacity = StoragePlan.Capacity.derive(.{100        .operands = 2,101        .results = 1,102        .regions = 0,103        .successors = 0,104        .properties = 0,105        .properties_alignment = .@"1",106    }) catch unreachable;107    pub const StorageAllocator: type = operation_storage.PoolAllocator(108        leaf_property_storage_capacity,109        binary_storage_capacity,110        nullary_storage_capacity,111        unary_storage_capacity,112    );113    pub const OperationName: type = operation_name.OperationName;114    pub const CloneOptions = struct {115        clone_operands: bool = true,116    };117    pub const State: type = operation_state.State(Operation);118    const lifecycle = operation_lifecycle.Methods(Operation);119    pub const create = lifecycle.create;120    pub const cloneWithoutRegions = lifecycle.cloneWithoutRegions;121    pub const cloneWithoutRegionsMapped = lifecycle.cloneWithoutRegionsMapped;122    pub const clone = lifecycle.clone;123    pub const dropAllReferences = lifecycle.dropAllReferences;124    pub const hasNoDefinedValueUses = lifecycle.hasNoDefinedValueUses;125    pub const dropAllDefinedValueUses = lifecycle.dropAllDefinedValueUses;126    pub const removeFromBlock = lifecycle.removeFromBlock;127    pub const moveBefore = lifecycle.moveBefore;128    pub const moveToEnd = lifecycle.moveToEnd;129    pub const replaceOperands = lifecycle.replaceOperands;130    pub const deinit = lifecycle.deinit;131    pub const destroy = lifecycle.destroy;132    pub const setOperandValue = lifecycle.setOperandValue;133    pub const setSuccessors = lifecycle.setSuccessors;134    pub const erase = lifecycle.erase;135    const registered = operation_registered.Methods(Operation);136    pub const getRegisteredInfo = registered.getRegisteredInfo;137    pub const getInherentAttributeNames = registered.getInherentAttributeNames;138    pub const hasInherentAttributeName = registered.hasInherentAttributeName;139    pub const isDiscardableAttrName = registered.isDiscardableAttrName;140    pub const isRegistered = registered.isRegistered;141    pub const getInterface = registered.getInterface;142    pub const interface_handle = registered.InterfaceHandle;143    pub const interface = registered.interface;144    pub const hasInterface = registered.hasInterface;145    pub const getTraits = registered.getTraits;146    pub const hasTrait = registered.hasTrait;147    pub const hasTraitId = registered.hasTraitId;148    pub const hasTraitName = registered.hasTraitName;149    const attributes = operation_attributes.Methods(Operation);150    pub const AttributeIterator: type = attributes.AttributeIterator;151    pub const DiscardableAttrIterator: type = attributes.DiscardableAttrIterator;152    pub const SetDiscardableAttrError: type = attributes.SetDiscardableAttrError;153    pub const getAttrs = attributes.getAttrs;154    pub const getNumAttrs = attributes.getNumAttrs;155    pub const getRawDictionaryAttrs = attributes.getRawDictionaryAttrs;156    pub const getDiscardableAttrs = attributes.getDiscardableAttrs;157    pub const countDiscardableAttrs = attributes.countDiscardableAttrs;158    pub const getDiscardableAttr = attributes.getDiscardableAttr;159    pub const getDiscardableAttrAs = attributes.getDiscardableAttrAs;160    pub const setDiscardableAttr = attributes.setDiscardableAttr;161    pub const removeDiscardableAttr = attributes.removeDiscardableAttr;162    pub const getAttr = attributes.getAttr;163    pub const getAttrAs = attributes.getAttrAs;164    pub const setAttr = attributes.setAttr;165    pub const removeAttr = attributes.removeAttr;166    pub const getPropertiesAsAttr = attributes.getPropertiesAsAttr;167    pub const getPropertiesRef = attributes.getPropertiesRef;168    pub const setPropertiesFromAttr = attributes.setPropertiesFromAttr;169    pub const copyProperties = attributes.copyProperties;170171    pub fn walk(172        self: *Operation,173        options: WalkOptions,174        context: anytype,175        callback: anytype,176    ) anyerror!WalkResult {177        return walkOperation(self, options, context, callback);178    }179180    fn walkOperation(181        op: *Operation,182        options: WalkOptions,183        context: anytype,184        callback: anytype,185    ) anyerror!WalkResult {186        if (options.order == .pre_order) {187            const result = try invokeWalkCallback(context, callback, op);188            if (result.wasInterrupted()) return .interrupt;189            if (result.wasSkipped()) return .advance;190        }191192        for (op.regions.items) |*region| {193            const result = try region.walkOperations(options, context, callback);194            if (result.wasInterrupted()) return .interrupt;195        }196197        if (options.order == .post_order) {198            return try invokeWalkCallback(context, callback, op);199        }200201        return .advance;202    }203204    fn invokeWalkCallback(context: anytype, callback: anytype, op: *Operation) anyerror!WalkResult {205        const result = callback(context, op);206        return try normalizeWalkResult(result);207    }208209    fn normalizeWalkResult(result: anytype) anyerror!WalkResult {210        const Result = @TypeOf(result);211        return switch (@typeInfo(Result)) {212            .error_union => |info| blk: {213                const payload = try result;214                if (info.payload == void) break :blk .advance;215                break :blk payload;216            },217            .void => .advance,218            else => result,219        };220    }221222    pub fn getName(self: Operation) OperationName {223        return self.name;224    }225226    pub fn getLoc(self: Operation) Location {227        return self.location;228    }229230    pub fn createdBefore(self: Operation, boundary: u31) bool {231        return self.lifecycle_state.creation_id < boundary;232    }233234    pub fn setCreationId(self: *Operation, creation_id: u31) void {235        self.lifecycle_state.creation_id = creation_id;236    }237238    pub fn getNumOperands(self: Operation) usize {239        return self.operands.items.len;240    }241242    pub fn getOperand(self: Operation, index: usize) ?*Value {243        if (index >= self.operand_values.len) return null;244        return self.operand_values[index];245    }246247    pub fn getOpOperand(self: *Operation, index: usize) ?*OpOperand {248        if (index >= self.operands.items.len) return null;249        return &self.operands.items[index];250    }251252    pub fn getNumResults(self: Operation) usize {253        return self.result_types.len;254    }255256    pub fn getResult(self: *Operation, index: usize) ?*Value {257        if (index >= self.results.items.len) return null;258        return &self.results.items[index];259    }260261    pub fn getOperandValues(self: Operation) []const *Value {262        return self.operand_values;263    }264265    pub fn getResultTypes(self: Operation) []const Type {266        return self.result_types;267    }268269    pub fn getNumRegions(self: Operation) usize {270        return self.regions.items.len;271    }272273    pub fn getRegion(self: *Operation, index: usize) ?*Region {274        if (index >= self.regions.items.len) return null;275        return &self.regions.items[index];276    }277278    pub fn getNumSuccessors(self: Operation) usize {279        return self.successors.items.len;280    }281282    pub fn getSuccessor(self: Operation, index: usize) ?*Block {283        if (index >= self.successors.items.len) return null;284        return self.successors.items[index];285    }286287    pub fn getBlock(self: Operation) ?*Block {288        return self.parent_block;289    }290291    pub fn getParentRegion(self: *const Operation) ?*Region {292        const block = self.parent_block orelse return null;293        return block.getParentRegion();294    }295296    pub fn getParentOp(self: *const Operation) ?*Operation {297        const region = self.getParentRegion() orelse return null;298        return region.getParentOperation();299    }300301    pub fn isProperAncestor(self: *const Operation, other: *const Operation) bool {302        var current = other.getParentOp();303        while (current) |op| {304            if (op == self) return true;305            current = op.getParentOp();306        }307        return false;308    }309310    pub fn isAncestor(self: *const Operation, other: *const Operation) bool {311        return self == other or self.isProperAncestor(other);312    }313314    pub fn isBeforeInBlock(self: *const Operation, other: *const Operation) bool {315        const block = self.parent_block orelse return false;316        if (other.parent_block != block) return false;317        if (self == other) return false;318319        return block.operationPrecedes(self, other);320    }321322    pub fn getContext(self: *const Operation) *Context {323        return self.context;324    }325326    pub fn emitDiagnostic(327        self: *Operation,328        severity: diagnostics.Severity,329        message: []const u8,330    ) Context.InFlightDiagnostic {331        return self.context.emitDiagnostic(diagnostics.operationDiagnostic(self, severity, message));332    }333334    pub fn emitError(self: *Operation, message: []const u8) Context.InFlightDiagnostic {335        return self.emitDiagnostic(.err, message);336    }337338    pub fn emitWarning(self: *Operation, message: []const u8) Context.InFlightDiagnostic {339        return self.emitDiagnostic(.warning, message);340    }341342    pub fn emitRemark(self: *Operation, message: []const u8) Context.InFlightDiagnostic {343        return self.emitDiagnostic(.remark, message);344    }345346    pub fn emitOpError(self: *Operation, message: []const u8) !Context.InFlightDiagnostic {347        const full_message = try std.fmt.allocPrint(348            context_mod.diagnosticPayloadAllocator(self.context),349            "'{s}' op {s}",350            .{ self.name.name, message },351        );352        var diagnostic = self.emitError(full_message);353        diagnostic.ownMessage(full_message);354        return diagnostic;355    }356357    pub fn hasNoUses(self: Operation) bool {358        for (self.results.items) |result| {359            if (!result.hasNoUses()) {360                return false;361            }362        }363        return true;364    }365366    pub fn hasOneUse(self: Operation) bool {367        if (self.results.items.len == 0) return false;368        for (self.results.items) |result| {369            if (!result.hasOneUse()) {370                return false;371            }372        }373        return true;374    }375376    pub fn format(self: Operation, writer: *std.Io.Writer) std.Io.Writer.Error!void {377        if (self.results.items.len > 0) {378            for (self.results.items, 0..) |result, i| {379                if (i > 0) try writer.writeAll(", ");380                try writer.print("{f}", .{result});381            }382            try writer.writeAll(" = ");383        }384385        try writer.print("{f}", .{self.name});386387        if (self.operands.items.len > 0) {388            try writer.writeAll("(");389            for (self.operands.items, 0..) |operand, i| {390                if (i > 0) try writer.writeAll(", ");391                try writer.print("{f}", .{operand.value.*});392            }393            try writer.writeAll(")");394        } else {395            try writer.writeAll("()");396        }397398        try self.formatAttrs(writer);399400        if (self.results.items.len > 0) {401            try writer.writeAll(" : ");402            for (self.results.items, 0..) |result, i| {403                if (i > 0) try writer.writeAll(", ");404                try writer.print("{f}", .{result.type});405            }406        }407408        for (self.regions.items) |region| {409            try writer.writeAll(" ");410            try writer.print("{f}", .{region});411        }412    }413414    fn formatAttrs(self: *const Operation, writer: *std.Io.Writer) std.Io.Writer.Error!void {415        var attrs = self.getAttrs();416        var first = true;417        while (attrs.next()) |attr| {418            try formatAttr(writer, &first, attr);419        }420421        if (!first) try writer.writeAll("}");422    }423424    fn formatAttr(425        writer: *std.Io.Writer,426        first: *bool,427        attr: NamedAttribute,428    ) std.Io.Writer.Error!void {429        if (first.*) {430            try writer.writeAll(" {");431            first.* = false;432        } else {433            try writer.writeAll(", ");434        }435        try writer.print("{f}", .{attr});436    }437};

1pub const Operation = ir.Operation;