tiny.choir.Region

1pub const Region = struct {2    allocator: std.mem.Allocator,34    blocks: BlockList,56    parent: ?*anyopaque,78    pub const BlockList = struct {9        head: ?*Block,10        tail: ?*Block,11        size: usize,1213        pub fn init() BlockList {14            return .{15                .head = null,16                .tail = null,17                .size = 0,18            };19        }2021        pub fn isEmpty(self: BlockList) bool {22            return self.head == null;23        }2425        pub fn front(self: BlockList) ?*Block {26            return self.head;27        }2829        pub fn back(self: BlockList) ?*Block {30            return self.tail;31        }32    };3334    pub const BlockIterator = struct {35        current: ?*Block,3637        pub fn next(self: *BlockIterator) ?*Block {38            const block = self.current;39            if (self.current) |b| {40                self.current = b.next;41            }42            return block;43        }44    };4546    pub fn init(allocator: std.mem.Allocator) Region {47        return .{48            .allocator = allocator,49            .blocks = BlockList.init(),50            .parent = null,51        };52    }5354    pub fn deinit(self: *Region) void {55        var current = self.blocks.head;56        while (current) |block| {57            const next = block.next;58            block.deinit();59            self.allocator.destroy(block);60            current = next;61        }62    }6364    pub fn takeBody(self: *Region, source: *Region) !void {65        if (self == source) return;66        if (!source.empty() and !sameAllocator(self.allocator, source.allocator)) {67            return error.RegionAllocatorMismatch;68        }6970        self.deinit();71        self.blocks = source.blocks;72        source.blocks = BlockList.init();7374        var current = self.blocks.head;75        while (current) |block| {76            block.parent = self;77            current = block.next;78        }79    }8081    pub fn dropAllReferences(self: *Region) void {82        var blocks = self.getBlocks();83        while (blocks.next()) |block| {84            block.dropAllReferences();85        }86    }8788    pub fn hasNoDefinedValueUses(self: *Region) bool {89        var blocks = self.getBlocks();90        while (blocks.next()) |block| {91            if (!block.hasNoDefinedValueUses()) return false;92        }93        return true;94    }9596    pub fn dropAllDefinedValueUses(self: *Region) void {97        var blocks = self.getBlocks();98        while (blocks.next()) |block| {99            block.dropAllDefinedValueUses();100        }101    }102103    pub fn walkOperations(104        self: *Region,105        options: @import("operation/root.zig").Operation.WalkOptions,106        context: anytype,107        callback: anytype,108    ) anyerror!@import("operation/root.zig").Operation.WalkResult {109        var blocks = self.getBlocks();110        while (blocks.next()) |block| {111            const result = try block.walkOperations(options, context, callback);112            if (result.wasInterrupted()) return .interrupt;113        }114        return .advance;115    }116117    pub fn cloneInto(self: *Region, dest: *Region, mapping: *Mapping) anyerror!void {118        if (self == dest) return error.RegionCloneIntoSelf;119120        var source_block = self.blocks.head;121        while (source_block) |block| : (source_block = block.next) {122            const cloned_block = try dest.addBlock();123            try mapping.mapBlock(block, cloned_block);124            try cloned_block.arguments.ensureTotalCapacity(cloned_block.allocator, block.arguments.items.len);125            for (block.arguments.items, 0..) |argument, index| {126                const cloned_argument = try cloned_block.addArgument(127                    argument.type,128                    block.getArgumentLocation(index).?,129                );130                try mapping.mapValue(argument, cloned_argument);131            }132        }133134        source_block = self.blocks.head;135        while (source_block) |block| : (source_block = block.next) {136            const cloned_block = mapping.lookupBlock(block).?;137            var ops = block.getOperations();138            while (ops.next()) |op| {139                const cloned_op = try op.cloneWithoutRegionsMapped(mapping, .{ .clone_operands = false });140                try cloned_block.addOperation(cloned_op);141            }142        }143144        source_block = self.blocks.head;145        while (source_block) |block| : (source_block = block.next) {146            const cloned_block = mapping.lookupBlock(block).?;147            var source_ops = block.getOperations();148            var cloned_ops = cloned_block.getOperations();149            while (source_ops.next()) |op| {150                const cloned_op = cloned_ops.next().?;151                try remapOperationBody(op, cloned_op, mapping);152            }153        }154    }155156    pub fn empty(self: Region) bool {157        return self.blocks.isEmpty();158    }159160    pub fn hasOneBlock(self: Region) bool {161        return self.blocks.size == 1;162    }163164    pub fn getEntryBlock(self: Region) ?*Block {165        return self.blocks.front();166    }167168    pub fn addBlock(self: *Region) !*Block {169        const block = try self.allocator.create(Block);170        block.* = Block.init(self.allocator);171        block.parent = self;172        block.id = @intCast(self.blocks.size);173174        block.prev = self.blocks.tail;175        block.next = null;176        if (self.blocks.tail) |tail| {177            tail.next = block;178        } else {179            self.blocks.head = block;180        }181        self.blocks.tail = block;182        self.blocks.size += 1;183184        return block;185    }186187    pub fn pushFront(self: *Region, block: *Block) void {188        block.parent = self;189        block.prev = null;190        block.next = self.blocks.head;191192        if (self.blocks.head) |head| {193            head.prev = block;194        } else {195            self.blocks.tail = block;196        }197        self.blocks.head = block;198        self.blocks.size += 1;199    }200201    pub fn pushBack(self: *Region, block: *Block) void {202        block.parent = self;203        block.prev = self.blocks.tail;204        block.next = null;205206        if (self.blocks.tail) |tail| {207            tail.next = block;208        } else {209            self.blocks.head = block;210        }211        self.blocks.tail = block;212        self.blocks.size += 1;213    }214215    pub fn eraseBlock(self: *Region, block: *Block) bool {216        if (block.parent != @as(*anyopaque, @ptrCast(self))) return false;217        if (!block.hasNoPredecessors()) return false;218219        var op_node = block.operations.tail;220        while (op_node) |node| {221            const op: *@import("operation/root.zig").Operation = @ptrCast(@alignCast(node));222            op_node = op.prev_op;223            op.erase();224        }225        std.debug.assert(block.hasNoDefinedValueUses());226227        const prev = block.prev;228        const next = block.next;229230        if (prev) |prev_block| {231            prev_block.next = next;232        } else {233            self.blocks.head = next;234        }235236        if (next) |next_block| {237            next_block.prev = prev;238        } else {239            self.blocks.tail = prev;240        }241242        block.parent = null;243        block.prev = null;244        block.next = null;245        self.blocks.size -= 1;246247        block.deinit();248        self.allocator.destroy(block);249        return true;250    }251252    pub fn getParentOperation(self: *const Region) ?*@import("operation/root.zig").Operation {253        const parent = self.parent orelse return null;254        return @ptrCast(@alignCast(parent));255    }256257    pub fn getBlocks(self: *Region) BlockIterator {258        return BlockIterator{ .current = self.blocks.head };259    }260261    pub fn format(self: Region, writer: *std.Io.Writer) std.Io.Writer.Error!void {262        try writer.writeAll("{\n");263        var current = self.blocks.head;264        while (current) |block| {265            try writer.print("  {f}\n", .{block.*});266            current = block.next;267        }268        try writer.writeAll("}");269    }270271    fn sameAllocator(a: std.mem.Allocator, b: std.mem.Allocator) bool {272        return a.ptr == b.ptr and a.vtable == b.vtable;273    }274};

1pub const Region = ir.Region;