tiny.choir.dialects.scf.ScfDialect

1pub const ScfDialect = struct {2    pub const name = "scf";3    const op_templates = ir.dialects.operationTemplate.dialect(@This());4    pub const spec = ir.dialects.dialectSpec(@This(), .{5        .op_interface_fallbacks = &.{6            .{ .id = ir.interfaces.Evaluatable.id, .fallback = ScfEval.fallback },7        },8    });910    pub const VerifyError = error{11        ScfIfMissingCondition,12        ScfIfMissingThenRegion,13        ScfIfMissingThenBlock,14        ScfIfMissingElseRegion,15        ScfIfMultipleBlocks,16        ScfIfYieldMissing,17        ScfIfYieldNotTerminal,18        ScfIfYieldArityMismatch,19        ScfIfYieldTypeMismatch,20        ScfForMissingBounds,21        ScfForRegionArityMismatch,22        ScfForMissingBody,23        ScfForMultipleBlocks,24        ScfForBlockArgCountMismatch,25        ScfForResultArityMismatch,26        ScfForBoundsTypeMismatch,27        ScfForInductionTypeMismatch,28        ScfForIterArgTypeMismatch,29        ScfForResultTypeMismatch,30        ScfForYieldMissing,31        ScfForYieldNotTerminal,32        ScfForYieldArityMismatch,33        ScfForYieldTypeMismatch,34        ScfForMultipleYields,35    };3637    const yield_vtable = ir.interfaces.YieldOpInterface.VTable{38        .getYieldOperandCount = getYieldOperandCount,39        .getYieldOperand = getYieldOperand,40    };4142    const ScfEval = struct {43        const arith = @import("arith/root.zig");4445        fn canEval(op_ptr: *const anyopaque) bool {46            const op: *const ir.Operation = @ptrCast(@alignCast(op_ptr));47            if (std.mem.eql(u8, op.name.name, ForOp.operation_name)) {48                return forInductionBits(op) != null;49            }50            return std.mem.eql(u8, op.name.name, IfOp.operation_name) or51                std.mem.eql(u8, op.name.name, WhileOp.operation_name) or52                std.mem.eql(u8, op.name.name, ConditionOp.operation_name) or53                std.mem.eql(u8, op.name.name, YieldOp.operation_name);54        }5556        /// The x64 guard and increment explicitly distinguish native 32/64-bit homes.57        fn forInductionBits(op: *const ir.Operation) ?u8 {58            if (op.operands.items.len < 3) return null;59            const typ = op.operands.items[0].value.type;60            if (!typ.eql(op.operands.items[1].value.type) or61                !typ.eql(op.operands.items[2].value.type)) return null;62            return switch (arith.scalarKindFromType(typ) orelse return null) {63                .index, .i64, .u64 => 64,64                .i32, .u32 => 32,65                else => null,66            };67        }6869        fn arrayValues(attr: ir.Attribute) ?[]const ir.Attribute {70            const array_attr = attr.cast(ir.Attribute.ArrayAttr) orelse return null;71            return array_attr.getValues();72        }7374        fn boolValue(attr: ir.Attribute) ?bool {75            const bool_attr = attr.cast(ir.Attribute.BoolAttr) orelse return null;76            return bool_attr.getValue();77        }7879        fn makeArray(ctx: *ir.Context, values: []const ir.Attribute) ir.interfaces.EvalError!ir.Attribute {80            return ctx.getArrayAttr(values) catch error.OutOfMemory;81        }8283        fn makeResults(ctx: *ir.Context, values: []const ir.Attribute, count: usize) ir.interfaces.EvalError!ir.Attribute {84            if (values.len != count) return error.InvalidOperand;85            if (count == 1) return values[0];86            return makeArray(ctx, values);87        }8889        fn evaluateIf(90            op: *const ir.Operation,91            operands: []const ir.Attribute,92            eval_ctx: *const ir.interfaces.EvalContext,93        ) ir.interfaces.EvalError!ir.Attribute {94            if (operands.len != 1) return error.InvalidOperand;95            const if_op = IfOp{ .op = @constCast(op) };96            const take_then = boolValue(operands[0]) orelse return error.InvalidOperand;97            try eval_ctx.consumeBranchFuel(eval_ctx.state);9899            const selected = if (take_then)100                if_op.getThenRegion()101            else102                if_op.getElseRegion() orelse {103                    if (op.results.items.len == 0) return makeArray(op.getContext(), &.{});104                    return error.InvalidOperand;105                };106107            const branch_attr = try eval_ctx.evaluateRegion(eval_ctx.state, selected);108            if (arrayValues(branch_attr)) |values| {109                return makeResults(op.getContext(), values, op.results.items.len);110            }111            return makeResults(op.getContext(), &.{branch_attr}, op.results.items.len);112        }113114        /// Each signed guard, including the exit guard, consumes both fuel budgets.115        /// Yield replaces the carried tuple before the wrapping induction increment.116        fn evaluateFor(117            op: *const ir.Operation,118            operands: []const ir.Attribute,119            eval_ctx: *const ir.interfaces.EvalContext,120        ) ir.interfaces.EvalError!ir.Attribute {121            const bits = forInductionBits(op) orelse return error.UnsupportedOperation;122            verifyForOpInternal(@constCast(op)) catch return error.InvalidOperand;123            std.debug.assert(operands.len == op.operands.items.len);124            const body = @constCast(op).getRegion(0) orelse return error.InvalidOperand;125            const lower = operands[0].cast(ir.Attribute.IntegerAttr) orelse return error.InvalidOperand;126            const upper = operands[1].cast(ir.Attribute.IntegerAttr) orelse return error.InvalidOperand;127            const step = operands[2].cast(ir.Attribute.IntegerAttr) orelse return error.InvalidOperand;128            var induction = arith.scalar.truncate(lower.getValue(), bits);129            const bound = arith.scalar.truncate(upper.getValue(), bits);130            const stride = step.getValue();131            const current = eval_ctx.allocator.alloc(ir.Attribute, operands.len - 2) catch return error.OutOfMemory;132            defer eval_ctx.allocator.free(current);133            const carried = current[1..];134            std.debug.assert(carried.len == op.results.items.len);135            @memcpy(carried, operands[3..]);136137            while (true) {138                try eval_ctx.consumeIterationFuel(eval_ctx.state);139                try eval_ctx.consumeBranchFuel(eval_ctx.state);140                if (induction >= bound) return makeResults(op.getContext(), carried, carried.len);141                current[0] = op.getContext().getI64Attr(induction) catch return error.OutOfMemory;142                const result = try eval_ctx.evaluateRegionWithArgs(eval_ctx.state, body, current);143                const yielded = arrayValues(result) orelse return error.InvalidOperand;144                if (yielded.len != carried.len) return error.InvalidOperand;145                @memcpy(carried, yielded);146                induction = arith.scalar.addWrap(induction, stride, bits);147            }148        }149150        fn evaluateWhile(151            op: *const ir.Operation,152            operands: []const ir.Attribute,153            eval_ctx: *const ir.interfaces.EvalContext,154        ) ir.interfaces.EvalError!ir.Attribute {155            const while_op = WhileOp{ .op = @constCast(op) };156            const result_count = op.results.items.len;157            if (result_count != operands.len) return error.InvalidOperand;158159            const current = eval_ctx.allocator.alloc(ir.Attribute, operands.len) catch return error.OutOfMemory;160            defer eval_ctx.allocator.free(current);161            @memcpy(current, operands);162163            while (true) {164                try eval_ctx.consumeIterationFuel(eval_ctx.state);165                const condition_attr = try eval_ctx.evaluateRegionWithArgs(eval_ctx.state, while_op.getBeforeRegion(), current);166                const condition_values = arrayValues(condition_attr) orelse return error.InvalidOperand;167                if (condition_values.len != operands.len + 1) return error.InvalidOperand;168                const keep_going = boolValue(condition_values[0]) orelse return error.InvalidOperand;169                const carried = condition_values[1..];170                if (!keep_going) return makeResults(op.getContext(), carried, result_count);171172                const yield_attr = try eval_ctx.evaluateRegionWithArgs(eval_ctx.state, while_op.getAfterRegion(), carried);173                const yielded = arrayValues(yield_attr) orelse return error.InvalidOperand;174                if (yielded.len != operands.len) return error.InvalidOperand;175                @memcpy(current, yielded);176            }177        }178179        fn evaluate(180            op_ptr: *const anyopaque,181            operands: []const ir.Attribute,182            eval_ctx: *const ir.interfaces.EvalContext,183        ) ir.interfaces.EvalError!ir.Attribute {184            const op: *const ir.Operation = @ptrCast(@alignCast(op_ptr));185            if (std.mem.eql(u8, op.name.name, IfOp.operation_name)) {186                return evaluateIf(op, operands, eval_ctx);187            }188            if (std.mem.eql(u8, op.name.name, ForOp.operation_name)) {189                return evaluateFor(op, operands, eval_ctx);190            }191            if (std.mem.eql(u8, op.name.name, WhileOp.operation_name)) {192                return evaluateWhile(op, operands, eval_ctx);193            }194            if (std.mem.eql(u8, op.name.name, ConditionOp.operation_name)) {195                if (operands.len == 0) return error.InvalidOperand;196                return makeArray(op.getContext(), operands);197            }198            if (std.mem.eql(u8, op.name.name, YieldOp.operation_name)) {199                return makeArray(op.getContext(), operands);200            }201            return error.UnsupportedOperation;202        }203204        const vtable = ir.interfaces.Evaluatable.VTable{205            .canEval = canEval,206            .evaluate = evaluate,207        };208209        fn fallback(_: *const ir.Operation) ?*const anyopaque {210            return &vtable;211        }212    };213214    pub const IfOp = struct {215        op: *ir.Operation,216217        const def = op_templates.explicit(@This(), .{218            .mnemonic = "if",219            .interfaces = &.{effects.EffectOpInterface.entryFor(.{220                .capacity = .{ .entries = 1, .per_region = 1, .per_result = 1 },221                .enumerate = conditionalEffects,222            })},223            .operands = .{"condition"},224            .regions = ir.dialects.shape.atLeast(1),225            .region_names = .{ "then", "else" },226            .successors = 0,227            .operand_types = &.{ir.dialects.typeConstraint.exact(0, "arith.bool")},228            .dynamic_traits = .{229                ir.traits.AtLeastNRegions(1),230                ir.traits.SingleBlock,231            },232        });233        pub const operation_spec = def.operation_spec;234        pub const operation_name = def.operation_name;235        pub const createOperation = def.createOperation;236        pub const getOperand = def.getOperand;237        pub const getRegion = def.getRegion;238        pub const verify = verifyIfOp;239        pub const verifyRegions = verifyIfOpRegions;240241        pub fn create(242            ctx: *ir.Context,243            loc: ir.Location,244            condition: *ir.Value,245            result_types: []const ir.Type,246        ) !IfOp {247            try loadSpec(ctx);248            var then_body = ir.context.initRegion(ctx);249            defer then_body.deinit();250            var then_builder = ir.OperationBuilder.init(ctx);251            _ = try then_builder.createBlock(&then_body, &.{}, &.{});252            var else_body = ir.context.initRegion(ctx);253            defer else_body.deinit();254            var else_builder = ir.OperationBuilder.init(ctx);255            _ = try else_builder.createBlock(&else_body, &.{}, &.{});256            var regions = [_]*ir.Region{ &then_body, &else_body };257            return try @This().createOperation(ctx, loc, &.{condition}, result_types, &regions, &.{});258        }259260        pub fn createWithoutElse(261            ctx: *ir.Context,262            loc: ir.Location,263            condition: *ir.Value,264        ) !IfOp {265            try loadSpec(ctx);266            var then_body = ir.context.initRegion(ctx);267            defer then_body.deinit();268            var then_builder = ir.OperationBuilder.init(ctx);269            _ = try then_builder.createBlock(&then_body, &.{}, &.{});270            var regions = [_]*ir.Region{&then_body};271            return try @This().createOperation(ctx, loc, &.{condition}, &.{}, &regions, &.{});272        }273274        pub fn getCondition(self: IfOp) *ir.Value {275            return self.getOperand("condition");276        }277278        pub fn getThenRegion(self: IfOp) *ir.Region {279            return self.getRegion("then");280        }281282        pub fn getThenBlock(self: IfOp) *ir.Block {283            return self.getThenRegion().getEntryBlock().?;284        }285286        pub fn getElseRegion(self: IfOp) ?*ir.Region {287            return self.op.getRegion(1);288        }289290        pub fn getElseBlock(self: IfOp) ?*ir.Block {291            if (self.getElseRegion()) |region| {292                return region.getEntryBlock();293            }294            return null;295        }296297        pub fn getResult(self: *const IfOp, index: usize) ?*ir.Value {298            return self.op.getResult(index);299        }300301        pub fn getNumResults(self: IfOp) usize {302            return self.op.results.items.len;303        }304    };305306    pub const ForOp = struct {307        op: *ir.Operation,308309        const def = op_templates.explicit(@This(), .{310            .mnemonic = "for",311            .interfaces = &.{effects.EffectOpInterface.entryFor(.{312                .capacity = .{ .entries = 1, .per_region = 1, .per_result = 1 },313                .enumerate = loopEffects,314            })},315            .operands = ir.dialects.shape.atLeast(3),316            .operand_names = .{ "lower_bound", "upper_bound", "step" },317            .regions = .{"body"},318            .successors = 0,319            .dynamic_traits = .{ ir.traits.OneRegion, ir.traits.SingleBlock },320        });321        pub const operation_spec = def.operation_spec;322        pub const operation_name = def.operation_name;323        pub const createOperation = def.createOperation;324        pub const getOperand = def.getOperand;325        pub const getRegion = def.getRegion;326        pub const verify = verifyForOp;327        pub const verifyRegions = verifyForOpRegions;328329        pub fn create(330            ctx: *ir.Context,331            loc: ir.Location,332            lower_bound: *ir.Value,333            upper_bound: *ir.Value,334            step: *ir.Value,335            init_args: []const *ir.Value,336            result_types: []const ir.Type,337        ) !ForOp {338            try loadSpec(ctx);339            var operands: std.ArrayList(*ir.Value) = .empty;340            const allocator = ir.context.transientAllocator(ctx);341            defer operands.deinit(allocator);342            try operands.append(allocator, lower_bound);343            try operands.append(allocator, upper_bound);344            try operands.append(allocator, step);345            for (init_args) |arg| {346                try operands.append(allocator, arg);347            }348            var body = ir.context.initRegion(ctx);349            defer body.deinit();350            var body_builder = ir.OperationBuilder.init(ctx);351            const body_block = try body_builder.createBlock(&body, &.{}, &.{});352353            _ = try body_block.addArgument(lower_bound.type, loc);354355            for (init_args) |init_arg| {356                _ = try body_block.addArgument(init_arg.type, loc);357            }358            var regions = [_]*ir.Region{&body};359            return try @This().createOperation(ctx, loc, operands.items, result_types, &regions, &.{});360        }361362        pub fn getLowerBound(self: ForOp) *ir.Value {363            return self.getOperand("lower_bound");364        }365366        pub fn getUpperBound(self: ForOp) *ir.Value {367            return self.getOperand("upper_bound");368        }369370        pub fn getStep(self: ForOp) *ir.Value {371            return self.getOperand("step");372        }373374        pub fn getInitArgs(self: ForOp) []const *ir.Value {375            return self.op.getOperandValues()[3..];376        }377378        pub fn getBodyRegion(self: ForOp) *ir.Region {379            return self.getRegion("body");380        }381382        pub fn getBodyBlock(self: ForOp) *ir.Block {383            return self.getBodyRegion().getEntryBlock().?;384        }385386        pub fn getInductionVar(self: ForOp) *ir.Value {387            return self.getBodyBlock().arguments.items[0];388        }389390        pub fn getIterArgs(self: ForOp) []*ir.Value {391            return self.getBodyBlock().arguments.items[1..];392        }393394        pub fn getResult(self: *const ForOp, index: usize) ?*ir.Value {395            return self.op.getResult(index);396        }397    };398399    pub const WhileOp = struct {400        op: *ir.Operation,401402        const def = op_templates.explicit(@This(), .{403            .mnemonic = "while",404            .interfaces = &.{effects.EffectOpInterface.entryFor(.{405                .capacity = .{ .entries = 1, .per_region = 1, .per_result = 1 },406                .enumerate = loopEffects,407            })},408            .regions = 2,409            .region_names = .{ "before", "after" },410            .successors = 0,411            .dynamic_traits = .{ir.traits.SingleBlock},412        });413        pub const operation_spec = def.operation_spec;414        pub const operation_name = def.operation_name;415        pub const createOperation = def.createOperation;416        pub const getRegion = def.getRegion;417418        pub fn create(419            ctx: *ir.Context,420            loc: ir.Location,421            init_args: []const *ir.Value,422            result_types: []const ir.Type,423        ) !WhileOp {424            try loadSpec(ctx);425            var operands: std.ArrayList(*ir.Value) = .empty;426            const allocator = ir.context.transientAllocator(ctx);427            defer operands.deinit(allocator);428            for (init_args) |arg| {429                try operands.append(allocator, arg);430            }431432            var before_body = ir.context.initRegion(ctx);433            defer before_body.deinit();434            var before_builder = ir.OperationBuilder.init(ctx);435            const before_block = try before_builder.createBlock(&before_body, &.{}, &.{});436            for (init_args) |init_arg| {437                _ = try before_block.addArgument(init_arg.type, loc);438            }439440            var after_body = ir.context.initRegion(ctx);441            defer after_body.deinit();442            var after_builder = ir.OperationBuilder.init(ctx);443            const after_block = try after_builder.createBlock(&after_body, &.{}, &.{});444            for (init_args) |init_arg| {445                _ = try after_block.addArgument(init_arg.type, loc);446            }447            var regions = [_]*ir.Region{ &before_body, &after_body };448            return try @This().createOperation(ctx, loc, operands.items, result_types, &regions, &.{});449        }450451        pub fn getBeforeRegion(self: WhileOp) *ir.Region {452            return self.getRegion("before");453        }454455        pub fn getAfterRegion(self: WhileOp) *ir.Region {456            return self.getRegion("after");457        }458459        pub fn getBeforeBlock(self: WhileOp) *ir.Block {460            return self.getBeforeRegion().getEntryBlock().?;461        }462463        pub fn getAfterBlock(self: WhileOp) *ir.Block {464            return self.getAfterRegion().getEntryBlock().?;465        }466    };467468    pub const YieldOp = struct {469        op: *ir.Operation,470471        const term = op_templates.explicitTerminator(@This(), .{472            .mnemonic = "yield",473            .interfaces = &.{474                ir.interfaces.YieldOpInterface.entry(&yield_vtable),475                effects.EffectOpInterface.entryFor(.{}),476            },477        });478        pub const operation_spec = term.operation_spec;479        pub const operation_name = term.operation_name;480        pub const createTerminator = term.createTerminator;481482        pub fn create(483            ctx: *ir.Context,484            loc: ir.Location,485            results: []const *ir.Value,486        ) !YieldOp {487            try loadSpec(ctx);488            return try @This().createTerminator(ctx, loc, results, &.{});489        }490491        pub fn getOperands(self: YieldOp) []const *ir.Value {492            return self.op.getOperandValues();493        }494    };495496    pub const ConditionOp = struct {497        op: *ir.Operation,498499        const term = op_templates.explicitTerminator(@This(), .{500            .mnemonic = "condition",501            .interfaces = &.{effects.EffectOpInterface.entryFor(.{})},502            .operands = ir.dialects.shape.atLeast(1),503            .operand_names = .{"condition"},504            .operand_types = &.{ir.dialects.typeConstraint.exact(0, "arith.bool")},505        });506        pub const operation_spec = term.operation_spec;507        pub const operation_name = term.operation_name;508        pub const createTerminator = term.createTerminator;509        pub const getOperand = term.getOperand;510511        pub fn create(512            ctx: *ir.Context,513            loc: ir.Location,514            condition: *ir.Value,515            args: []const *ir.Value,516        ) !ConditionOp {517            try loadSpec(ctx);518            var operands: std.ArrayList(*ir.Value) = .empty;519            const allocator = ir.context.transientAllocator(ctx);520            defer operands.deinit(allocator);521            try operands.append(allocator, condition);522            for (args) |arg| {523                try operands.append(allocator, arg);524            }525            return try @This().createTerminator(ctx, loc, operands.items, &.{});526        }527528        pub fn getCondition(self: ConditionOp) *ir.Value {529            return self.getOperand("condition");530        }531532        pub fn getArgs(self: ConditionOp) []const *ir.Value {533            return self.op.getOperandValues()[1..];534        }535    };536537    fn loadSpec(ctx: *ir.Context) !void {538        try ir.dialects.loadDialectSpec(ctx, spec);539    }540541    fn getYieldOperandCount(op_ptr: *const anyopaque) usize {542        const op: *const ir.Operation = @ptrCast(@alignCast(op_ptr));543        return op.getOperandValues().len;544    }545546    fn getYieldOperand(op_ptr: *const anyopaque, index: usize) ?*ir.Value {547        const op: *const ir.Operation = @ptrCast(@alignCast(op_ptr));548        return op.getOperand(index);549    }550551    fn verifyForOp(op_ptr: *const anyopaque) anyerror!void {552        const op: *ir.Operation = @ptrCast(@alignCast(@constCast(op_ptr)));553        if (op.operands.items.len < 3) return error.ScfForMissingBounds;554        if (op.regions.items.len != 1) return error.ScfForRegionArityMismatch;555    }556557    fn verifyIfOp(op_ptr: *const anyopaque) anyerror!void {558        const op: *ir.Operation = @ptrCast(@alignCast(@constCast(op_ptr)));559        if (op.operands.items.len != 1) return error.ScfIfMissingCondition;560        if (op.regions.items.len < 1) return error.ScfIfMissingThenRegion;561        if (op.results.items.len > 0 and op.regions.items.len < 2) return error.ScfIfMissingElseRegion;562    }563564    fn verifyForOpRegions(op_ptr: *const anyopaque) anyerror!void {565        const op: *ir.Operation = @ptrCast(@alignCast(@constCast(op_ptr)));566        try verifyForOpInternal(op);567    }568569    fn verifyIfOpRegions(op_ptr: *const anyopaque) anyerror!void {570        const op: *ir.Operation = @ptrCast(@alignCast(@constCast(op_ptr)));571        try verifyIfOpInternal(op);572    }573574    fn verifyIfOpInternal(op: *ir.Operation) VerifyError!void {575        if (op.operands.items.len != 1) return error.ScfIfMissingCondition;576        if (op.regions.items.len < 1) return error.ScfIfMissingThenRegion;577578        const result_count = op.results.items.len;579        if (result_count == 0) return;580        if (op.regions.items.len < 2) return error.ScfIfMissingElseRegion;581582        try verifyIfYield(op, op.getRegion(0) orelse return error.ScfIfMissingThenRegion);583        try verifyIfYield(op, op.getRegion(1) orelse return error.ScfIfMissingElseRegion);584    }585586    fn verifyIfYield(op: *ir.Operation, region: *ir.Region) VerifyError!void {587        const block = region.getEntryBlock() orelse return error.ScfIfMissingThenBlock;588        if (!region.hasOneBlock()) return error.ScfIfMultipleBlocks;589590        var yield_op: ?*ir.Operation = null;591        var op_iter = block.operations.head;592        while (op_iter) |opaque_op| {593            const current: *ir.Operation = @ptrCast(@alignCast(opaque_op));594            if (std.mem.eql(u8, current.name.name, YieldOp.operation_name)) {595                if (current.next_op != null) return error.ScfIfYieldNotTerminal;596                yield_op = current;597            }598            op_iter = current.next_op;599        }600601        const yield_final = yield_op orelse return error.ScfIfYieldMissing;602        if (yield_final.operands.items.len != op.results.items.len) return error.ScfIfYieldArityMismatch;603604        for (op.results.items, 0..) |result, index| {605            const yield_type = yield_final.operands.items[index].value.type;606            if (!result.type.eql(yield_type)) return error.ScfIfYieldTypeMismatch;607        }608    }609610    fn verifyForOpInternal(op: *ir.Operation) VerifyError!void {611        if (op.operands.items.len < 3) return error.ScfForMissingBounds;612        if (op.regions.items.len != 1) return error.ScfForRegionArityMismatch;613614        const body_region = op.getRegion(0) orelse return error.ScfForMissingBody;615        const body_block = body_region.getEntryBlock() orelse return error.ScfForMissingBody;616        if (!body_region.hasOneBlock()) return error.ScfForMultipleBlocks;617618        const iter_count = op.operands.items.len - 3;619        if (op.results.items.len != iter_count) return error.ScfForResultArityMismatch;620        if (body_block.arguments.items.len != iter_count + 1) return error.ScfForBlockArgCountMismatch;621622        const lower_type = op.operands.items[0].value.type;623        const upper_type = op.operands.items[1].value.type;624        const step_type = op.operands.items[2].value.type;625        if (!lower_type.eql(upper_type) or !lower_type.eql(step_type)) {626            return error.ScfForBoundsTypeMismatch;627        }628        if (!body_block.arguments.items[0].type.eql(lower_type)) {629            return error.ScfForInductionTypeMismatch;630        }631632        var yield_op: ?*ir.Operation = null;633        var op_iter = body_block.operations.head;634        while (op_iter) |opaque_op| {635            const current: *ir.Operation = @ptrCast(@alignCast(opaque_op));636            if (std.mem.eql(u8, current.name.name, YieldOp.operation_name)) {637                if (yield_op != null) return error.ScfForMultipleYields;638                if (current.next_op != null) return error.ScfForYieldNotTerminal;639                yield_op = current;640            }641            op_iter = current.next_op;642        }643644        const yield_final = yield_op orelse return error.ScfForYieldMissing;645        if (yield_final.operands.items.len != iter_count) return error.ScfForYieldArityMismatch;646647        for (0..iter_count) |i| {648            const init_type = op.operands.items[3 + i].value.type;649            const block_type = body_block.arguments.items[1 + i].type;650            if (!init_type.eql(block_type)) return error.ScfForIterArgTypeMismatch;651            const result_type = op.results.items[i].type;652            if (!init_type.eql(result_type)) return error.ScfForResultTypeMismatch;653            const yield_type = yield_final.operands.items[i].value.type;654            if (!init_type.eql(yield_type)) return error.ScfForYieldTypeMismatch;655        }656    }657};