tiny.choir.bytecode

1pub const AttrKind = enum(u8) {2    dialect = 0,3    integer = 1,4    float_ = 2,5    bool_ = 3,6    string = 4,7    type_list = 5,8    string_list = 6,9    symbol_ref = 7,10    array = 8,11};

1pub const BuiltinScalarKind = enum(u8) {2    index = 0,3    bool_ = 1,4    integer = 2,5    float_ = 3,6};

1pub const ContainerHeader = struct {2    version: u32,3    endianness: u8,4    ptr_size: u8,5    flags: u16,6    section_table_offset: u64,7    section_count: u64,8    file_hash: u64,910    pub fn compatibility(self: ContainerHeader) FormatCompatibility {11        return classifyFormatVersion(self.version);12    }13};

1pub const DecodedModule = struct {2    module: *ir.Operation,3    tables: DecodedTables,4    resources: []const Resource = &.{},56    pub fn format(self: *const DecodedModule) FormatCompatibility {7        return self.tables.format;8    }910    pub fn deinit(self: *DecodedModule) void {11        freeResources(self.tables.allocator, self.resources);12        self.tables.deinit();13    }14};

1pub const DecodedTables = struct {2    allocator: std.mem.Allocator,3    format: FormatCompatibility,4    strings: []const []const u8,5    dialects: []const DialectEntry,6    types: []const ir.Type,7    attrs: []const ir.Attribute,8    locs: []const ir.Location,9    loc_slices: std.ArrayList([]const ir.Location),1011    pub fn deinit(self: *DecodedTables) void {12        for (self.loc_slices.items) |slice| {13            self.allocator.free(@constCast(slice));14        }15        self.loc_slices.deinit(self.allocator);1617        for (self.strings) |str| {18            self.allocator.free(@constCast(str));19        }20        self.allocator.free(self.strings);21        self.allocator.free(self.dialects);22        self.allocator.free(self.types);23        self.allocator.free(self.attrs);24        self.allocator.free(self.locs);25    }26};

1pub const DialectEntry = struct {2    name: []const u8,3    version: u32,4    flags: u32,56    pub fn usesDefaultVersion(self: DialectEntry) bool {7        return self.version == default_dialect_version and self.flags == default_dialect_flags;8    }9};

1pub const FlatModuleDecoder = struct {2    allocator: std.mem.Allocator,3    tables: DecodedTables,4    resources: []const Resource,5    decoder: ModuleDecoder,6    reader: SliceReader,7    module_name: []const u8,8    module_location: ir.Location,9    operations_remaining: usize,10    value_base: usize = 0,11    current: ?*ir.Operation = null,1213    pub fn init(14        allocator: std.mem.Allocator,15        ctx: *ir.Context,16        bytes: []const u8,17    ) !FlatModuleDecoder {18        const sections = try parseSections(bytes);19        const module_bytes = sections.module orelse return error.MissingModule;2021        var tables = try decodeTablesFromSections(allocator, ctx, sections);22        errdefer tables.deinit();2324        const resources = try decodeResourcesSection(allocator, sections.resources);25        errdefer freeResources(allocator, resources);2627        var decoder = ModuleDecoder.init(allocator, ctx, &tables);28        errdefer decoder.deinit();2930        var reader = SliceReader.init(module_bytes);31        const envelope = try decodeFlatModuleEnvelope(&decoder, &reader);32        return .{33            .allocator = allocator,34            .tables = tables,35            .resources = resources,36            .decoder = decoder,37            .reader = reader,38            .module_name = envelope.name,39            .module_location = envelope.location,40            .operations_remaining = envelope.operation_count,41        };42    }4344    pub fn deinit(self: *FlatModuleDecoder) void {45        self.releaseCurrent();46        self.decoder.deinit();47        freeResources(self.allocator, self.resources);48        self.tables.deinit();49        self.* = undefined;50    }5152    pub fn format(self: *const FlatModuleDecoder) FormatCompatibility {53        return self.tables.format;54    }5556    pub fn name(self: *const FlatModuleDecoder) []const u8 {57        return self.module_name;58    }5960    pub fn location(self: *const FlatModuleDecoder) ir.Location {61        return self.module_location;62    }6364    pub fn next(self: *FlatModuleDecoder) !?*ir.Operation {65        self.releaseCurrent();66        if (self.operations_remaining == 0) {67            if (self.reader.offset != self.reader.bytes.len) {68                return error.InvalidModule;69            }70            return null;71        }72        self.decoder.value_base = self.value_base;73        const op = try decodeOperation(74            &self.decoder,75            &self.reader,76            null,77            null,78        );79        self.current = op;80        self.operations_remaining -= 1;81        return op;82    }8384    fn releaseCurrent(self: *FlatModuleDecoder) void {85        const op = self.current orelse return;86        op.erase();87        self.value_base = std.math.add(88            usize,89            self.value_base,90            self.decoder.values.items.len,91        ) catch unreachable;92        self.decoder.values.clearRetainingCapacity();93        self.current = null;94    }95};

1pub const FormatCompatibility = struct {2    version: u32,3    minimum_readable: u32 = minimum_readable_version,4    maximum_readable: u32 = maximum_readable_version,5    status: FormatVersionStatus,67    pub fn readable(self: FormatCompatibility) bool {8        return self.status == .readable;9    }10};

1pub const FormatVersionStatus = enum {2    readable,3    unsupported_older,4    unsupported_newer,5};

1pub const LocationKind = enum(u8) {2    unknown = 0,3    file = 1,4    name = 2,5    fused = 3,6    call_site = 4,7    file_range = 5,8};

1pub const ParsedSections = struct {2    header: ContainerHeader,3    strings: ?[]const u8,4    dialects: ?[]const u8,5    types: ?[]const u8,6    attrs: ?[]const u8,7    locs: ?[]const u8,8    module: ?[]const u8,9    resources: ?[]const u8,10};

1pub const Resource = struct {2    namespace: []const u8,3    name: []const u8,4    type_id: []const u8,5    data: []const u8,6};

1pub const SectionKind = enum(u32) {2    strings = 1,3    dialects = 2,4    types = 3,5    attributes = 4,6    locations = 5,7    module = 6,8    resources = 7,9};

1pub const SliceReader = struct {2    bytes: []const u8,3    offset: usize,45    pub fn init(bytes: []const u8) SliceReader {6        return .{ .bytes = bytes, .offset = 0 };7    }89    pub fn readByte(self: *SliceReader) !u8 {10        if (self.offset >= self.bytes.len) return error.EndOfStream;11        const value = self.bytes[self.offset];12        self.offset += 1;13        return value;14    }1516    pub fn readBytes(self: *SliceReader, len: usize) ![]const u8 {17        if (len > self.bytes.len - self.offset) return error.EndOfStream;18        const end = self.offset + len;19        const slice = self.bytes[self.offset..end];20        self.offset = end;21        return slice;22    }2324    pub fn readBytesWithLen(self: *SliceReader) ![]const u8 {25        const len = try self.readULEBToUsize();26        return self.readBytes(len);27    }2829    pub fn readU16(self: *SliceReader) !u16 {30        const slice = try self.readBytes(2);31        var buf: [2]u8 = undefined;32        std.mem.copyForwards(u8, buf[0..], slice);33        return std.mem.readInt(u16, &buf, .little);34    }3536    pub fn readU32(self: *SliceReader) !u32 {37        const slice = try self.readBytes(4);38        var buf: [4]u8 = undefined;39        std.mem.copyForwards(u8, buf[0..], slice);40        return std.mem.readInt(u32, &buf, .little);41    }4243    pub fn readU64(self: *SliceReader) !u64 {44        const slice = try self.readBytes(8);45        var buf: [8]u8 = undefined;46        std.mem.copyForwards(u8, buf[0..], slice);47        return std.mem.readInt(u64, &buf, .little);48    }4950    pub fn readULEB(self: *SliceReader) !u64 {51        var result: u64 = 0;52        var shift: u8 = 0;53        while (true) {54            const byte = try self.readByte();55            const payload = byte & 0x7f;56            if (shift == 63) {57                if (payload > 1) return error.InvalidLEB128;58                result |= @as(u64, payload) << 63;59            } else {60                const bit_shift: u6 = @intCast(shift);61                result |= @as(u64, payload) << bit_shift;62            }63            if ((byte & 0x80) == 0) return result;64            if (shift >= 63) return error.InvalidLEB128;65            shift += 7;66        }67    }6869    pub fn readSLEB(self: *SliceReader) !i64 {70        var result: u64 = 0;71        var shift: u8 = 0;72        while (true) {73            const byte = try self.readByte();74            const payload = byte & 0x7f;75            if (shift == 63) {76                if (payload == 0x7f) {77                    result |= @as(u64, 1) << 63;78                } else if (payload != 0) {79                    return error.InvalidLEB128;80                }81            } else {82                const bit_shift: u6 = @intCast(shift);83                result |= @as(u64, payload) << bit_shift;84            }85            if ((byte & 0x80) == 0) {86                const used = shift + 7;87                if (used < 64 and (byte & 0x40) != 0) {88                    const sign_shift: u6 = @intCast(used);89                    result |= @as(u64, std.math.maxInt(u64)) << sign_shift;90                }91                return @bitCast(result);92            }93            if (shift >= 63) return error.InvalidLEB128;94            shift += 7;95        }96    }9798    pub fn readULEBToU32(self: *SliceReader) !u32 {99        const value = try self.readULEB();100        if (value > std.math.maxInt(u32)) return error.InvalidTable;101        return @intCast(value);102    }103104    pub fn readULEBToUsize(self: *SliceReader) !usize {105        const value = try self.readULEB();106        if (value > std.math.maxInt(usize)) return error.InvalidTable;107        return @intCast(value);108    }109110    pub fn readTypeList(111        self: *SliceReader,112        allocator: std.mem.Allocator,113        count: usize,114        types: []const ir.Type,115    ) ![]ir.Type {116        const list = try allocator.alloc(ir.Type, count);117        errdefer allocator.free(list);118        var i: usize = 0;119        while (i < count) : (i += 1) {120            const type_id = try self.readULEBToUsize();121            if (type_id >= types.len) return error.InvalidTable;122            list[i] = types[type_id];123        }124        return list;125    }126};

1pub const TableBuilder = struct {2    allocator: std.mem.Allocator,3    strings: StringTable,4    dialects: DialectTable,5    types: std.ArrayList(ir.Type),6    attrs: std.ArrayList(ir.Attribute),7    locs: std.ArrayList(ir.Location),89    pub fn init(allocator: std.mem.Allocator) TableBuilder {10        return .{11            .allocator = allocator,12            .strings = StringTable.init(allocator),13            .dialects = DialectTable.init(allocator),14            .types = .empty,15            .attrs = .empty,16            .locs = .empty,17        };18    }1920    pub fn deinit(self: *TableBuilder) void {21        self.locs.deinit(self.allocator);22        self.attrs.deinit(self.allocator);23        self.types.deinit(self.allocator);24        self.dialects.deinit(self.allocator);25        self.strings.deinit();26    }2728    pub fn internString(self: *TableBuilder, value: []const u8) !u32 {29        return self.strings.intern(value);30    }3132    pub fn internDialect(self: *TableBuilder, name: []const u8) !u32 {33        const name_id = try self.internString(name);34        return self.dialects.intern(self.allocator, name_id);35    }3637    pub fn internType(self: *TableBuilder, typ: ir.Type) !u32 {38        if (findTypeIndex(self.types.items, typ)) |id| return id;39        const storage = typ.getDialectStorage() orelse return error.UnsupportedType;40        const dialect = dialectNamespace(storage.name);41        if (dialect.len > 0) {42            _ = try self.internDialect(dialect);43            const type_name = dialectTypeName(storage.name);44            _ = try self.internString(type_name);45        } else {46            _ = try self.internDialect(storage.name);47        }48        if (storage.param_key.len > 0) {49            _ = try self.internString(storage.param_key);50        }5152        try self.types.append(self.allocator, typ);53        return @intCast(self.types.items.len - 1);54    }5556    pub fn internAttribute(self: *TableBuilder, attr: ir.Attribute) !u32 {57        if (findAttrIndex(self.attrs.items, attr)) |id| return id;58        if (attr.abstract.name.len == 0) return error.UnsupportedAttribute;5960        const dialect = dialectNamespace(attr.abstract.name);61        if (dialect.len > 0) {62            _ = try self.internDialect(dialect);63        }64        const attr_name = dialectTypeName(attr.abstract.name);65        _ = try self.internString(attr_name);6667        const is_typed = std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.integer) or68            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.float_) or69            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.bool_) or70            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.string) or71            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.symbol_ref) or72            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.string_list) or73            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.type_list) or74            std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.array);75        if (!is_typed) {76            _ = attr.cast(ir.Attribute.DialectAttr) orelse return error.UnsupportedAttribute;77        }78        if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.type_list)) {79            const type_list_attr = attr.cast(ir.Attribute.TypeListAttr) orelse return error.UnsupportedAttribute;80            for (type_list_attr.values) |typ| {81                _ = try self.internType(typ);82            }83        }84        if (std.mem.eql(u8, attr.abstract.name, ir.builtin_attr_names.array)) {85            const array_attr = attr.cast(ir.Attribute.ArrayAttr) orelse return error.UnsupportedAttribute;86            for (array_attr.values) |child| {87                _ = try self.internAttribute(child);88            }89        }9091        try self.attrs.append(self.allocator, attr);92        return @intCast(self.attrs.items.len - 1);93    }9495    pub fn internLocation(self: *TableBuilder, loc: ir.Location) !u32 {96        if (findLocationIndex(self.locs.items, loc)) |id| return id;9798        switch (loc) {99            .unknown => {},100            .file => |file_loc| {101                _ = try self.internString(file_loc.filename);102            },103            .file_range => |file_range| {104                _ = try self.internString(file_range.filename);105            },106            .name => |name_loc| {107                _ = try self.internString(name_loc.name);108                if (name_loc.child) |child| {109                    _ = try self.internLocation(child.*);110                }111            },112            .fused => |fused| {113                for (fused.locations) |child_loc| {114                    _ = try self.internLocation(child_loc);115                }116            },117            .call_site => |call_site| {118                _ = try self.internLocation(call_site.callee.*);119                _ = try self.internLocation(call_site.caller.*);120            },121        }122123        try self.locs.append(self.allocator, loc);124        return @intCast(self.locs.items.len - 1);125    }126};

1pub const TypeKind = enum(u8) {2    dialect = 0,3    builtin_scalar = 1,4    dialect_only = 2,5};

1pub fn classifyFormatVersion(version: u32) FormatCompatibility {2    return .{3        .version = version,4        .status = if (version < minimum_readable_version)5            .unsupported_older6        else if (version > maximum_readable_version)7            .unsupported_newer8        else9            .readable,10    };11}

1pub fn decodeModule(allocator: std.mem.Allocator, ctx: *ir.Context, bytes: []const u8) !DecodedModule {2    const sections = try parseSections(bytes);3    const module_bytes = sections.module orelse return error.MissingModule;45    var tables = try decodeTablesFromSections(allocator, ctx, sections);6    errdefer tables.deinit();78    const resources = try decodeResourcesSection(allocator, sections.resources);9    errdefer freeResources(allocator, resources);1011    const module_op = try decodeModuleSection(allocator, ctx, module_bytes, &tables);12    return .{13        .module = module_op,14        .tables = tables,15        .resources = resources,16    };17}

1pub fn decodeTables(allocator: std.mem.Allocator, ctx: *ir.Context, bytes: []const u8) !DecodedTables {2    const sections = try parseSections(bytes);3    return decodeTablesFromSections(allocator, ctx, sections);4}

1pub const default_dialect_flags: u32 = 0;

1pub const default_dialect_version: u32 = 0;

1pub fn encodeModule(allocator: std.mem.Allocator, module: *ir.Operation) ![]u8 {2    return encodeModuleWithResources(allocator, module, &.{});3}

1pub fn encodeModuleWithResources(2    allocator: std.mem.Allocator,3    module: *ir.Operation,4    resources: []const Resource,5) ![]u8 {6    var builder = TableBuilder.init(allocator);7    defer builder.deinit();89    _ = try builder.internLocation(ir.Location.getUnknown());10    try collectOperationTables(&builder, module);1112    var sections: std.ArrayList(SectionData) = .empty;13    defer {14        for (sections.items) |section| {15            allocator.free(@constCast(section.data));16        }17        sections.deinit(allocator);18    }1920    try appendOwnedSection(21        allocator,22        &sections,23        @backingInt(SectionKind.strings),24        try encodeStringsSection(allocator, &builder),25    );2627    try appendOwnedSection(28        allocator,29        &sections,30        @backingInt(SectionKind.dialects),31        try encodeDialectsSection(allocator, &builder),32    );3334    try appendOwnedSection(35        allocator,36        &sections,37        @backingInt(SectionKind.types),38        try encodeTypesSection(allocator, &builder),39    );4041    try appendOwnedSection(42        allocator,43        &sections,44        @backingInt(SectionKind.attributes),45        try encodeAttributesSection(allocator, &builder),46    );4748    try appendOwnedSection(49        allocator,50        &sections,51        @backingInt(SectionKind.locations),52        try encodeLocationsSection(allocator, &builder),53    );5455    try appendOwnedSection(56        allocator,57        &sections,58        @backingInt(SectionKind.module),59        try encodeModuleSection(allocator, &builder, module),60    );6162    if (resources.len != 0) {63        try appendOwnedSection(64            allocator,65            &sections,66            @backingInt(SectionKind.resources),67            try encodeResourcesSection(allocator, resources),68        );69    }7071    return try writeContainer(allocator, sections.items);72}

1pub fn encodeTables(allocator: std.mem.Allocator, builder: *TableBuilder) ![]u8 {2    var sections: std.ArrayList(SectionData) = .empty;3    defer {4        for (sections.items) |section| {5            allocator.free(@constCast(section.data));6        }7        sections.deinit(allocator);8    }910    const strings_data = try encodeStringsSection(allocator, builder);11    try sections.append(allocator, .{ .kind = @backingInt(SectionKind.strings), .flags = 0, .data = strings_data });1213    const dialects_data = try encodeDialectsSection(allocator, builder);14    try sections.append(allocator, .{ .kind = @backingInt(SectionKind.dialects), .flags = 0, .data = dialects_data });1516    const types_data = try encodeTypesSection(allocator, builder);17    try sections.append(allocator, .{ .kind = @backingInt(SectionKind.types), .flags = 0, .data = types_data });1819    const attrs_data = try encodeAttributesSection(allocator, builder);20    try sections.append(allocator, .{ .kind = @backingInt(SectionKind.attributes), .flags = 0, .data = attrs_data });2122    const locs_data = try encodeLocationsSection(allocator, builder);23    try sections.append(allocator, .{ .kind = @backingInt(SectionKind.locations), .flags = 0, .data = locs_data });2425    return try writeContainer(allocator, sections.items);26}

1pub const format_version: u32 = 12;

1pub fn inspectHeader(bytes: []const u8) !ContainerHeader {2    var reader = SliceReader.init(bytes);3    return readHeader(&reader);4}

1pub fn parseSections(bytes: []const u8) !ParsedSections {2    var header_reader = SliceReader.init(bytes);3    const header = try readHeader(&header_reader);45    if (!header.compatibility().readable()) return error.UnsupportedVersion;6    if (header.endianness != current_endianness) return error.UnsupportedEndianness;78    const bytes_len_u64: u64 = @intCast(bytes.len);9    const section_table_size = std.math.mul(10        u64,11        header.section_count,12        sectionEntrySize(),13    ) catch return error.InvalidSectionTable;14    const section_table_end = std.math.add(15        u64,16        header.section_table_offset,17        section_table_size,18    ) catch return error.InvalidSectionTable;19    if (section_table_end > bytes_len_u64) return error.InvalidSectionTable;2021    var sections = ParsedSections{22        .header = header,23        .strings = null,24        .dialects = null,25        .types = null,26        .attrs = null,27        .locs = null,28        .module = null,29        .resources = null,30    };3132    const table_offset: usize = @intCast(header.section_table_offset);33    var table_reader = SliceReader.init(bytes[table_offset..]);34    var i: u64 = 0;35    while (i < header.section_count) : (i += 1) {36        const kind_raw = try table_reader.readU32();37        const flags = try table_reader.readU32();38        const offset = try table_reader.readU64();39        const size = try table_reader.readU64();40        _ = flags;4142        const end_u64 = std.math.add(43            u64,44            offset,45            size,46        ) catch return error.InvalidSection;47        if (end_u64 > bytes_len_u64) return error.InvalidSection;48        const start: usize = @intCast(offset);49        const end: usize = @intCast(end_u64);50        const slice = bytes[start..end];5152        switch (kind_raw) {53            @backingInt(SectionKind.strings) => {54                if (sections.strings != null) return error.DuplicateSection;55                sections.strings = slice;56            },57            @backingInt(SectionKind.dialects) => {58                if (sections.dialects != null) return error.DuplicateSection;59                sections.dialects = slice;60            },61            @backingInt(SectionKind.types) => {62                if (sections.types != null) return error.DuplicateSection;63                sections.types = slice;64            },65            @backingInt(SectionKind.attributes) => {66                if (sections.attrs != null) return error.DuplicateSection;67                sections.attrs = slice;68            },69            @backingInt(SectionKind.locations) => {70                if (sections.locs != null) return error.DuplicateSection;71                sections.locs = slice;72            },73            @backingInt(SectionKind.module) => {74                if (sections.module != null) return error.DuplicateSection;75                sections.module = slice;76            },77            @backingInt(SectionKind.resources) => {78                if (sections.resources != null) return error.DuplicateSection;79                sections.resources = slice;80            },81            else => {},82        }83    }8485    return sections;86}

1const bytecode = @import("bytecode.zig");2pub const qualification = @import("qualification.zig");3pub const image = @import("image.zig");4pub const Reader = bytecode.SliceReader;5pub const ContainerSections = bytecode.ParsedSections;6pub const inspectSections = bytecode.parseSections;7pub const TypeKind = bytecode.TypeKind;8pub const BuiltinScalarKind = bytecode.BuiltinScalarKind;9pub const AttrKind = bytecode.AttrKind;10pub const LocationKind = bytecode.LocationKind;1112pub const format_version = bytecode.format_version;13pub const minimum_readable_version = bytecode.minimum_readable_version;14pub const maximum_readable_version = bytecode.maximum_readable_version;15pub const default_dialect_version = bytecode.default_dialect_version;16pub const default_dialect_flags = bytecode.default_dialect_flags;17pub const FormatVersionStatus = bytecode.FormatVersionStatus;18pub const FormatCompatibility = bytecode.FormatCompatibility;19pub const ContainerHeader = bytecode.ContainerHeader;20pub const SectionKind = bytecode.SectionKind;21pub const DialectEntry = bytecode.DialectEntry;22pub const Resource = bytecode.Resource;23pub const DecodedTables = bytecode.DecodedTables;24pub const DecodedModule = bytecode.DecodedModule;25pub const FlatModuleDecoder = bytecode.FlatModuleDecoder;26pub const TableBuilder = bytecode.TableBuilder;27pub const classifyFormatVersion = bytecode.classifyFormatVersion;28pub const inspectHeader = bytecode.inspectHeader;29pub const encodeTables = bytecode.encodeTables;30pub const encodeModule = bytecode.encodeModule;31pub const encodeModuleWithResources = bytecode.encodeModuleWithResources;32pub const decodeTables = bytecode.decodeTables;33pub const decodeModule = bytecode.decodeModule;

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