tiny.chant.lower

1pub const Local = struct {2    kind: LocalKind,3    value: *choir.Value,4    c_type: *const ast.Type,5};

1pub const LocalKind = enum {2    slot,3    pointer_param,4    loop_iv,5};

1pub const Lowerer = struct {2    gpa: std.mem.Allocator,3    arena: std.mem.Allocator,4    ctx: *choir.Context,5    loc: choir.ir.Location,6    block: *choir.Block,7    scopes: std.ArrayListUnmanaged(Scope),8    functions: std.StringHashMapUnmanaged(*const ast.Type),9    terminated: bool,10};

1pub const Error = error{2    OutOfMemory,3    UnsupportedConstruct,4    UnsupportedType,5    UndefinedName,6};

1pub const Unit = struct {2    module: choir.dialects.BuiltinDialect.ModuleOp,3    lowered: std.ArrayListUnmanaged([]const u8),4    skipped: std.ArrayListUnmanaged(Skipped),56    pub const Skipped = struct {7        name: []const u8,8        reason: Error,9    };10};

1pub fn lowerFunction(2    gpa: std.mem.Allocator,3    arena: std.mem.Allocator,4    ctx: *choir.Context,5    module: choir.dialects.BuiltinDialect.ModuleOp,6    functions: std.StringHashMapUnmanaged(*const ast.Type),7    function: ast.decl.Function,8) Error!void {9    const loc = choir.ir.Location.getUnknown();10    const return_type = function.type.child orelse return error.UnsupportedType;11    if (return_type.kind != .void_type) return error.UnsupportedConstruct;12    const body = function.body orelse return error.UnsupportedConstruct;1314    var lowerer = Lowerer{15        .gpa = gpa,16        .arena = arena,17        .ctx = ctx,18        .loc = loc,19        .block = undefined,20        .scopes = .empty,21        .functions = functions,22        .terminated = false,23    };24    defer {25        while (lowerer.scopes.items.len > 0) scope.pop(&lowerer);26        lowerer.scopes.deinit(gpa);27    }2829    var arg_types = std.ArrayListUnmanaged(choir.Type).empty;30    defer arg_types.deinit(gpa);31    for (function.type.params) |param| {32        try arg_types.append(gpa, try convert.valueType(&lowerer, param.type));33    }3435    const func = FuncDialect.FuncOp.create(ctx, loc, function.name, arg_types.items, &.{}) catch return error.OutOfMemory;36    const entry = func.getEntryBlock();37    lowerer.block = entry;3839    var registered = false;40    errdefer if (!registered) func.op.erase();4142    try scope.push(&lowerer);43    for (function.type.params, 0..) |param, i| {44        const argument = func.getArgument(i);45        if (ast.types.isPointerLike(param.type)) {46            const element = try convert.pointerElement(param.type);47            const pointer_c_type = try arena.create(ast.Type);48            pointer_c_type.* = .{ .kind = .pointer, .child = param.type.child };49            _ = element;50            try scope.bind(&lowerer, param.name, .{ .kind = .pointer_param, .value = argument, .c_type = pointer_c_type });51        } else {52            const slot = try memory.allocaScalar(&lowerer, param.type);53            const zero = try emit.indexConstant(&lowerer, 0);54            try memory.storeElement(&lowerer, .{ .memref = slot, .index = zero, .c_type = param.type }, argument);55            try scope.bind(&lowerer, param.name, .{ .kind = .slot, .value = slot, .c_type = param.type });56        }57    }5859    try statement.lowerStatement(&lowerer, body);60    if (!lowerer.terminated) {61        const ret = FuncDialect.ReturnOp.create(ctx, loc, &.{}) catch return error.OutOfMemory;62        try emit.append(&lowerer, ret.op);63    }64    lowerer.terminated = false;6566    module.getBodyBlock().addOperation(func.op) catch return error.OutOfMemory;67    registered = true;68}

1pub fn lowerUnit(2    gpa: std.mem.Allocator,3    arena: std.mem.Allocator,4    ctx: *choir.Context,5    translation: ast.TranslationUnit,6) Error!Unit {7    const loc = choir.ir.Location.getUnknown();8    const module = choir.dialects.BuiltinDialect.ModuleOp.create(ctx, loc) catch return error.OutOfMemory;910    var result = Unit{11        .module = module,12        .lowered = .empty,13        .skipped = .empty,14    };1516    var functions = std.StringHashMapUnmanaged(*const ast.Type).empty;17    defer functions.deinit(gpa);18    for (translation.declarations) |decl| {19        switch (decl) {20            .function => |decl_function| try functions.put(gpa, decl_function.name, decl_function.type),21            .variable => {},22        }23    }2425    for (translation.declarations) |decl| {26        switch (decl) {27            .function => |decl_function| {28                if (decl_function.body == null) continue;29                if (lowerFunction(gpa, arena, ctx, module, functions, decl_function)) |_| {30                    try result.lowered.append(arena, decl_function.name);31                } else |err| switch (err) {32                    error.OutOfMemory => return error.OutOfMemory,33                    else => try result.skipped.append(arena, .{ .name = decl_function.name, .reason = err }),34                }35            },36            .variable => {},37        }38    }39    return result;40}

1const context = @import("context.zig");2const unit_mod = @import("unit.zig");34pub const Error = @import("error.zig").Error;5pub const convert = @import("convert.zig");6pub const emit = @import("emit.zig");7pub const local = @import("local.zig");8pub const memory = @import("memory.zig");9pub const scope = @import("scope.zig");10pub const LocalKind = context.LocalKind;11pub const Local = context.Local;12pub const Lowerer = context.Lowerer;13pub const Unit = unit_mod.Unit;14pub const lowerFunction = unit_mod.lowerFunction;15pub const lowerUnit = unit_mod.lowerUnit;

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