tiny.choir.OperationBuilder

1pub const OperationBuilder = struct {2    ir_ctx: *Context,3    insertion_block: ?*Block,4    insertion_before: ?*Operation,5    listener: ?Listener,67    pub const Listener = struct {8        context: ?*anyopaque = null,9        notify_operation_inserted: ?*const fn (?*anyopaque, *Operation, InsertPoint) anyerror!void = null,10        notify_block_inserted: ?*const fn (?*anyopaque, *Block) anyerror!void = null,1112        pub fn notifyOperationInserted(self: Listener, op: *Operation, previous: InsertPoint) !void {13            if (self.notify_operation_inserted) |notify| {14                try notify(self.context, op, previous);15            }16        }1718        pub fn notifyBlockInserted(self: Listener, block: *Block) !void {19            if (self.notify_block_inserted) |notify| {20                try notify(self.context, block);21            }22        }23    };2425    pub const InsertPoint = struct {26        block: ?*Block = null,27        before: ?*Operation = null,2829        pub fn isSet(self: InsertPoint) bool {30            return self.block != null;31        }32    };3334    pub const InsertionGuard = struct {35        builder: ?*OperationBuilder,36        insert_point: InsertPoint,3738        pub fn init(builder: *OperationBuilder) InsertionGuard {39            return .{40                .builder = builder,41                .insert_point = builder.saveInsertionPoint(),42            };43        }4445        pub fn deinit(self: *InsertionGuard) void {46            const builder = self.builder orelse return;47            builder.restoreInsertionPoint(self.insert_point);48            self.builder = null;49        }50    };5152    pub fn init(ir_ctx: *Context) OperationBuilder {53        return .{54            .ir_ctx = ir_ctx,55            .insertion_block = null,56            .insertion_before = null,57            .listener = null,58        };59    }6061    pub fn setListener(self: *OperationBuilder, listener: ?Listener) void {62        self.listener = listener;63    }6465    pub fn getListener(self: *const OperationBuilder) ?Listener {66        return self.listener;67    }6869    pub fn clearInsertionPoint(self: *OperationBuilder) void {70        self.insertion_block = null;71        self.insertion_before = null;72    }7374    pub fn hasInsertionPoint(self: *const OperationBuilder) bool {75        return self.insertion_block != null;76    }7778    pub fn saveInsertionPoint(self: *const OperationBuilder) InsertPoint {79        return .{80            .block = self.insertion_block,81            .before = self.insertion_before,82        };83    }8485    pub fn restoreInsertionPoint(self: *OperationBuilder, insert_point: InsertPoint) void {86        if (insert_point.isSet()) {87            self.insertion_block = insert_point.block;88            self.insertion_before = insert_point.before;89            return;90        }91        self.clearInsertionPoint();92    }9394    pub fn insertionGuard(self: *OperationBuilder) InsertionGuard {95        return InsertionGuard.init(self);96    }9798    pub fn setInsertionPoint(self: *OperationBuilder, block: *Block) void {99        self.setInsertionPointToEnd(block);100    }101102    pub fn setInsertionPointToEnd(self: *OperationBuilder, block: *Block) void {103        self.insertion_block = block;104        self.insertion_before = null;105    }106107    pub fn setInsertionPointBefore(self: *OperationBuilder, op: *Operation) void {108        self.insertion_block = op.getBlock();109        self.insertion_before = op;110    }111112    pub fn setInsertionPointAfter(self: *OperationBuilder, op: *Operation) void {113        if (op.next_op) |next| {114            self.setInsertionPointBefore(next);115            return;116        }117        if (op.getBlock()) |block| {118            self.setInsertionPointToEnd(block);119            return;120        }121        self.clearInsertionPoint();122    }123124    pub fn getInsertionBlock(self: *const OperationBuilder) ?*Block {125        return self.insertion_block;126    }127128    pub fn getInsertionBefore(self: *const OperationBuilder) ?*Operation {129        return self.insertion_before;130    }131132    pub fn createBlock(self: *OperationBuilder, region: *Region, arg_types: []const Type, locs: []const Location) !*Block {133        if (arg_types.len != locs.len) return error.BlockArgumentLocationMismatch;134135        const previous = self.saveInsertionPoint();136        errdefer self.restoreInsertionPoint(previous);137        const block = try region.addBlock();138        errdefer std.debug.assert(region.eraseBlock(block));139140        for (arg_types, locs) |arg_type, loc| {141            _ = try block.addArgument(arg_type, loc);142        }143144        self.setInsertionPointToEnd(block);145        if (self.listener) |listener| {146            try listener.notifyBlockInserted(block);147        }148        return block;149    }150151    pub fn createBlockWithLoc(self: *OperationBuilder, region: *Region, arg_types: []const Type, loc: Location) !*Block {152        const previous = self.saveInsertionPoint();153        errdefer self.restoreInsertionPoint(previous);154        const block = try region.addBlock();155        errdefer std.debug.assert(region.eraseBlock(block));156157        for (arg_types) |arg_type| {158            _ = try block.addArgument(arg_type, loc);159        }160161        self.setInsertionPointToEnd(block);162        if (self.listener) |listener| {163            try listener.notifyBlockInserted(block);164        }165        return block;166    }167168    pub fn insert(self: *OperationBuilder, op: *Operation) !*Operation {169        var inserted = false;170        if (self.insertion_block) |block| {171            if (self.insertion_before) |before| {172                if (before.getBlock() == block) {173                    try block.insertBefore(op, before);174                } else {175                    try block.addOperation(op);176                }177            } else {178                try block.addOperation(op);179            }180            inserted = true;181        }182183        if (inserted) {184            if (self.listener) |listener| {185                listener.notifyOperationInserted(op, .{}) catch |err| {186                    if (op.getBlock()) |block| block.detachOperation(op);187                    return err;188                };189            }190        }191192        return op;193    }194195    pub fn create(self: *OperationBuilder, state: Operation.State) !*Operation {196        const op = try self.ir_ctx.createOperation(state);197        errdefer if (op.getBlock() == null) op.erase();198        return try self.insert(op);199    }200};

1pub const OperationBuilder = ir.OperationBuilder;