diff --git a/src-self-hosted/codegen.zig b/src-self-hosted/codegen.zig new file mode 100644 index 0000000000..df8f451856 --- /dev/null +++ b/src-self-hosted/codegen.zig @@ -0,0 +1,61 @@ +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; +// 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 +const llvm = @import("llvm.zig"); +const ir = @import("ir.zig"); +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 { + fn_val.base.ref(); + defer fn_val.base.deref(build); + defer code.destroy(build.a()); + + const llvm_handle = try build.event_loop_local.getAnyLlvmContext(); + defer llvm_handle.release(build.event_loop_local); + + const context = llvm_handle.node.data; + + const module = llvm.ModuleCreateWithNameInContext(build.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, + .module = module, + .builder = builder, + .context = context, + .lock = event.Lock.init(build.loop), + }; + + try renderToLlvmModule(&cunit, fn_val, code); + + if (build.verbose_llvm_ir) { + llvm.DumpModule(cunit.module); + } +} + +pub const CompilationUnit = struct { + build: *Build, + module: llvm.ModuleRef, + builder: llvm.BuilderRef, + context: llvm.ContextRef, + lock: event.Lock, + + fn a(self: *CompilationUnit) *std.mem.Allocator { + return self.build.a(); + } +}; + +pub fn renderToLlvmModule(cunit: *CompilationUnit, 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); +} diff --git a/src-self-hosted/ir.zig b/src-self-hosted/ir.zig index 22161a0c27..f1c395a790 100644 --- a/src-self-hosted/ir.zig +++ b/src-self-hosted/ir.zig @@ -375,15 +375,8 @@ pub const Instruction = struct { pub fn analyze(self: *const AddImplicitReturnType, ira: *Analyze) !*Instruction { const target = try self.params.target.getAsParam(); - try ira.src_implicit_return_type_list.append(target); - - return ira.irb.build( - AddImplicitReturnType, - self.base.scope, - self.base.span, - Params{ .target = target }, - ); + return ira.irb.buildConstVoid(self.base.scope, self.base.span, true); } }; }; diff --git a/src-self-hosted/llvm.zig b/src-self-hosted/llvm.zig index 391a92cd63..b815f75b05 100644 --- a/src-self-hosted/llvm.zig +++ b/src-self-hosted/llvm.zig @@ -2,10 +2,27 @@ const builtin = @import("builtin"); const c = @import("c.zig"); const assert = @import("std").debug.assert; -pub const ValueRef = removeNullability(c.LLVMValueRef); -pub const ModuleRef = removeNullability(c.LLVMModuleRef); -pub const ContextRef = removeNullability(c.LLVMContextRef); pub const BuilderRef = removeNullability(c.LLVMBuilderRef); +pub const ContextRef = removeNullability(c.LLVMContextRef); +pub const ModuleRef = removeNullability(c.LLVMModuleRef); +pub const ValueRef = removeNullability(c.LLVMValueRef); +pub const TypeRef = removeNullability(c.LLVMTypeRef); + +pub const AddFunction = c.LLVMAddFunction; +pub const CreateBuilderInContext = c.LLVMCreateBuilderInContext; +pub const DisposeBuilder = c.LLVMDisposeBuilder; +pub const DisposeModule = c.LLVMDisposeModule; +pub const DumpModule = c.LLVMDumpModule; +pub const ModuleCreateWithNameInContext = c.LLVMModuleCreateWithNameInContext; +pub const VoidTypeInContext = c.LLVMVoidTypeInContext; + +pub const FunctionType = LLVMFunctionType; +extern fn LLVMFunctionType( + ReturnType: TypeRef, + ParamTypes: [*]TypeRef, + ParamCount: c_uint, + IsVarArg: c_int, +) ?TypeRef; fn removeNullability(comptime T: type) type { comptime assert(@typeId(T) == builtin.TypeId.Optional); diff --git a/src-self-hosted/main.zig b/src-self-hosted/main.zig index 972aaae9ac..77ec7f6d32 100644 --- a/src-self-hosted/main.zig +++ b/src-self-hosted/main.zig @@ -14,6 +14,7 @@ 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 Target = @import("target.zig").Target; const errmsg = @import("errmsg.zig"); @@ -386,9 +387,13 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Mo var loop: event.Loop = undefined; try loop.initMultiThreaded(allocator); + defer loop.deinit(); + + var event_loop_local = EventLoopLocal.init(&loop); + defer event_loop_local.deinit(); var module = try Module.create( - &loop, + &event_loop_local, root_name, root_source_file, Target.Native, diff --git a/src-self-hosted/module.zig b/src-self-hosted/module.zig index 3fbe6d54ad..617bd0d44a 100644 --- a/src-self-hosted/module.zig +++ b/src-self-hosted/module.zig @@ -25,14 +25,58 @@ const ParsedFile = @import("parsed_file.zig").ParsedFile; const Value = @import("value.zig").Value; const Type = Value.Type; const Span = errmsg.Span; +const codegen = @import("codegen.zig"); + +/// Data that is local to the event loop. +pub const EventLoopLocal = struct { + loop: *event.Loop, + llvm_handle_pool: std.atomic.Stack(llvm.ContextRef), + + fn init(loop: *event.Loop) EventLoopLocal { + return EventLoopLocal{ + .loop = loop, + .llvm_handle_pool = std.atomic.Stack(llvm.ContextRef).init(), + }; + } + + fn deinit(self: *EventLoopLocal) void { + while (self.llvm_handle_pool.pop()) |node| { + c.LLVMContextDispose(node.data); + self.loop.allocator.destroy(node); + } + } + + /// Gets an exclusive handle on any LlvmContext. + /// Caller must release the handle when done. + pub fn getAnyLlvmContext(self: *EventLoopLocal) !LlvmHandle { + if (self.llvm_handle_pool.pop()) |node| return LlvmHandle{ .node = node }; + + const context_ref = c.LLVMContextCreate() orelse return error.OutOfMemory; + errdefer c.LLVMContextDispose(context_ref); + + const node = try self.loop.allocator.create(std.atomic.Stack(llvm.ContextRef).Node{ + .next = undefined, + .data = context_ref, + }); + errdefer self.loop.allocator.destroy(node); + + return LlvmHandle{ .node = node }; + } +}; + +pub const LlvmHandle = struct { + node: *std.atomic.Stack(llvm.ContextRef).Node, + + pub fn release(self: LlvmHandle, event_loop_local: *EventLoopLocal) void { + event_loop_local.llvm_handle_pool.push(self.node); + } +}; pub const Module = struct { + event_loop_local: *EventLoopLocal, loop: *event.Loop, name: Buffer, root_src_path: ?[]const u8, - llvm_module: llvm.ModuleRef, - context: llvm.ContextRef, - builder: llvm.BuilderRef, target: Target, build_mode: builtin.Mode, zig_lib_dir: []const u8, @@ -187,7 +231,7 @@ pub const Module = struct { }; pub fn create( - loop: *event.Loop, + event_loop_local: *EventLoopLocal, name: []const u8, root_src_path: ?[]const u8, target: *const Target, @@ -196,29 +240,20 @@ pub const Module = struct { zig_lib_dir: []const u8, cache_dir: []const u8, ) !*Module { + const loop = event_loop_local.loop; + var name_buffer = try Buffer.init(loop.allocator, name); errdefer name_buffer.deinit(); - const context = c.LLVMContextCreate() orelse return error.OutOfMemory; - errdefer c.LLVMContextDispose(context); - - const llvm_module = c.LLVMModuleCreateWithNameInContext(name_buffer.ptr(), context) orelse return error.OutOfMemory; - errdefer c.LLVMDisposeModule(llvm_module); - - const builder = c.LLVMCreateBuilderInContext(context) orelse return error.OutOfMemory; - errdefer c.LLVMDisposeBuilder(builder); - const events = try event.Channel(Event).create(loop, 0); errdefer events.destroy(); const module = try loop.allocator.create(Module{ .loop = loop, + .event_loop_local = event_loop_local, .events = events, .name = name_buffer, .root_src_path = root_src_path, - .llvm_module = llvm_module, - .context = context, - .builder = builder, .target = target.*, .kind = kind, .build_mode = build_mode, @@ -290,7 +325,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Type, .typeof = undefined, - .ref_count = 3, // 3 because it references itself twice + .ref_count = std.atomic.Int(usize).init(3), // 3 because it references itself twice }, .id = builtin.TypeId.Type, }, @@ -305,7 +340,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Type, .typeof = &Type.MetaType.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Void, }, @@ -317,7 +352,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Type, .typeof = &Type.MetaType.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.NoReturn, }, @@ -329,7 +364,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Type, .typeof = &Type.MetaType.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Bool, }, @@ -340,7 +375,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Void, .typeof = &Type.Void.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, }); errdefer module.a().destroy(module.void_value); @@ -349,7 +384,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Bool, .typeof = &Type.Bool.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .x = true, }); @@ -359,7 +394,7 @@ pub const Module = struct { .base = Value{ .id = Value.Id.Bool, .typeof = &Type.Bool.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .x = false, }); @@ -369,16 +404,12 @@ pub const Module = struct { .base = Value{ .id = Value.Id.NoReturn, .typeof = &Type.NoReturn.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, }); errdefer module.a().destroy(module.noreturn_value); } - fn dump(self: *Module) void { - c.LLVMDumpModule(self.module); - } - pub fn destroy(self: *Module) void { self.noreturn_value.base.deref(self); self.void_value.base.deref(self); @@ -389,9 +420,6 @@ pub const Module = struct { self.meta_type.base.base.deref(self); self.events.destroy(); - c.LLVMDisposeBuilder(self.builder); - c.LLVMDisposeModule(self.llvm_module); - c.LLVMContextDispose(self.context); self.name.deinit(); self.a().destroy(self); @@ -657,10 +685,19 @@ async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { const fndef_scope = try Scope.FnDef.create(module, fn_decl.base.parent_scope); defer fndef_scope.base.deref(module); - const fn_type = try Type.Fn.create(module); + // 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 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_val = try Value.Fn.create(module, fn_type, fndef_scope); + var symbol_name = try std.Buffer.init(module.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); fn_decl.value = Decl.Fn.Val{ .Ok = fn_val }; @@ -674,6 +711,7 @@ async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { ) catch unreachable)) catch |err| switch (err) { // This poison value should not cause the errdefers to run. It simply means // that self.compile_errors is populated. + // TODO https://github.com/ziglang/zig/issues/769 error.SemanticAnalysisFailed => return {}, else => return err, }; @@ -692,14 +730,18 @@ async fn generateDeclFn(module: *Module, fn_decl: *Decl.Fn) !void { ) catch unreachable)) catch |err| switch (err) { // This poison value should not cause the errdefers to run. It simply means // that self.compile_errors is populated. + // TODO https://github.com/ziglang/zig/issues/769 error.SemanticAnalysisFailed => return {}, else => return err, }; - defer analyzed_code.destroy(module.a()); + errdefer analyzed_code.destroy(module.a()); if (module.verbose_ir) { std.debug.warn("analyzed:\n"); analyzed_code.dump(); } - // TODO now render to LLVM module + + // Kick off rendering to LLVM module, but it doesn't block the fn decl + // analysis from being complete. + try module.build_group.call(codegen.renderToLlvm, module, fn_val, analyzed_code); } diff --git a/src-self-hosted/test.zig b/src-self-hosted/test.zig index 4455352f95..e609eb2791 100644 --- a/src-self-hosted/test.zig +++ b/src-self-hosted/test.zig @@ -6,6 +6,7 @@ const Module = @import("module.zig").Module; const introspect = @import("introspect.zig"); const assertOrPanic = std.debug.assertOrPanic; const errmsg = @import("errmsg.zig"); +const EventLoopLocal = @import("module.zig").EventLoopLocal; test "compile errors" { var ctx: TestContext = undefined; @@ -22,6 +23,7 @@ const allocator = std.heap.c_allocator; pub const TestContext = struct { loop: std.event.Loop, + event_loop_local: EventLoopLocal, zig_lib_dir: []u8, zig_cache_dir: []u8, file_index: std.atomic.Int(usize), @@ -34,6 +36,7 @@ pub const TestContext = struct { self.* = TestContext{ .any_err = {}, .loop = undefined, + .event_loop_local = undefined, .zig_lib_dir = undefined, .zig_cache_dir = undefined, .group = undefined, @@ -43,6 +46,9 @@ pub const TestContext = struct { try self.loop.initMultiThreaded(allocator); errdefer self.loop.deinit(); + self.event_loop_local = EventLoopLocal.init(&self.loop); + errdefer self.event_loop_local.deinit(); + self.group = std.event.Group(error!void).init(&self.loop); errdefer self.group.cancelAll(); @@ -60,6 +66,7 @@ pub const TestContext = struct { std.os.deleteTree(allocator, tmp_dir_name) catch {}; allocator.free(self.zig_cache_dir); allocator.free(self.zig_lib_dir); + self.event_loop_local.deinit(); self.loop.deinit(); } @@ -83,7 +90,7 @@ pub const TestContext = struct { msg: []const u8, ) !void { var file_index_buf: [20]u8 = undefined; - const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.next()); + const file_index = try std.fmt.bufPrint(file_index_buf[0..], "{}", self.file_index.incr()); const file1_path = try std.os.path.join(allocator, tmp_dir_name, file_index, file1); if (std.os.path.dirname(file1_path)) |dirname| { @@ -94,7 +101,7 @@ pub const TestContext = struct { try std.io.writeFile(allocator, file1_path, source); var module = try Module.create( - &self.loop, + &self.event_loop_local, "test", file1_path, Target.Native, diff --git a/src-self-hosted/type.zig b/src-self-hosted/type.zig index 66e1470cc0..e4c31018a3 100644 --- a/src-self-hosted/type.zig +++ b/src-self-hosted/type.zig @@ -1,7 +1,10 @@ +const std = @import("std"); const builtin = @import("builtin"); const Scope = @import("scope.zig").Scope; const Module = @import("module.zig").Module; const Value = @import("value.zig").Value; +const llvm = @import("llvm.zig"); +const CompilationUnit = @import("codegen.zig").CompilationUnit; pub const Type = struct { base: Value, @@ -39,6 +42,36 @@ pub const Type = struct { } } + pub fn getLlvmType(base: *Type, cunit: *CompilationUnit) (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.Type => unreachable, + Id.Void => unreachable, + Id.Bool => return @fieldParentPtr(Bool, "base", base).getLlvmType(cunit), + 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.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.Namespace => unreachable, + Id.Block => unreachable, + Id.BoundFn => return @fieldParentPtr(BoundFn, "base", base).getLlvmType(cunit), + Id.ArgTuple => unreachable, + Id.Opaque => return @fieldParentPtr(Opaque, "base", base).getLlvmType(cunit), + Id.Promise => return @fieldParentPtr(Promise, "base", base).getLlvmType(cunit), + } + } + pub fn dump(base: *const Type) void { std.debug.warn("{}", @tagName(base.id)); } @@ -54,27 +87,72 @@ pub const Type = struct { pub fn destroy(self: *Struct, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Struct, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const Fn = struct { base: Type, + return_type: *Type, + params: []Param, + is_var_args: bool, - pub fn create(module: *Module) !*Fn { - return module.a().create(Fn{ + pub const Param = struct { + is_noalias: bool, + typeof: *Type, + }; + + pub fn create(module: *Module, return_type: *Type, params: []Param, is_var_args: bool) !*Fn { + const result = try module.a().create(Fn{ .base = Type{ .base = Value{ .id = Value.Id.Type, .typeof = &MetaType.get(module).base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .id = builtin.TypeId.Fn, }, + .return_type = return_type, + .params = params, + .is_var_args = is_var_args, }); + errdefer module.a().destroy(result); + + result.return_type.base.ref(); + for (result.params) |param| { + param.typeof.base.ref(); + } + return result; } pub fn destroy(self: *Fn, module: *Module) void { + self.return_type.base.deref(module); + for (self.params) |param| { + param.typeof.base.deref(module); + } module.a().destroy(self); } + + pub fn getLlvmType(self: *Fn, cunit: *CompilationUnit) !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), + }; + const llvm_param_types = try cunit.a().alloc(llvm.TypeRef, self.params.len); + defer cunit.a().free(llvm_param_types); + for (llvm_param_types) |*llvm_param_type, i| { + llvm_param_type.* = try self.params[i].typeof.getLlvmType(cunit); + } + + return llvm.FunctionType( + llvm_return_type, + llvm_param_types.ptr, + @intCast(c_uint, llvm_param_types.len), + @boolToInt(self.is_var_args), + ) orelse error.OutOfMemory; + } }; pub const MetaType = struct { @@ -118,6 +196,10 @@ pub const Type = struct { pub fn destroy(self: *Bool, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Bool, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const NoReturn = struct { @@ -140,6 +222,10 @@ pub const Type = struct { pub fn destroy(self: *Int, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Int, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const Float = struct { @@ -148,6 +234,10 @@ pub const Type = struct { pub fn destroy(self: *Float, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Float, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const Pointer = struct { base: Type, @@ -180,14 +270,24 @@ pub const Type = struct { ) *Pointer { @panic("TODO get pointer"); } + + pub fn getLlvmType(self: *Pointer, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const Array = struct { base: Type, pub fn destroy(self: *Array, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Array, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const ComptimeFloat = struct { base: Type, @@ -195,6 +295,7 @@ pub const Type = struct { module.a().destroy(self); } }; + pub const ComptimeInt = struct { base: Type, @@ -202,6 +303,7 @@ pub const Type = struct { module.a().destroy(self); } }; + pub const Undefined = struct { base: Type, @@ -209,6 +311,7 @@ pub const Type = struct { module.a().destroy(self); } }; + pub const Null = struct { base: Type, @@ -216,41 +319,67 @@ pub const Type = struct { module.a().destroy(self); } }; + pub const Optional = struct { base: Type, pub fn destroy(self: *Optional, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Optional, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const ErrorUnion = struct { base: Type, pub fn destroy(self: *ErrorUnion, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *ErrorUnion, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const ErrorSet = struct { base: Type, pub fn destroy(self: *ErrorSet, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *ErrorSet, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const Enum = struct { base: Type, pub fn destroy(self: *Enum, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Enum, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const Union = struct { base: Type, pub fn destroy(self: *Union, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Union, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; + pub const Namespace = struct { base: Type, @@ -273,6 +402,10 @@ pub const Type = struct { pub fn destroy(self: *BoundFn, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *BoundFn, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const ArgTuple = struct { @@ -289,6 +422,10 @@ pub const Type = struct { pub fn destroy(self: *Opaque, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Opaque, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; pub const Promise = struct { @@ -297,5 +434,9 @@ pub const Type = struct { pub fn destroy(self: *Promise, module: *Module) void { module.a().destroy(self); } + + pub fn getLlvmType(self: *Promise, cunit: *CompilationUnit) llvm.TypeRef { + @panic("TODO"); + } }; }; diff --git a/src-self-hosted/value.zig b/src-self-hosted/value.zig index 7ee594b41c..779e5c2e45 100644 --- a/src-self-hosted/value.zig +++ b/src-self-hosted/value.zig @@ -8,15 +8,16 @@ const Module = @import("module.zig").Module; pub const Value = struct { id: Id, typeof: *Type, - ref_count: usize, + ref_count: std.atomic.Int(usize), + /// Thread-safe pub fn ref(base: *Value) void { - base.ref_count += 1; + _ = base.ref_count.incr(); } + /// Thread-safe pub fn deref(base: *Value, module: *Module) void { - base.ref_count -= 1; - if (base.ref_count == 0) { + if (base.ref_count.decr() == 1) { base.typeof.base.deref(module); switch (base.id) { Id.Type => @fieldParentPtr(Type, "base", base).destroy(module), @@ -52,6 +53,10 @@ pub const Value = struct { pub const Fn = struct { base: Value, + /// The main external name that is used in the .o file. + /// TODO https://github.com/ziglang/zig/issues/265 + symbol_name: std.Buffer, + /// parent should be the top level decls or container decls fndef_scope: *Scope.FnDef, @@ -62,16 +67,18 @@ pub const Value = struct { block_scope: *Scope.Block, /// Creates a Fn value with 1 ref - pub fn create(module: *Module, fn_type: *Type.Fn, fndef_scope: *Scope.FnDef) !*Fn { + /// 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{ .base = Value{ .id = Value.Id.Fn, .typeof = &fn_type.base, - .ref_count = 1, + .ref_count = std.atomic.Int(usize).init(1), }, .fndef_scope = fndef_scope, .child_scope = &fndef_scope.base, .block_scope = undefined, + .symbol_name = symbol_name, }); fn_type.base.base.ref(); fndef_scope.fn_val = self; @@ -81,6 +88,7 @@ pub const Value = struct { pub fn destroy(self: *Fn, module: *Module) void { self.fndef_scope.base.deref(module); + self.symbol_name.deinit(); module.a().destroy(self); } }; diff --git a/std/atomic/int.zig b/std/atomic/int.zig index 7042bca78d..d51454c673 100644 --- a/std/atomic/int.zig +++ b/std/atomic/int.zig @@ -4,16 +4,26 @@ const AtomicOrder = builtin.AtomicOrder; /// Thread-safe, lock-free integer pub fn Int(comptime T: type) type { return struct { - value: T, + unprotected_value: T, pub const Self = this; pub fn init(init_val: T) Self { - return Self{ .value = init_val }; + return Self{ .unprotected_value = init_val }; } - pub fn next(self: *Self) T { - return @atomicRmw(T, &self.value, builtin.AtomicRmwOp.Add, 1, AtomicOrder.SeqCst); + /// Returns previous value + pub fn incr(self: *Self) T { + return @atomicRmw(T, &self.unprotected_value, builtin.AtomicRmwOp.Add, 1, AtomicOrder.SeqCst); + } + + /// Returns previous value + pub fn decr(self: *Self) T { + return @atomicRmw(T, &self.unprotected_value, builtin.AtomicRmwOp.Sub, 1, AtomicOrder.SeqCst); + } + + pub fn get(self: *Self) T { + return @atomicLoad(T, &self.unprotected_value, AtomicOrder.SeqCst); } }; } diff --git a/std/event/loop.zig b/std/event/loop.zig index ba75109a72..fc927592b9 100644 --- a/std/event/loop.zig +++ b/std/event/loop.zig @@ -101,7 +101,6 @@ pub const Loop = struct { errdefer self.deinitOsData(); } - /// must call stop before deinit pub fn deinit(self: *Loop) void { self.deinitOsData(); self.allocator.free(self.extra_threads);