From 28c3d4809bc6d497ac81892bc7eb03b95d8c2b32 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Sat, 14 Jul 2018 16:12:41 -0400 Subject: [PATCH] rename Module to Compilation and CompilationUnit to ObjectFile --- src-self-hosted/codegen.zig | 42 ++- .../{module.zig => compilation.zig} | 128 ++++----- src-self-hosted/decl.zig | 4 +- src-self-hosted/ir.zig | 56 ++-- src-self-hosted/main.zig | 114 ++++---- src-self-hosted/scope.zig | 72 ++--- src-self-hosted/test.zig | 26 +- src-self-hosted/type.zig | 268 +++++++++--------- src-self-hosted/value.zig | 66 ++--- 9 files changed, 387 insertions(+), 389 deletions(-) rename src-self-hosted/{module.zig => compilation.zig} (85%) diff --git a/src-self-hosted/codegen.zig b/src-self-hosted/codegen.zig index df8f451856..a07485e74e 100644 --- a/src-self-hosted/codegen.zig +++ b/src-self-hosted/codegen.zig @@ -1,7 +1,5 @@ const std = @import("std"); -// TODO codegen pretends that Module is renamed to Build because I plan to -// do that refactor at some point -const Build = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; // we go through llvm instead of c for 2 reasons: // 1. to avoid accidentally calling the non-thread-safe functions // 2. patch up some of the types to remove nullability @@ -11,51 +9,51 @@ const Value = @import("value.zig").Value; const Type = @import("type.zig").Type; const event = std.event; -pub async fn renderToLlvm(build: *Build, fn_val: *Value.Fn, code: *ir.Code) !void { +pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code) !void { fn_val.base.ref(); - defer fn_val.base.deref(build); - defer code.destroy(build.a()); + defer fn_val.base.deref(comp); + defer code.destroy(comp.a()); - const llvm_handle = try build.event_loop_local.getAnyLlvmContext(); - defer llvm_handle.release(build.event_loop_local); + const llvm_handle = try comp.event_loop_local.getAnyLlvmContext(); + defer llvm_handle.release(comp.event_loop_local); const context = llvm_handle.node.data; - const module = llvm.ModuleCreateWithNameInContext(build.name.ptr(), context) orelse return error.OutOfMemory; + const module = llvm.ModuleCreateWithNameInContext(comp.name.ptr(), context) orelse return error.OutOfMemory; defer llvm.DisposeModule(module); const builder = llvm.CreateBuilderInContext(context) orelse return error.OutOfMemory; defer llvm.DisposeBuilder(builder); - var cunit = CompilationUnit{ - .build = build, + var ofile = ObjectFile{ + .comp = comp, .module = module, .builder = builder, .context = context, - .lock = event.Lock.init(build.loop), + .lock = event.Lock.init(comp.loop), }; - try renderToLlvmModule(&cunit, fn_val, code); + try renderToLlvmModule(&ofile, fn_val, code); - if (build.verbose_llvm_ir) { - llvm.DumpModule(cunit.module); + if (comp.verbose_llvm_ir) { + llvm.DumpModule(ofile.module); } } -pub const CompilationUnit = struct { - build: *Build, +pub const ObjectFile = struct { + comp: *Compilation, module: llvm.ModuleRef, builder: llvm.BuilderRef, context: llvm.ContextRef, lock: event.Lock, - fn a(self: *CompilationUnit) *std.mem.Allocator { - return self.build.a(); + fn a(self: *ObjectFile) *std.mem.Allocator { + return self.comp.a(); } }; -pub fn renderToLlvmModule(cunit: *CompilationUnit, fn_val: *Value.Fn, code: *ir.Code) !void { +pub fn renderToLlvmModule(ofile: *ObjectFile, fn_val: *Value.Fn, code: *ir.Code) !void { // TODO audit more of codegen.cpp:fn_llvm_value and port more logic - const llvm_fn_type = try fn_val.base.typeof.getLlvmType(cunit); - const llvm_fn = llvm.AddFunction(cunit.module, fn_val.symbol_name.ptr(), llvm_fn_type); + const llvm_fn_type = try fn_val.base.typeof.getLlvmType(ofile); + const llvm_fn = llvm.AddFunction(ofile.module, fn_val.symbol_name.ptr(), llvm_fn_type); } diff --git a/src-self-hosted/module.zig b/src-self-hosted/compilation.zig similarity index 85% rename from src-self-hosted/module.zig rename to src-self-hosted/compilation.zig index 617bd0d44a..cbda7861bc 100644 --- a/src-self-hosted/module.zig +++ b/src-self-hosted/compilation.zig @@ -72,7 +72,7 @@ pub const LlvmHandle = struct { } }; -pub const Module = struct { +pub const Compilation = struct { event_loop_local: *EventLoopLocal, loop: *event.Loop, name: Buffer, @@ -239,7 +239,7 @@ pub const Module = struct { build_mode: builtin.Mode, zig_lib_dir: []const u8, cache_dir: []const u8, - ) !*Module { + ) !*Compilation { const loop = event_loop_local.loop; var name_buffer = try Buffer.init(loop.allocator, name); @@ -248,7 +248,7 @@ pub const Module = struct { const events = try event.Channel(Event).create(loop, 0); errdefer events.destroy(); - const module = try loop.allocator.create(Module{ + const comp = try loop.allocator.create(Compilation{ .loop = loop, .event_loop_local = event_loop_local, .events = events, @@ -315,12 +315,12 @@ pub const Module = struct { .noreturn_type = undefined, .noreturn_value = undefined, }); - try module.initTypes(); - return module; + try comp.initTypes(); + return comp; } - fn initTypes(module: *Module) !void { - module.meta_type = try module.a().create(Type.MetaType{ + fn initTypes(comp: *Compilation) !void { + comp.meta_type = try comp.a().create(Type.MetaType{ .base = Type{ .base = Value{ .id = Value.Id.Type, @@ -331,86 +331,86 @@ pub const Module = struct { }, .value = undefined, }); - module.meta_type.value = &module.meta_type.base; - module.meta_type.base.base.typeof = &module.meta_type.base; - errdefer module.a().destroy(module.meta_type); + comp.meta_type.value = &comp.meta_type.base; + comp.meta_type.base.base.typeof = &comp.meta_type.base; + errdefer comp.a().destroy(comp.meta_type); - module.void_type = try module.a().create(Type.Void{ + comp.void_type = try comp.a().create(Type.Void{ .base = Type{ .base = Value{ .id = Value.Id.Type, - .typeof = &Type.MetaType.get(module).base, + .typeof = &Type.MetaType.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Void, }, }); - errdefer module.a().destroy(module.void_type); + errdefer comp.a().destroy(comp.void_type); - module.noreturn_type = try module.a().create(Type.NoReturn{ + comp.noreturn_type = try comp.a().create(Type.NoReturn{ .base = Type{ .base = Value{ .id = Value.Id.Type, - .typeof = &Type.MetaType.get(module).base, + .typeof = &Type.MetaType.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.NoReturn, }, }); - errdefer module.a().destroy(module.noreturn_type); + errdefer comp.a().destroy(comp.noreturn_type); - module.bool_type = try module.a().create(Type.Bool{ + comp.bool_type = try comp.a().create(Type.Bool{ .base = Type{ .base = Value{ .id = Value.Id.Type, - .typeof = &Type.MetaType.get(module).base, + .typeof = &Type.MetaType.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Bool, }, }); - errdefer module.a().destroy(module.bool_type); + errdefer comp.a().destroy(comp.bool_type); - module.void_value = try module.a().create(Value.Void{ + comp.void_value = try comp.a().create(Value.Void{ .base = Value{ .id = Value.Id.Void, - .typeof = &Type.Void.get(module).base, + .typeof = &Type.Void.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, }); - errdefer module.a().destroy(module.void_value); + errdefer comp.a().destroy(comp.void_value); - module.true_value = try module.a().create(Value.Bool{ + comp.true_value = try comp.a().create(Value.Bool{ .base = Value{ .id = Value.Id.Bool, - .typeof = &Type.Bool.get(module).base, + .typeof = &Type.Bool.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .x = true, }); - errdefer module.a().destroy(module.true_value); + errdefer comp.a().destroy(comp.true_value); - module.false_value = try module.a().create(Value.Bool{ + comp.false_value = try comp.a().create(Value.Bool{ .base = Value{ .id = Value.Id.Bool, - .typeof = &Type.Bool.get(module).base, + .typeof = &Type.Bool.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .x = false, }); - errdefer module.a().destroy(module.false_value); + errdefer comp.a().destroy(comp.false_value); - module.noreturn_value = try module.a().create(Value.NoReturn{ + comp.noreturn_value = try comp.a().create(Value.NoReturn{ .base = Value{ .id = Value.Id.NoReturn, - .typeof = &Type.NoReturn.get(module).base, + .typeof = &Type.NoReturn.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, }); - errdefer module.a().destroy(module.noreturn_value); + errdefer comp.a().destroy(comp.noreturn_value); } - pub fn destroy(self: *Module) void { + pub fn destroy(self: *Compilation) void { self.noreturn_value.base.deref(self); self.void_value.base.deref(self); self.false_value.base.deref(self); @@ -425,7 +425,7 @@ pub const Module = struct { self.a().destroy(self); } - pub fn build(self: *Module) !void { + pub fn build(self: *Compilation) !void { if (self.llvm_argv.len != 0) { var c_compatible_args = try std.cstr.NullTerminated2DArray.fromSlices(self.a(), [][]const []const u8{ [][]const u8{"zig (LLVM option parsing)"}, @@ -439,7 +439,7 @@ pub const Module = struct { _ = try async self.buildAsync(); } - async fn buildAsync(self: *Module) void { + async fn buildAsync(self: *Compilation) void { while (true) { // TODO directly awaiting async should guarantee memory allocation elision // TODO also async before suspending should guarantee memory allocation elision @@ -474,7 +474,7 @@ pub const Module = struct { } } - async fn addRootSrc(self: *Module) !void { + async fn addRootSrc(self: *Compilation) !void { const root_src_path = self.root_src_path orelse @panic("TODO handle null root src path"); // TODO async/await os.path.real const root_src_real_path = os.path.real(self.a(), root_src_path) catch |err| { @@ -550,7 +550,7 @@ pub const Module = struct { try await (async self.build_group.wait() catch unreachable); } - async fn addTopLevelDecl(self: *Module, decl: *Decl) !void { + async fn addTopLevelDecl(self: *Compilation, decl: *Decl) !void { const is_export = decl.isExported(&decl.parsed_file.tree); if (is_export) { @@ -559,7 +559,7 @@ pub const Module = struct { } } - fn addCompileError(self: *Module, parsed_file: *ParsedFile, span: Span, comptime fmt: []const u8, args: ...) !void { + fn addCompileError(self: *Compilation, parsed_file: *ParsedFile, span: Span, comptime fmt: []const u8, args: ...) !void { const text = try std.fmt.allocPrint(self.loop.allocator, fmt, args); errdefer self.loop.allocator.free(text); @@ -567,7 +567,7 @@ pub const Module = struct { } async fn addCompileErrorAsync( - self: *Module, + self: *Compilation, parsed_file: *ParsedFile, span: Span, text: []u8, @@ -586,7 +586,7 @@ pub const Module = struct { try compile_errors.value.append(msg); } - async fn verifyUniqueSymbol(self: *Module, decl: *Decl) !void { + async fn verifyUniqueSymbol(self: *Compilation, decl: *Decl) !void { const exported_symbol_names = await (async self.exported_symbol_names.acquire() catch unreachable); defer exported_symbol_names.release(); @@ -601,12 +601,12 @@ pub const Module = struct { } } - pub fn link(self: *Module, out_file: ?[]const u8) !void { + pub fn link(self: *Compilation, out_file: ?[]const u8) !void { warn("TODO link"); return error.Todo; } - pub fn addLinkLib(self: *Module, name: []const u8, provided_explicitly: bool) !*LinkLib { + pub fn addLinkLib(self: *Compilation, name: []const u8, provided_explicitly: bool) !*LinkLib { const is_libc = mem.eql(u8, name, "c"); if (is_libc) { @@ -634,7 +634,7 @@ pub const Module = struct { return link_lib; } - fn a(self: Module) *mem.Allocator { + fn a(self: Compilation) *mem.Allocator { return self.loop.allocator; } }; @@ -657,9 +657,9 @@ fn parseVisibToken(tree: *ast.Tree, optional_token_index: ?ast.TokenIndex) Visib } /// This declaration has been blessed as going into the final code generation. -pub async fn resolveDecl(module: *Module, decl: *Decl) !void { +pub async fn resolveDecl(comp: *Compilation, decl: *Decl) !void { if (@atomicRmw(u8, &decl.resolution_in_progress, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst) == 0) { - decl.resolution.data = await (async generateDecl(module, decl) catch unreachable); + decl.resolution.data = await (async generateDecl(comp, decl) catch unreachable); decl.resolution.resolve(); return decl.resolution.data; } else { @@ -668,42 +668,42 @@ pub async fn resolveDecl(module: *Module, decl: *Decl) !void { } /// The function that actually does the generation. -async fn generateDecl(module: *Module, decl: *Decl) !void { +async fn generateDecl(comp: *Compilation, decl: *Decl) !void { switch (decl.id) { Decl.Id.Var => @panic("TODO"), Decl.Id.Fn => { const fn_decl = @fieldParentPtr(Decl.Fn, "base", decl); - return await (async generateDeclFn(module, fn_decl) catch unreachable); + return await (async generateDeclFn(comp, fn_decl) catch unreachable); }, Decl.Id.CompTime => @panic("TODO"), } } -async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { +async fn generateDeclFn(comp: *Compilation, fn_decl: *Decl.Fn) !void { const body_node = fn_decl.fn_proto.body_node orelse @panic("TODO extern fn proto decl"); - const fndef_scope = try Scope.FnDef.create(module, fn_decl.base.parent_scope); - defer fndef_scope.base.deref(module); + const fndef_scope = try Scope.FnDef.create(comp, fn_decl.base.parent_scope); + defer fndef_scope.base.deref(comp); // TODO actually look at the return type of the AST - const return_type = &Type.Void.get(module).base; - defer return_type.base.deref(module); + const return_type = &Type.Void.get(comp).base; + defer return_type.base.deref(comp); const is_var_args = false; const params = ([*]Type.Fn.Param)(undefined)[0..0]; - const fn_type = try Type.Fn.create(module, return_type, params, is_var_args); - defer fn_type.base.base.deref(module); + const fn_type = try Type.Fn.create(comp, return_type, params, is_var_args); + defer fn_type.base.base.deref(comp); - var symbol_name = try std.Buffer.init(module.a(), fn_decl.base.name); + var symbol_name = try std.Buffer.init(comp.a(), fn_decl.base.name); errdefer symbol_name.deinit(); - const fn_val = try Value.Fn.create(module, fn_type, fndef_scope, symbol_name); - defer fn_val.base.deref(module); + const fn_val = try Value.Fn.create(comp, fn_type, fndef_scope, symbol_name); + defer fn_val.base.deref(comp); fn_decl.value = Decl.Fn.Val{ .Ok = fn_val }; const unanalyzed_code = (await (async ir.gen( - module, + comp, body_node, &fndef_scope.base, Span.token(body_node.lastToken()), @@ -715,15 +715,15 @@ async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { error.SemanticAnalysisFailed => return {}, else => return err, }; - defer unanalyzed_code.destroy(module.a()); + defer unanalyzed_code.destroy(comp.a()); - if (module.verbose_ir) { + if (comp.verbose_ir) { std.debug.warn("unanalyzed:\n"); unanalyzed_code.dump(); } const analyzed_code = (await (async ir.analyze( - module, + comp, fn_decl.base.parsed_file, unanalyzed_code, null, @@ -734,14 +734,14 @@ async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { error.SemanticAnalysisFailed => return {}, else => return err, }; - errdefer analyzed_code.destroy(module.a()); + errdefer analyzed_code.destroy(comp.a()); - if (module.verbose_ir) { + if (comp.verbose_ir) { std.debug.warn("analyzed:\n"); analyzed_code.dump(); } - // Kick off rendering to LLVM module, but it doesn't block the fn decl + // Kick off rendering to LLVM comp, but it doesn't block the fn decl // analysis from being complete. - try module.build_group.call(codegen.renderToLlvm, module, fn_val, analyzed_code); + try comp.build_group.call(codegen.renderToLlvm, comp, fn_val, analyzed_code); } diff --git a/src-self-hosted/decl.zig b/src-self-hosted/decl.zig index 1a75a3249e..c0173266ee 100644 --- a/src-self-hosted/decl.zig +++ b/src-self-hosted/decl.zig @@ -9,13 +9,13 @@ const Value = @import("value.zig").Value; const Token = std.zig.Token; const errmsg = @import("errmsg.zig"); const Scope = @import("scope.zig").Scope; -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; pub const Decl = struct { id: Id, name: []const u8, visib: Visib, - resolution: event.Future(Module.BuildError!void), + resolution: event.Future(Compilation.BuildError!void), resolution_in_progress: u8, parsed_file: *ParsedFile, parent_scope: *Scope, diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig index f1c395a790..22d5a067a7 100644 --- a/src-self-hosted/ir.zig +++ b/src-self-hosted/ir.zig @@ -1,6 +1,6 @@ const std = @import("std"); const builtin = @import("builtin"); -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; const Scope = @import("scope.zig").Scope; const ast = std.zig.ast; const Allocator = std.mem.Allocator; @@ -243,7 +243,7 @@ pub const Instruction = struct { Value.Ptr.Mut.CompTimeConst, self.params.mut, self.params.volatility, - val.typeof.getAbiAlignment(ira.irb.module), + val.typeof.getAbiAlignment(ira.irb.comp), ); } @@ -254,12 +254,12 @@ pub const Instruction = struct { }); const elem_type = target.getKnownType(); const ptr_type = Type.Pointer.get( - ira.irb.module, + ira.irb.comp, elem_type, self.params.mut, self.params.volatility, Type.Pointer.Size.One, - elem_type.getAbiAlignment(ira.irb.module), + elem_type.getAbiAlignment(ira.irb.comp), ); // TODO: potentially set the hint that this is a stack pointer. But it might not be - this // could be a ref of a global, for example @@ -417,7 +417,7 @@ pub const Code = struct { arena: std.heap.ArenaAllocator, return_type: ?*Type, - /// allocator is module.a() + /// allocator is comp.a() pub fn destroy(self: *Code, allocator: *Allocator) void { self.arena.deinit(); allocator.destroy(self); @@ -437,7 +437,7 @@ pub const Code = struct { }; pub const Builder = struct { - module: *Module, + comp: *Compilation, code: *Code, current_basic_block: *BasicBlock, next_debug_id: usize, @@ -446,17 +446,17 @@ pub const Builder = struct { pub const Error = Analyze.Error; - pub fn init(module: *Module, parsed_file: *ParsedFile) !Builder { - const code = try module.a().create(Code{ + pub fn init(comp: *Compilation, parsed_file: *ParsedFile) !Builder { + const code = try comp.a().create(Code{ .basic_block_list = undefined, - .arena = std.heap.ArenaAllocator.init(module.a()), + .arena = std.heap.ArenaAllocator.init(comp.a()), .return_type = null, }); code.basic_block_list = std.ArrayList(*BasicBlock).init(&code.arena.allocator); - errdefer code.destroy(module.a()); + errdefer code.destroy(comp.a()); return Builder{ - .module = module, + .comp = comp, .parsed_file = parsed_file, .current_basic_block = undefined, .code = code, @@ -466,7 +466,7 @@ pub const Builder = struct { } pub fn abort(self: *Builder) void { - self.code.destroy(self.module.a()); + self.code.destroy(self.comp.a()); } /// Call code.destroy() when done @@ -581,7 +581,7 @@ pub const Builder = struct { } pub fn genBlock(irb: *Builder, block: *ast.Node.Block, parent_scope: *Scope) !*Instruction { - const block_scope = try Scope.Block.create(irb.module, parent_scope); + const block_scope = try Scope.Block.create(irb.comp, parent_scope); const outer_block_scope = &block_scope.base; var child_scope = outer_block_scope; @@ -623,8 +623,8 @@ pub const Builder = struct { Token.Id.Keyword_errdefer => Scope.Defer.Kind.ErrorExit, else => unreachable, }; - const defer_expr_scope = try Scope.DeferExpr.create(irb.module, parent_scope, defer_node.expr); - const defer_child_scope = try Scope.Defer.create(irb.module, parent_scope, kind, defer_expr_scope); + const defer_expr_scope = try Scope.DeferExpr.create(irb.comp, parent_scope, defer_node.expr); + const defer_child_scope = try Scope.Defer.create(irb.comp, parent_scope, kind, defer_expr_scope); child_scope = &defer_child_scope.base; continue; } @@ -770,8 +770,8 @@ pub const Builder = struct { .debug_id = self.next_debug_id, .val = switch (I.ir_val_init) { IrVal.Init.Unknown => IrVal.Unknown, - IrVal.Init.NoReturn => IrVal{ .KnownValue = &Value.NoReturn.get(self.module).base }, - IrVal.Init.Void => IrVal{ .KnownValue = &Value.Void.get(self.module).base }, + IrVal.Init.NoReturn => IrVal{ .KnownValue = &Value.NoReturn.get(self.comp).base }, + IrVal.Init.Void => IrVal{ .KnownValue = &Value.Void.get(self.comp).base }, }, .ref_count = 0, .span = span, @@ -819,13 +819,13 @@ pub const Builder = struct { fn buildConstBool(self: *Builder, scope: *Scope, span: Span, x: bool) !*Instruction { const inst = try self.build(Instruction.Const, scope, span, Instruction.Const.Params{}); - inst.val = IrVal{ .KnownValue = &Value.Bool.get(self.module, x).base }; + inst.val = IrVal{ .KnownValue = &Value.Bool.get(self.comp, x).base }; return inst; } fn buildConstVoid(self: *Builder, scope: *Scope, span: Span, is_generated: bool) !*Instruction { const inst = try self.buildExtra(Instruction.Const, scope, span, Instruction.Const.Params{}, is_generated); - inst.val = IrVal{ .KnownValue = &Value.Void.get(self.module).base }; + inst.val = IrVal{ .KnownValue = &Value.Void.get(self.comp).base }; return inst; } }; @@ -850,8 +850,8 @@ const Analyze = struct { OutOfMemory, }; - pub fn init(module: *Module, parsed_file: *ParsedFile, explicit_return_type: ?*Type) !Analyze { - var irb = try Builder.init(module, parsed_file); + pub fn init(comp: *Compilation, parsed_file: *ParsedFile, explicit_return_type: ?*Type) !Analyze { + var irb = try Builder.init(comp, parsed_file); errdefer irb.abort(); return Analyze{ @@ -929,12 +929,12 @@ const Analyze = struct { } fn addCompileError(self: *Analyze, span: Span, comptime fmt: []const u8, args: ...) !void { - return self.irb.module.addCompileError(self.irb.parsed_file, span, fmt, args); + return self.irb.comp.addCompileError(self.irb.parsed_file, span, fmt, args); } fn resolvePeerTypes(self: *Analyze, expected_type: ?*Type, peers: []const *Instruction) Analyze.Error!*Type { // TODO actual implementation - return &Type.Void.get(self.irb.module).base; + return &Type.Void.get(self.irb.comp).base; } fn implicitCast(self: *Analyze, target: *Instruction, optional_dest_type: ?*Type) Analyze.Error!*Instruction { @@ -959,13 +959,13 @@ const Analyze = struct { }; pub async fn gen( - module: *Module, + comp: *Compilation, body_node: *ast.Node, scope: *Scope, end_span: Span, parsed_file: *ParsedFile, ) !*Code { - var irb = try Builder.init(module, parsed_file); + var irb = try Builder.init(comp, parsed_file); errdefer irb.abort(); const entry_block = try irb.createBasicBlock(scope, "Entry"); @@ -991,8 +991,8 @@ pub async fn gen( return irb.finish(); } -pub async fn analyze(module: *Module, parsed_file: *ParsedFile, old_code: *Code, expected_type: ?*Type) !*Code { - var ira = try Analyze.init(module, parsed_file, expected_type); +pub async fn analyze(comp: *Compilation, parsed_file: *ParsedFile, old_code: *Code, expected_type: ?*Type) !*Code { + var ira = try Analyze.init(comp, parsed_file, expected_type); errdefer ira.abort(); const old_entry_bb = old_code.basic_block_list.at(0); @@ -1025,7 +1025,7 @@ pub async fn analyze(module: *Module, parsed_file: *ParsedFile, old_code: *Code, } if (ira.src_implicit_return_type_list.len == 0) { - ira.irb.code.return_type = &Type.NoReturn.get(module).base; + ira.irb.code.return_type = &Type.NoReturn.get(comp).base; return ira.irb.finish(); } diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig index 77ec7f6d32..c9478954c5 100644 --- a/src-self-hosted/main.zig +++ b/src-self-hosted/main.zig @@ -14,8 +14,8 @@ const c = @import("c.zig"); const introspect = @import("introspect.zig"); const Args = arg.Args; const Flag = arg.Flag; -const EventLoopLocal = @import("module.zig").EventLoopLocal; -const Module = @import("module.zig").Module; +const EventLoopLocal = @import("compilation.zig").EventLoopLocal; +const Compilation = @import("compilation.zig").Compilation; const Target = @import("target.zig").Target; const errmsg = @import("errmsg.zig"); @@ -258,7 +258,7 @@ const args_build_generic = []Flag{ Flag.Arg1("--ver-patch"), }; -fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Module.Kind) !void { +fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Compilation.Kind) !void { var flags = try Args.parse(allocator, args_build_generic, args); defer flags.deinit(); @@ -300,14 +300,14 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo const emit_type = blk: { if (flags.single("emit")) |emit_flag| { if (mem.eql(u8, emit_flag, "asm")) { - break :blk Module.Emit.Assembly; + break :blk Compilation.Emit.Assembly; } else if (mem.eql(u8, emit_flag, "bin")) { - break :blk Module.Emit.Binary; + break :blk Compilation.Emit.Binary; } else if (mem.eql(u8, emit_flag, "llvm-ir")) { - break :blk Module.Emit.LlvmIr; + break :blk Compilation.Emit.LlvmIr; } else unreachable; } else { - break :blk Module.Emit.Binary; + break :blk Compilation.Emit.Binary; } }; @@ -370,7 +370,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo os.exit(1); } - if (out_type == Module.Kind.Obj and link_objects.len != 0) { + if (out_type == Compilation.Kind.Obj and link_objects.len != 0) { try stderr.write("When building an object file, --object arguments are invalid\n"); os.exit(1); } @@ -392,7 +392,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo var event_loop_local = EventLoopLocal.init(&loop); defer event_loop_local.deinit(); - var module = try Module.create( + var comp = try Compilation.create( &event_loop_local, root_name, root_source_file, @@ -402,16 +402,16 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo zig_lib_dir, full_cache_dir, ); - defer module.destroy(); + defer comp.destroy(); - module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") orelse "0", 10); - module.version_minor = try std.fmt.parseUnsigned(u32, flags.single("ver-minor") orelse "0", 10); - module.version_patch = try std.fmt.parseUnsigned(u32, flags.single("ver-patch") orelse "0", 10); + comp.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") orelse "0", 10); + comp.version_minor = try std.fmt.parseUnsigned(u32, flags.single("ver-minor") orelse "0", 10); + comp.version_patch = try std.fmt.parseUnsigned(u32, flags.single("ver-patch") orelse "0", 10); - module.is_test = false; + comp.is_test = false; - module.linker_script = flags.single("linker-script"); - module.each_lib_rpath = flags.present("each-lib-rpath"); + comp.linker_script = flags.single("linker-script"); + comp.each_lib_rpath = flags.present("each-lib-rpath"); var clang_argv_buf = ArrayList([]const u8).init(allocator); defer clang_argv_buf.deinit(); @@ -422,51 +422,51 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo try clang_argv_buf.append(mllvm); } - module.llvm_argv = mllvm_flags; - module.clang_argv = clang_argv_buf.toSliceConst(); + comp.llvm_argv = mllvm_flags; + comp.clang_argv = clang_argv_buf.toSliceConst(); - module.strip = flags.present("strip"); - module.is_static = flags.present("static"); + comp.strip = flags.present("strip"); + comp.is_static = flags.present("static"); if (flags.single("libc-lib-dir")) |libc_lib_dir| { - module.libc_lib_dir = libc_lib_dir; + comp.libc_lib_dir = libc_lib_dir; } if (flags.single("libc-static-lib-dir")) |libc_static_lib_dir| { - module.libc_static_lib_dir = libc_static_lib_dir; + comp.libc_static_lib_dir = libc_static_lib_dir; } if (flags.single("libc-include-dir")) |libc_include_dir| { - module.libc_include_dir = libc_include_dir; + comp.libc_include_dir = libc_include_dir; } if (flags.single("msvc-lib-dir")) |msvc_lib_dir| { - module.msvc_lib_dir = msvc_lib_dir; + comp.msvc_lib_dir = msvc_lib_dir; } if (flags.single("kernel32-lib-dir")) |kernel32_lib_dir| { - module.kernel32_lib_dir = kernel32_lib_dir; + comp.kernel32_lib_dir = kernel32_lib_dir; } if (flags.single("dynamic-linker")) |dynamic_linker| { - module.dynamic_linker = dynamic_linker; + comp.dynamic_linker = dynamic_linker; } - module.verbose_tokenize = flags.present("verbose-tokenize"); - module.verbose_ast_tree = flags.present("verbose-ast-tree"); - module.verbose_ast_fmt = flags.present("verbose-ast-fmt"); - module.verbose_link = flags.present("verbose-link"); - module.verbose_ir = flags.present("verbose-ir"); - module.verbose_llvm_ir = flags.present("verbose-llvm-ir"); - module.verbose_cimport = flags.present("verbose-cimport"); + comp.verbose_tokenize = flags.present("verbose-tokenize"); + comp.verbose_ast_tree = flags.present("verbose-ast-tree"); + comp.verbose_ast_fmt = flags.present("verbose-ast-fmt"); + comp.verbose_link = flags.present("verbose-link"); + comp.verbose_ir = flags.present("verbose-ir"); + comp.verbose_llvm_ir = flags.present("verbose-llvm-ir"); + comp.verbose_cimport = flags.present("verbose-cimport"); - module.err_color = color; - module.lib_dirs = flags.many("library-path"); - module.darwin_frameworks = flags.many("framework"); - module.rpath_list = flags.many("rpath"); + comp.err_color = color; + comp.lib_dirs = flags.many("library-path"); + comp.darwin_frameworks = flags.many("framework"); + comp.rpath_list = flags.many("rpath"); if (flags.single("output-h")) |output_h| { - module.out_h_path = output_h; + comp.out_h_path = output_h; } - module.windows_subsystem_windows = flags.present("mwindows"); - module.windows_subsystem_console = flags.present("mconsole"); - module.linker_rdynamic = flags.present("rdynamic"); + comp.windows_subsystem_windows = flags.present("mwindows"); + comp.windows_subsystem_console = flags.present("mconsole"); + comp.linker_rdynamic = flags.present("rdynamic"); if (flags.single("mmacosx-version-min") != null and flags.single("mios-version-min") != null) { try stderr.write("-mmacosx-version-min and -mios-version-min options not allowed together\n"); @@ -474,37 +474,37 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo } if (flags.single("mmacosx-version-min")) |ver| { - module.darwin_version_min = Module.DarwinVersionMin{ .MacOS = ver }; + comp.darwin_version_min = Compilation.DarwinVersionMin{ .MacOS = ver }; } if (flags.single("mios-version-min")) |ver| { - module.darwin_version_min = Module.DarwinVersionMin{ .Ios = ver }; + comp.darwin_version_min = Compilation.DarwinVersionMin{ .Ios = ver }; } - module.emit_file_type = emit_type; - module.link_objects = link_objects; - module.assembly_files = assembly_files; - module.link_out_file = flags.single("out-file"); + comp.emit_file_type = emit_type; + comp.link_objects = link_objects; + comp.assembly_files = assembly_files; + comp.link_out_file = flags.single("out-file"); - try module.build(); - const process_build_events_handle = try async processBuildEvents(module, color); + try comp.build(); + const process_build_events_handle = try async processBuildEvents(comp, color); defer cancel process_build_events_handle; loop.run(); } -async fn processBuildEvents(module: *Module, color: errmsg.Color) void { +async fn processBuildEvents(comp: *Compilation, color: errmsg.Color) void { // TODO directly awaiting async should guarantee memory allocation elision - const build_event = await (async module.events.get() catch unreachable); + const build_event = await (async comp.events.get() catch unreachable); switch (build_event) { - Module.Event.Ok => { + Compilation.Event.Ok => { std.debug.warn("Build succeeded\n"); return; }, - Module.Event.Error => |err| { + Compilation.Event.Error => |err| { std.debug.warn("build failed: {}\n", @errorName(err)); os.exit(1); }, - Module.Event.Fail => |msgs| { + Compilation.Event.Fail => |msgs| { for (msgs) |msg| { errmsg.printToFile(&stderr_file, msg, color) catch os.exit(1); } @@ -513,15 +513,15 @@ async fn processBuildEvents(module: *Module, color: errmsg.Color) void { } fn cmdBuildExe(allocator: *Allocator, args: []const []const u8) !void { - return buildOutputType(allocator, args, Module.Kind.Exe); + return buildOutputType(allocator, args, Compilation.Kind.Exe); } fn cmdBuildLib(allocator: *Allocator, args: []const []const u8) !void { - return buildOutputType(allocator, args, Module.Kind.Lib); + return buildOutputType(allocator, args, Compilation.Kind.Lib); } fn cmdBuildObj(allocator: *Allocator, args: []const []const u8) !void { - return buildOutputType(allocator, args, Module.Kind.Obj); + return buildOutputType(allocator, args, Compilation.Kind.Obj); } const usage_fmt = diff --git a/src-self-hosted/scope.zig b/src-self-hosted/scope.zig index 8f8d016a7c..6fd6456b12 100644 --- a/src-self-hosted/scope.zig +++ b/src-self-hosted/scope.zig @@ -1,7 +1,7 @@ const std = @import("std"); const Allocator = mem.Allocator; const Decl = @import("decl.zig").Decl; -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; const mem = std.mem; const ast = std.zig.ast; const Value = @import("value.zig").Value; @@ -16,17 +16,17 @@ pub const Scope = struct { base.ref_count += 1; } - pub fn deref(base: *Scope, module: *Module) void { + pub fn deref(base: *Scope, comp: *Compilation) void { base.ref_count -= 1; if (base.ref_count == 0) { - if (base.parent) |parent| parent.deref(module); + if (base.parent) |parent| parent.deref(comp); switch (base.id) { Id.Decls => @fieldParentPtr(Decls, "base", base).destroy(), - Id.Block => @fieldParentPtr(Block, "base", base).destroy(module), - Id.FnDef => @fieldParentPtr(FnDef, "base", base).destroy(module), - Id.CompTime => @fieldParentPtr(CompTime, "base", base).destroy(module), - Id.Defer => @fieldParentPtr(Defer, "base", base).destroy(module), - Id.DeferExpr => @fieldParentPtr(DeferExpr, "base", base).destroy(module), + Id.Block => @fieldParentPtr(Block, "base", base).destroy(comp), + Id.FnDef => @fieldParentPtr(FnDef, "base", base).destroy(comp), + Id.CompTime => @fieldParentPtr(CompTime, "base", base).destroy(comp), + Id.Defer => @fieldParentPtr(Defer, "base", base).destroy(comp), + Id.DeferExpr => @fieldParentPtr(DeferExpr, "base", base).destroy(comp), } } } @@ -61,8 +61,8 @@ pub const Scope = struct { table: Decl.Table, /// Creates a Decls scope with 1 reference - pub fn create(module: *Module, parent: ?*Scope) !*Decls { - const self = try module.a().create(Decls{ + pub fn create(comp: *Compilation, parent: ?*Scope) !*Decls { + const self = try comp.a().create(Decls{ .base = Scope{ .id = Id.Decls, .parent = parent, @@ -70,9 +70,9 @@ pub const Scope = struct { }, .table = undefined, }); - errdefer module.a().destroy(self); + errdefer comp.a().destroy(self); - self.table = Decl.Table.init(module.a()); + self.table = Decl.Table.init(comp.a()); errdefer self.table.deinit(); if (parent) |p| p.ref(); @@ -94,8 +94,8 @@ pub const Scope = struct { is_comptime: *ir.Instruction, /// Creates a Block scope with 1 reference - pub fn create(module: *Module, parent: ?*Scope) !*Block { - const self = try module.a().create(Block{ + pub fn create(comp: *Compilation, parent: ?*Scope) !*Block { + const self = try comp.a().create(Block{ .base = Scope{ .id = Id.Block, .parent = parent, @@ -106,14 +106,14 @@ pub const Scope = struct { .end_block = undefined, .is_comptime = undefined, }); - errdefer module.a().destroy(self); + errdefer comp.a().destroy(self); if (parent) |p| p.ref(); return self; } - pub fn destroy(self: *Block, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Block, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -125,8 +125,8 @@ pub const Scope = struct { /// Creates a FnDef scope with 1 reference /// Must set the fn_val later - pub fn create(module: *Module, parent: ?*Scope) !*FnDef { - const self = try module.a().create(FnDef{ + pub fn create(comp: *Compilation, parent: ?*Scope) !*FnDef { + const self = try comp.a().create(FnDef{ .base = Scope{ .id = Id.FnDef, .parent = parent, @@ -140,8 +140,8 @@ pub const Scope = struct { return self; } - pub fn destroy(self: *FnDef, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *FnDef, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -149,8 +149,8 @@ pub const Scope = struct { base: Scope, /// Creates a CompTime scope with 1 reference - pub fn create(module: *Module, parent: ?*Scope) !*CompTime { - const self = try module.a().create(CompTime{ + pub fn create(comp: *Compilation, parent: ?*Scope) !*CompTime { + const self = try comp.a().create(CompTime{ .base = Scope{ .id = Id.CompTime, .parent = parent, @@ -162,8 +162,8 @@ pub const Scope = struct { return self; } - pub fn destroy(self: *CompTime, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *CompTime, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -179,12 +179,12 @@ pub const Scope = struct { /// Creates a Defer scope with 1 reference pub fn create( - module: *Module, + comp: *Compilation, parent: ?*Scope, kind: Kind, defer_expr_scope: *DeferExpr, ) !*Defer { - const self = try module.a().create(Defer{ + const self = try comp.a().create(Defer{ .base = Scope{ .id = Id.Defer, .parent = parent, @@ -193,7 +193,7 @@ pub const Scope = struct { .defer_expr_scope = defer_expr_scope, .kind = kind, }); - errdefer module.a().destroy(self); + errdefer comp.a().destroy(self); defer_expr_scope.base.ref(); @@ -201,9 +201,9 @@ pub const Scope = struct { return self; } - pub fn destroy(self: *Defer, module: *Module) void { - self.defer_expr_scope.base.deref(module); - module.a().destroy(self); + pub fn destroy(self: *Defer, comp: *Compilation) void { + self.defer_expr_scope.base.deref(comp); + comp.a().destroy(self); } }; @@ -212,8 +212,8 @@ pub const Scope = struct { expr_node: *ast.Node, /// Creates a DeferExpr scope with 1 reference - pub fn create(module: *Module, parent: ?*Scope, expr_node: *ast.Node) !*DeferExpr { - const self = try module.a().create(DeferExpr{ + pub fn create(comp: *Compilation, parent: ?*Scope, expr_node: *ast.Node) !*DeferExpr { + const self = try comp.a().create(DeferExpr{ .base = Scope{ .id = Id.DeferExpr, .parent = parent, @@ -221,14 +221,14 @@ pub const Scope = struct { }, .expr_node = expr_node, }); - errdefer module.a().destroy(self); + errdefer comp.a().destroy(self); if (parent) |p| p.ref(); return self; } - pub fn destroy(self: *DeferExpr, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *DeferExpr, comp: *Compilation) void { + comp.a().destroy(self); } }; }; diff --git a/src-self-hosted/test.zig b/src-self-hosted/test.zig index e609eb2791..3edb267ca9 100644 --- a/src-self-hosted/test.zig +++ b/src-self-hosted/test.zig @@ -2,11 +2,11 @@ const std = @import("std"); const mem = std.mem; const builtin = @import("builtin"); const Target = @import("target.zig").Target; -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; const introspect = @import("introspect.zig"); const assertOrPanic = std.debug.assertOrPanic; const errmsg = @import("errmsg.zig"); -const EventLoopLocal = @import("module.zig").EventLoopLocal; +const EventLoopLocal = @import("compilation.zig").EventLoopLocal; test "compile errors" { var ctx: TestContext = undefined; @@ -100,42 +100,42 @@ pub const TestContext = struct { // TODO async I/O try std.io.writeFile(allocator, file1_path, source); - var module = try Module.create( + var comp = try Compilation.create( &self.event_loop_local, "test", file1_path, Target.Native, - Module.Kind.Obj, + Compilation.Kind.Obj, builtin.Mode.Debug, self.zig_lib_dir, self.zig_cache_dir, ); - errdefer module.destroy(); + errdefer comp.destroy(); - try module.build(); + try comp.build(); - try self.group.call(getModuleEvent, module, source, path, line, column, msg); + try self.group.call(getModuleEvent, comp, source, path, line, column, msg); } async fn getModuleEvent( - module: *Module, + comp: *Compilation, source: []const u8, path: []const u8, line: usize, column: usize, text: []const u8, ) !void { - defer module.destroy(); - const build_event = await (async module.events.get() catch unreachable); + defer comp.destroy(); + const build_event = await (async comp.events.get() catch unreachable); switch (build_event) { - Module.Event.Ok => { + Compilation.Event.Ok => { @panic("build incorrectly succeeded"); }, - Module.Event.Error => |err| { + Compilation.Event.Error => |err| { @panic("build incorrectly failed"); }, - Module.Event.Fail => |msgs| { + Compilation.Event.Fail => |msgs| { assertOrPanic(msgs.len != 0); for (msgs) |msg| { if (mem.endsWith(u8, msg.path, path) and mem.eql(u8, msg.text, text)) { diff --git a/src-self-hosted/type.zig b/src-self-hosted/type.zig index e4c31018a3..8349047749 100644 --- a/src-self-hosted/type.zig +++ b/src-self-hosted/type.zig @@ -1,10 +1,10 @@ const std = @import("std"); const builtin = @import("builtin"); const Scope = @import("scope.zig").Scope; -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; const Value = @import("value.zig").Value; const llvm = @import("llvm.zig"); -const CompilationUnit = @import("codegen.zig").CompilationUnit; +const ObjectFile = @import("codegen.zig").ObjectFile; pub const Type = struct { base: Value, @@ -12,63 +12,63 @@ pub const Type = struct { pub const Id = builtin.TypeId; - pub fn destroy(base: *Type, module: *Module) void { + pub fn destroy(base: *Type, comp: *Compilation) void { switch (base.id) { - Id.Struct => @fieldParentPtr(Struct, "base", base).destroy(module), - Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(module), - Id.Type => @fieldParentPtr(MetaType, "base", base).destroy(module), - Id.Void => @fieldParentPtr(Void, "base", base).destroy(module), - Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(module), - Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(module), - Id.Int => @fieldParentPtr(Int, "base", base).destroy(module), - Id.Float => @fieldParentPtr(Float, "base", base).destroy(module), - Id.Pointer => @fieldParentPtr(Pointer, "base", base).destroy(module), - Id.Array => @fieldParentPtr(Array, "base", base).destroy(module), - Id.ComptimeFloat => @fieldParentPtr(ComptimeFloat, "base", base).destroy(module), - Id.ComptimeInt => @fieldParentPtr(ComptimeInt, "base", base).destroy(module), - Id.Undefined => @fieldParentPtr(Undefined, "base", base).destroy(module), - Id.Null => @fieldParentPtr(Null, "base", base).destroy(module), - Id.Optional => @fieldParentPtr(Optional, "base", base).destroy(module), - Id.ErrorUnion => @fieldParentPtr(ErrorUnion, "base", base).destroy(module), - Id.ErrorSet => @fieldParentPtr(ErrorSet, "base", base).destroy(module), - Id.Enum => @fieldParentPtr(Enum, "base", base).destroy(module), - Id.Union => @fieldParentPtr(Union, "base", base).destroy(module), - Id.Namespace => @fieldParentPtr(Namespace, "base", base).destroy(module), - Id.Block => @fieldParentPtr(Block, "base", base).destroy(module), - Id.BoundFn => @fieldParentPtr(BoundFn, "base", base).destroy(module), - Id.ArgTuple => @fieldParentPtr(ArgTuple, "base", base).destroy(module), - Id.Opaque => @fieldParentPtr(Opaque, "base", base).destroy(module), - Id.Promise => @fieldParentPtr(Promise, "base", base).destroy(module), + Id.Struct => @fieldParentPtr(Struct, "base", base).destroy(comp), + Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(comp), + Id.Type => @fieldParentPtr(MetaType, "base", base).destroy(comp), + Id.Void => @fieldParentPtr(Void, "base", base).destroy(comp), + Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(comp), + Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp), + Id.Int => @fieldParentPtr(Int, "base", base).destroy(comp), + Id.Float => @fieldParentPtr(Float, "base", base).destroy(comp), + Id.Pointer => @fieldParentPtr(Pointer, "base", base).destroy(comp), + Id.Array => @fieldParentPtr(Array, "base", base).destroy(comp), + Id.ComptimeFloat => @fieldParentPtr(ComptimeFloat, "base", base).destroy(comp), + Id.ComptimeInt => @fieldParentPtr(ComptimeInt, "base", base).destroy(comp), + Id.Undefined => @fieldParentPtr(Undefined, "base", base).destroy(comp), + Id.Null => @fieldParentPtr(Null, "base", base).destroy(comp), + Id.Optional => @fieldParentPtr(Optional, "base", base).destroy(comp), + Id.ErrorUnion => @fieldParentPtr(ErrorUnion, "base", base).destroy(comp), + Id.ErrorSet => @fieldParentPtr(ErrorSet, "base", base).destroy(comp), + Id.Enum => @fieldParentPtr(Enum, "base", base).destroy(comp), + Id.Union => @fieldParentPtr(Union, "base", base).destroy(comp), + Id.Namespace => @fieldParentPtr(Namespace, "base", base).destroy(comp), + Id.Block => @fieldParentPtr(Block, "base", base).destroy(comp), + Id.BoundFn => @fieldParentPtr(BoundFn, "base", base).destroy(comp), + Id.ArgTuple => @fieldParentPtr(ArgTuple, "base", base).destroy(comp), + Id.Opaque => @fieldParentPtr(Opaque, "base", base).destroy(comp), + Id.Promise => @fieldParentPtr(Promise, "base", base).destroy(comp), } } - pub fn getLlvmType(base: *Type, cunit: *CompilationUnit) (error{OutOfMemory}!llvm.TypeRef) { + pub fn getLlvmType(base: *Type, ofile: *ObjectFile) (error{OutOfMemory}!llvm.TypeRef) { switch (base.id) { - Id.Struct => return @fieldParentPtr(Struct, "base", base).getLlvmType(cunit), - Id.Fn => return @fieldParentPtr(Fn, "base", base).getLlvmType(cunit), + Id.Struct => return @fieldParentPtr(Struct, "base", base).getLlvmType(ofile), + Id.Fn => return @fieldParentPtr(Fn, "base", base).getLlvmType(ofile), Id.Type => unreachable, Id.Void => unreachable, - Id.Bool => return @fieldParentPtr(Bool, "base", base).getLlvmType(cunit), + Id.Bool => return @fieldParentPtr(Bool, "base", base).getLlvmType(ofile), Id.NoReturn => unreachable, - Id.Int => return @fieldParentPtr(Int, "base", base).getLlvmType(cunit), - Id.Float => return @fieldParentPtr(Float, "base", base).getLlvmType(cunit), - Id.Pointer => return @fieldParentPtr(Pointer, "base", base).getLlvmType(cunit), - Id.Array => return @fieldParentPtr(Array, "base", base).getLlvmType(cunit), + Id.Int => return @fieldParentPtr(Int, "base", base).getLlvmType(ofile), + Id.Float => return @fieldParentPtr(Float, "base", base).getLlvmType(ofile), + Id.Pointer => return @fieldParentPtr(Pointer, "base", base).getLlvmType(ofile), + Id.Array => return @fieldParentPtr(Array, "base", base).getLlvmType(ofile), Id.ComptimeFloat => unreachable, Id.ComptimeInt => unreachable, Id.Undefined => unreachable, Id.Null => unreachable, - Id.Optional => return @fieldParentPtr(Optional, "base", base).getLlvmType(cunit), - Id.ErrorUnion => return @fieldParentPtr(ErrorUnion, "base", base).getLlvmType(cunit), - Id.ErrorSet => return @fieldParentPtr(ErrorSet, "base", base).getLlvmType(cunit), - Id.Enum => return @fieldParentPtr(Enum, "base", base).getLlvmType(cunit), - Id.Union => return @fieldParentPtr(Union, "base", base).getLlvmType(cunit), + Id.Optional => return @fieldParentPtr(Optional, "base", base).getLlvmType(ofile), + Id.ErrorUnion => return @fieldParentPtr(ErrorUnion, "base", base).getLlvmType(ofile), + Id.ErrorSet => return @fieldParentPtr(ErrorSet, "base", base).getLlvmType(ofile), + Id.Enum => return @fieldParentPtr(Enum, "base", base).getLlvmType(ofile), + Id.Union => return @fieldParentPtr(Union, "base", base).getLlvmType(ofile), Id.Namespace => unreachable, Id.Block => unreachable, - Id.BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(cunit), + Id.BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(ofile), Id.ArgTuple => unreachable, - Id.Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(cunit), - Id.Promise => return @fieldParentPtr(Promise, "base", base).getLlvmType(cunit), + Id.Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(ofile), + Id.Promise => return @fieldParentPtr(Promise, "base", base).getLlvmType(ofile), } } @@ -76,7 +76,7 @@ pub const Type = struct { std.debug.warn("{}", @tagName(base.id)); } - pub fn getAbiAlignment(base: *Type, module: *Module) u32 { + pub fn getAbiAlignment(base: *Type, comp: *Compilation) u32 { @panic("TODO getAbiAlignment"); } @@ -84,11 +84,11 @@ pub const Type = struct { base: Type, decls: *Scope.Decls, - pub fn destroy(self: *Struct, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Struct, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Struct, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Struct, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -104,12 +104,12 @@ pub const Type = struct { typeof: *Type, }; - pub fn create(module: *Module, return_type: *Type, params: []Param, is_var_args: bool) !*Fn { - const result = try module.a().create(Fn{ + pub fn create(comp: *Compilation, return_type: *Type, params: []Param, is_var_args: bool) !*Fn { + const result = try comp.a().create(Fn{ .base = Type{ .base = Value{ .id = Value.Id.Type, - .typeof = &MetaType.get(module).base, + .typeof = &MetaType.get(comp).base, .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Fn, @@ -118,7 +118,7 @@ pub const Type = struct { .params = params, .is_var_args = is_var_args, }); - errdefer module.a().destroy(result); + errdefer comp.a().destroy(result); result.return_type.base.ref(); for (result.params) |param| { @@ -127,23 +127,23 @@ pub const Type = struct { return result; } - pub fn destroy(self: *Fn, module: *Module) void { - self.return_type.base.deref(module); + pub fn destroy(self: *Fn, comp: *Compilation) void { + self.return_type.base.deref(comp); for (self.params) |param| { - param.typeof.base.deref(module); + param.typeof.base.deref(comp); } - module.a().destroy(self); + comp.a().destroy(self); } - pub fn getLlvmType(self: *Fn, cunit: *CompilationUnit) !llvm.TypeRef { + pub fn getLlvmType(self: *Fn, ofile: *ObjectFile) !llvm.TypeRef { const llvm_return_type = switch (self.return_type.id) { - Type.Id.Void => llvm.VoidTypeInContext(cunit.context) orelse return error.OutOfMemory, - else => try self.return_type.getLlvmType(cunit), + Type.Id.Void => llvm.VoidTypeInContext(ofile.context) orelse return error.OutOfMemory, + else => try self.return_type.getLlvmType(ofile), }; - const llvm_param_types = try cunit.a().alloc(llvm.TypeRef, self.params.len); - defer cunit.a().free(llvm_param_types); + const llvm_param_types = try ofile.a().alloc(llvm.TypeRef, self.params.len); + defer ofile.a().free(llvm_param_types); for (llvm_param_types) |*llvm_param_type, i| { - llvm_param_type.* = try self.params[i].typeof.getLlvmType(cunit); + llvm_param_type.* = try self.params[i].typeof.getLlvmType(ofile); } return llvm.FunctionType( @@ -160,13 +160,13 @@ pub const Type = struct { value: *Type, /// Adds 1 reference to the resulting type - pub fn get(module: *Module) *MetaType { - module.meta_type.base.base.ref(); - return module.meta_type; + pub fn get(comp: *Compilation) *MetaType { + comp.meta_type.base.base.ref(); + return comp.meta_type; } - pub fn destroy(self: *MetaType, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *MetaType, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -174,13 +174,13 @@ pub const Type = struct { base: Type, /// Adds 1 reference to the resulting type - pub fn get(module: *Module) *Void { - module.void_type.base.base.ref(); - return module.void_type; + pub fn get(comp: *Compilation) *Void { + comp.void_type.base.base.ref(); + return comp.void_type; } - pub fn destroy(self: *Void, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Void, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -188,16 +188,16 @@ pub const Type = struct { base: Type, /// Adds 1 reference to the resulting type - pub fn get(module: *Module) *Bool { - module.bool_type.base.base.ref(); - return module.bool_type; + pub fn get(comp: *Compilation) *Bool { + comp.bool_type.base.base.ref(); + return comp.bool_type; } - pub fn destroy(self: *Bool, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Bool, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Bool, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Bool, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -206,24 +206,24 @@ pub const Type = struct { base: Type, /// Adds 1 reference to the resulting type - pub fn get(module: *Module) *NoReturn { - module.noreturn_type.base.base.ref(); - return module.noreturn_type; + pub fn get(comp: *Compilation) *NoReturn { + comp.noreturn_type.base.base.ref(); + return comp.noreturn_type; } - pub fn destroy(self: *NoReturn, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *NoReturn, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Int = struct { base: Type, - pub fn destroy(self: *Int, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Int, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Int, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Int, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -231,11 +231,11 @@ pub const Type = struct { pub const Float = struct { base: Type, - pub fn destroy(self: *Float, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Float, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Float, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Float, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -256,12 +256,12 @@ pub const Type = struct { }; pub const Size = builtin.TypeInfo.Pointer.Size; - pub fn destroy(self: *Pointer, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Pointer, comp: *Compilation) void { + comp.a().destroy(self); } pub fn get( - module: *Module, + comp: *Compilation, elem_type: *Type, mut: Mut, vol: Vol, @@ -271,7 +271,7 @@ pub const Type = struct { @panic("TODO get pointer"); } - pub fn getLlvmType(self: *Pointer, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Pointer, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -279,11 +279,11 @@ pub const Type = struct { pub const Array = struct { base: Type, - pub fn destroy(self: *Array, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Array, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Array, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Array, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -291,43 +291,43 @@ pub const Type = struct { pub const ComptimeFloat = struct { base: Type, - pub fn destroy(self: *ComptimeFloat, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *ComptimeFloat, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const ComptimeInt = struct { base: Type, - pub fn destroy(self: *ComptimeInt, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *ComptimeInt, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Undefined = struct { base: Type, - pub fn destroy(self: *Undefined, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Undefined, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Null = struct { base: Type, - pub fn destroy(self: *Null, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Null, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Optional = struct { base: Type, - pub fn destroy(self: *Optional, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Optional, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Optional, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Optional, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -335,11 +335,11 @@ pub const Type = struct { pub const ErrorUnion = struct { base: Type, - pub fn destroy(self: *ErrorUnion, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *ErrorUnion, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *ErrorUnion, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *ErrorUnion, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -347,11 +347,11 @@ pub const Type = struct { pub const ErrorSet = struct { base: Type, - pub fn destroy(self: *ErrorSet, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *ErrorSet, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *ErrorSet, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *ErrorSet, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -359,11 +359,11 @@ pub const Type = struct { pub const Enum = struct { base: Type, - pub fn destroy(self: *Enum, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Enum, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Enum, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Enum, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -371,11 +371,11 @@ pub const Type = struct { pub const Union = struct { base: Type, - pub fn destroy(self: *Union, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Union, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Union, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Union, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -383,27 +383,27 @@ pub const Type = struct { pub const Namespace = struct { base: Type, - pub fn destroy(self: *Namespace, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Namespace, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Block = struct { base: Type, - pub fn destroy(self: *Block, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Block, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const BoundFn = struct { base: Type, - pub fn destroy(self: *BoundFn, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *BoundFn, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *BoundFn, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *BoundFn, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -411,19 +411,19 @@ pub const Type = struct { pub const ArgTuple = struct { base: Type, - pub fn destroy(self: *ArgTuple, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *ArgTuple, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const Opaque = struct { base: Type, - pub fn destroy(self: *Opaque, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Opaque, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Opaque, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Opaque, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; @@ -431,11 +431,11 @@ pub const Type = struct { pub const Promise = struct { base: Type, - pub fn destroy(self: *Promise, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Promise, comp: *Compilation) void { + comp.a().destroy(self); } - pub fn getLlvmType(self: *Promise, cunit: *CompilationUnit) llvm.TypeRef { + pub fn getLlvmType(self: *Promise, ofile: *ObjectFile) llvm.TypeRef { @panic("TODO"); } }; diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig index 779e5c2e45..8c047b1513 100644 --- a/src-self-hosted/value.zig +++ b/src-self-hosted/value.zig @@ -1,7 +1,7 @@ const std = @import("std"); const builtin = @import("builtin"); const Scope = @import("scope.zig").Scope; -const Module = @import("module.zig").Module; +const Compilation = @import("compilation.zig").Compilation; /// Values are ref-counted, heap-allocated, and copy-on-write /// If there is only 1 ref then write need not copy @@ -16,16 +16,16 @@ pub const Value = struct { } /// Thread-safe - pub fn deref(base: *Value, module: *Module) void { + pub fn deref(base: *Value, comp: *Compilation) void { if (base.ref_count.decr() == 1) { - base.typeof.base.deref(module); + base.typeof.base.deref(comp); switch (base.id) { - Id.Type => @fieldParentPtr(Type, "base", base).destroy(module), - Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(module), - Id.Void => @fieldParentPtr(Void, "base", base).destroy(module), - Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(module), - Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(module), - Id.Ptr => @fieldParentPtr(Ptr, "base", base).destroy(module), + Id.Type => @fieldParentPtr(Type, "base", base).destroy(comp), + Id.Fn => @fieldParentPtr(Fn, "base", base).destroy(comp), + Id.Void => @fieldParentPtr(Void, "base", base).destroy(comp), + Id.Bool => @fieldParentPtr(Bool, "base", base).destroy(comp), + Id.NoReturn => @fieldParentPtr(NoReturn, "base", base).destroy(comp), + Id.Ptr => @fieldParentPtr(Ptr, "base", base).destroy(comp), } } } @@ -68,8 +68,8 @@ pub const Value = struct { /// Creates a Fn value with 1 ref /// Takes ownership of symbol_name - pub fn create(module: *Module, fn_type: *Type.Fn, fndef_scope: *Scope.FnDef, symbol_name: std.Buffer) !*Fn { - const self = try module.a().create(Fn{ + pub fn create(comp: *Compilation, fn_type: *Type.Fn, fndef_scope: *Scope.FnDef, symbol_name: std.Buffer) !*Fn { + const self = try comp.a().create(Fn{ .base = Value{ .id = Value.Id.Fn, .typeof = &fn_type.base, @@ -86,23 +86,23 @@ pub const Value = struct { return self; } - pub fn destroy(self: *Fn, module: *Module) void { - self.fndef_scope.base.deref(module); + pub fn destroy(self: *Fn, comp: *Compilation) void { + self.fndef_scope.base.deref(comp); self.symbol_name.deinit(); - module.a().destroy(self); + comp.a().destroy(self); } }; pub const Void = struct { base: Value, - pub fn get(module: *Module) *Void { - module.void_value.base.ref(); - return module.void_value; + pub fn get(comp: *Compilation) *Void { + comp.void_value.base.ref(); + return comp.void_value; } - pub fn destroy(self: *Void, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Void, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -110,31 +110,31 @@ pub const Value = struct { base: Value, x: bool, - pub fn get(module: *Module, x: bool) *Bool { + pub fn get(comp: *Compilation, x: bool) *Bool { if (x) { - module.true_value.base.ref(); - return module.true_value; + comp.true_value.base.ref(); + return comp.true_value; } else { - module.false_value.base.ref(); - return module.false_value; + comp.false_value.base.ref(); + return comp.false_value; } } - pub fn destroy(self: *Bool, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Bool, comp: *Compilation) void { + comp.a().destroy(self); } }; pub const NoReturn = struct { base: Value, - pub fn get(module: *Module) *NoReturn { - module.noreturn_value.base.ref(); - return module.noreturn_value; + pub fn get(comp: *Compilation) *NoReturn { + comp.noreturn_value.base.ref(); + return comp.noreturn_value; } - pub fn destroy(self: *NoReturn, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *NoReturn, comp: *Compilation) void { + comp.a().destroy(self); } }; @@ -147,8 +147,8 @@ pub const Value = struct { RunTime, }; - pub fn destroy(self: *Ptr, module: *Module) void { - module.a().destroy(self); + pub fn destroy(self: *Ptr, comp: *Compilation) void { + comp.a().destroy(self); } }; };