Commit 97bfeac13f
Changed files (20)
src/zig_llvm.cpp
@@ -440,6 +440,11 @@ ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unreso
return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
}
+void ZigLLVMDisposeDIBuilder(ZigLLVMDIBuilder *dbuilder) {
+ DIBuilder *di_builder = reinterpret_cast<DIBuilder *>(dbuilder);
+ delete di_builder;
+}
+
void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, ZigLLVMDIScope *scope) {
unwrap(builder)->SetCurrentDebugLocation(DebugLoc::get(
line, column, reinterpret_cast<DIScope*>(scope)));
src/zig_llvm.h
@@ -39,7 +39,7 @@ struct ZigLLVMInsertionPoint;
ZIG_EXTERN_C void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R);
ZIG_EXTERN_C void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R);
-/// Caller must free memory.
+/// Caller must free memory with LLVMDisposeMessage
ZIG_EXTERN_C char *ZigLLVMGetHostCPUName(void);
ZIG_EXTERN_C char *ZigLLVMGetNativeFeatures(void);
@@ -139,6 +139,7 @@ ZIG_EXTERN_C unsigned ZigLLVMTag_DW_enumeration_type(void);
ZIG_EXTERN_C unsigned ZigLLVMTag_DW_union_type(void);
ZIG_EXTERN_C struct ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
+ZIG_EXTERN_C void ZigLLVMDisposeDIBuilder(struct ZigLLVMDIBuilder *dbuilder);
ZIG_EXTERN_C void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module);
ZIG_EXTERN_C void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module);
src-self-hosted/codegen.zig
@@ -1,19 +1,22 @@
const std = @import("std");
+const builtin = @import("builtin");
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
const llvm = @import("llvm.zig");
+const c = @import("c.zig");
const ir = @import("ir.zig");
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const event = std.event;
const assert = std.debug.assert;
+const DW = std.dwarf;
pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code) !void {
fn_val.base.ref();
defer fn_val.base.deref(comp);
- defer code.destroy(comp.a());
+ defer code.destroy(comp.gpa());
+
+ var output_path = try await (async comp.createRandomOutputPath(comp.target.oFileExt()) catch unreachable);
+ errdefer output_path.deinit();
const llvm_handle = try comp.event_loop_local.getAnyLlvmContext();
defer llvm_handle.release(comp.event_loop_local);
@@ -23,13 +26,56 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
const module = llvm.ModuleCreateWithNameInContext(comp.name.ptr(), context) orelse return error.OutOfMemory;
defer llvm.DisposeModule(module);
+ llvm.SetTarget(module, comp.llvm_triple.ptr());
+ llvm.SetDataLayout(module, comp.target_layout_str);
+
+ if (comp.target.getObjectFormat() == builtin.ObjectFormat.coff) {
+ llvm.AddModuleCodeViewFlag(module);
+ } else {
+ llvm.AddModuleDebugInfoFlag(module);
+ }
+
const builder = llvm.CreateBuilderInContext(context) orelse return error.OutOfMemory;
defer llvm.DisposeBuilder(builder);
+ const dibuilder = llvm.CreateDIBuilder(module, true) orelse return error.OutOfMemory;
+ defer llvm.DisposeDIBuilder(dibuilder);
+
+ // Don't use ZIG_VERSION_STRING here. LLVM misparses it when it includes
+ // the git revision.
+ const producer = try std.Buffer.allocPrint(
+ &code.arena.allocator,
+ "zig {}.{}.{}",
+ u32(c.ZIG_VERSION_MAJOR),
+ u32(c.ZIG_VERSION_MINOR),
+ u32(c.ZIG_VERSION_PATCH),
+ );
+ const flags = c"";
+ const runtime_version = 0;
+ const compile_unit_file = llvm.CreateFile(
+ dibuilder,
+ comp.name.ptr(),
+ comp.root_package.root_src_dir.ptr(),
+ ) orelse return error.OutOfMemory;
+ const is_optimized = comp.build_mode != builtin.Mode.Debug;
+ const compile_unit = llvm.CreateCompileUnit(
+ dibuilder,
+ DW.LANG_C99,
+ compile_unit_file,
+ producer.ptr(),
+ is_optimized,
+ flags,
+ runtime_version,
+ c"",
+ 0,
+ !comp.strip,
+ ) orelse return error.OutOfMemory;
+
var ofile = ObjectFile{
.comp = comp,
.module = module,
.builder = builder,
+ .dibuilder = dibuilder,
.context = context,
.lock = event.Lock.init(comp.loop),
};
@@ -41,8 +87,7 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
// LLVMSetModuleInlineAsm(g->module, buf_ptr(&g->global_asm));
//}
- // TODO
- //ZigLLVMDIBuilderFinalize(g->dbuilder);
+ llvm.DIBuilderFinalize(dibuilder);
if (comp.verbose_llvm_ir) {
llvm.DumpModule(ofile.module);
@@ -53,17 +98,42 @@ pub async fn renderToLlvm(comp: *Compilation, fn_val: *Value.Fn, code: *ir.Code)
var error_ptr: ?[*]u8 = null;
_ = llvm.VerifyModule(ofile.module, llvm.AbortProcessAction, &error_ptr);
}
+
+ assert(comp.emit_file_type == Compilation.Emit.Binary); // TODO support other types
+
+ const is_small = comp.build_mode == builtin.Mode.ReleaseSmall;
+ const is_debug = comp.build_mode == builtin.Mode.Debug;
+
+ var err_msg: [*]u8 = undefined;
+ // TODO integrate this with evented I/O
+ if (llvm.TargetMachineEmitToFile(
+ comp.target_machine,
+ module,
+ output_path.ptr(),
+ llvm.EmitBinary,
+ &err_msg,
+ is_debug,
+ is_small,
+ )) {
+ if (std.debug.runtime_safety) {
+ std.debug.panic("unable to write object file {}: {s}\n", output_path.toSliceConst(), err_msg);
+ }
+ return error.WritingObjectFileFailed;
+ }
+ //validate_inline_fns(g); TODO
+ fn_val.containing_object = output_path;
}
pub const ObjectFile = struct {
comp: *Compilation,
module: llvm.ModuleRef,
builder: llvm.BuilderRef,
+ dibuilder: *llvm.DIBuilder,
context: llvm.ContextRef,
lock: event.Lock,
- fn a(self: *ObjectFile) *std.mem.Allocator {
- return self.comp.a();
+ fn gpa(self: *ObjectFile) *std.mem.Allocator {
+ return self.comp.gpa();
}
};
src-self-hosted/compilation.zig
@@ -26,16 +26,31 @@ const Value = @import("value.zig").Value;
const Type = Value.Type;
const Span = errmsg.Span;
const codegen = @import("codegen.zig");
+const Package = @import("package.zig").Package;
/// 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 {
+ /// TODO pool these so that it doesn't have to lock
+ prng: event.Locked(std.rand.DefaultPrng),
+
+ var lazy_init_targets = std.lazyInit(void);
+
+ fn init(loop: *event.Loop) !EventLoopLocal {
+ lazy_init_targets.get() orelse {
+ Target.initializeAll();
+ lazy_init_targets.resolve();
+ };
+
+ var seed_bytes: [@sizeOf(u64)]u8 = undefined;
+ try std.os.getRandomBytes(seed_bytes[0..]);
+ const seed = std.mem.readInt(seed_bytes, u64, builtin.Endian.Big);
return EventLoopLocal{
.loop = loop,
.llvm_handle_pool = std.atomic.Stack(llvm.ContextRef).init(),
+ .prng = event.Locked(std.rand.DefaultPrng).init(loop, std.rand.DefaultPrng.init(seed)),
};
}
@@ -76,10 +91,16 @@ pub const Compilation = struct {
event_loop_local: *EventLoopLocal,
loop: *event.Loop,
name: Buffer,
+ llvm_triple: Buffer,
root_src_path: ?[]const u8,
target: Target,
+ llvm_target: llvm.TargetRef,
build_mode: builtin.Mode,
zig_lib_dir: []const u8,
+ zig_std_dir: []const u8,
+
+ /// lazily created when we need it
+ tmp_dir: event.Future(BuildError![]u8),
version_major: u32,
version_minor: u32,
@@ -106,8 +127,16 @@ pub const Compilation = struct {
lib_dirs: []const []const u8,
rpath_list: []const []const u8,
assembly_files: []const []const u8,
+
+ /// paths that are explicitly provided by the user to link against
link_objects: []const []const u8,
+ /// functions that have their own objects that we need to link
+ /// it uses an optional pointer so that tombstone removals are possible
+ fn_link_set: event.Locked(FnLinkSet),
+
+ pub const FnLinkSet = std.LinkedList(?*Value.Fn);
+
windows_subsystem_windows: bool,
windows_subsystem_console: bool,
@@ -141,7 +170,7 @@ pub const Compilation = struct {
/// Before code generation starts, must wait on this group to make sure
/// the build is complete.
- build_group: event.Group(BuildError!void),
+ prelink_group: event.Group(BuildError!void),
compile_errors: event.Locked(CompileErrList),
@@ -155,6 +184,16 @@ pub const Compilation = struct {
false_value: *Value.Bool,
noreturn_value: *Value.NoReturn,
+ target_machine: llvm.TargetMachineRef,
+ target_data_ref: llvm.TargetDataRef,
+ target_layout_str: [*]u8,
+
+ /// for allocating things which have the same lifetime as this Compilation
+ arena_allocator: std.heap.ArenaAllocator,
+
+ root_package: *Package,
+ std_package: *Package,
+
const CompileErrList = std.ArrayList(*errmsg.Msg);
// TODO handle some of these earlier and report them in a way other than error codes
@@ -195,6 +234,9 @@ pub const Compilation = struct {
BufferTooSmall,
Unimplemented, // TODO remove this one
SemanticAnalysisFailed, // TODO remove this one
+ ReadOnlyFileSystem,
+ LinkQuotaExceeded,
+ EnvironmentVariableNotFound,
};
pub const Event = union(enum) {
@@ -234,31 +276,31 @@ pub const Compilation = struct {
event_loop_local: *EventLoopLocal,
name: []const u8,
root_src_path: ?[]const u8,
- target: *const Target,
+ target: Target,
kind: Kind,
build_mode: builtin.Mode,
+ is_static: bool,
zig_lib_dir: []const u8,
cache_dir: []const u8,
) !*Compilation {
const loop = event_loop_local.loop;
-
- var name_buffer = try Buffer.init(loop.allocator, name);
- errdefer name_buffer.deinit();
-
- const events = try event.Channel(Event).create(loop, 0);
- errdefer events.destroy();
-
- const comp = try loop.allocator.create(Compilation{
+ const comp = try event_loop_local.loop.allocator.create(Compilation{
.loop = loop,
+ .arena_allocator = std.heap.ArenaAllocator.init(loop.allocator),
.event_loop_local = event_loop_local,
- .events = events,
- .name = name_buffer,
+ .events = undefined,
.root_src_path = root_src_path,
- .target = target.*,
+ .target = target,
+ .llvm_target = undefined,
.kind = kind,
.build_mode = build_mode,
.zig_lib_dir = zig_lib_dir,
+ .zig_std_dir = undefined,
.cache_dir = cache_dir,
+ .tmp_dir = event.Future(BuildError![]u8).init(loop),
+
+ .name = undefined,
+ .llvm_triple = undefined,
.version_major = 0,
.version_minor = 0,
@@ -283,7 +325,7 @@ pub const Compilation = struct {
.is_test = false,
.each_lib_rpath = false,
.strip = false,
- .is_static = false,
+ .is_static = is_static,
.linker_rdynamic = false,
.clang_argv = [][]const u8{},
.llvm_argv = [][]const u8{},
@@ -291,9 +333,10 @@ pub const Compilation = struct {
.rpath_list = [][]const u8{},
.assembly_files = [][]const u8{},
.link_objects = [][]const u8{},
+ .fn_link_set = event.Locked(FnLinkSet).init(loop, FnLinkSet.init()),
.windows_subsystem_windows = false,
.windows_subsystem_console = false,
- .link_libs_list = ArrayList(*LinkLib).init(loop.allocator),
+ .link_libs_list = undefined,
.libc_link_lib = null,
.err_color = errmsg.Color.Auto,
.darwin_frameworks = [][]const u8{},
@@ -303,7 +346,7 @@ pub const Compilation = struct {
.emit_file_type = Emit.Binary,
.link_out_file = null,
.exported_symbol_names = event.Locked(Decl.Table).init(loop, Decl.Table.init(loop.allocator)),
- .build_group = event.Group(BuildError!void).init(loop),
+ .prelink_group = event.Group(BuildError!void).init(loop),
.compile_errors = event.Locked(CompileErrList).init(loop, CompileErrList.init(loop.allocator)),
.meta_type = undefined,
@@ -314,13 +357,82 @@ pub const Compilation = struct {
.false_value = undefined,
.noreturn_type = undefined,
.noreturn_value = undefined,
+
+ .target_machine = undefined,
+ .target_data_ref = undefined,
+ .target_layout_str = undefined,
+
+ .root_package = undefined,
+ .std_package = undefined,
});
+ errdefer {
+ comp.arena_allocator.deinit();
+ comp.loop.allocator.destroy(comp);
+ }
+
+ comp.name = try Buffer.init(comp.arena(), name);
+ comp.llvm_triple = try target.getTriple(comp.arena());
+ comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);
+ comp.link_libs_list = ArrayList(*LinkLib).init(comp.arena());
+ comp.zig_std_dir = try std.os.path.join(comp.arena(), zig_lib_dir, "std");
+
+ const opt_level = switch (build_mode) {
+ builtin.Mode.Debug => llvm.CodeGenLevelNone,
+ else => llvm.CodeGenLevelAggressive,
+ };
+
+ const reloc_mode = if (is_static) llvm.RelocStatic else llvm.RelocPIC;
+
+ // LLVM creates invalid binaries on Windows sometimes.
+ // See https://github.com/ziglang/zig/issues/508
+ // As a workaround we do not use target native features on Windows.
+ var target_specific_cpu_args: ?[*]u8 = null;
+ var target_specific_cpu_features: ?[*]u8 = null;
+ errdefer llvm.DisposeMessage(target_specific_cpu_args);
+ errdefer llvm.DisposeMessage(target_specific_cpu_features);
+ if (target == Target.Native and !target.isWindows()) {
+ target_specific_cpu_args = llvm.GetHostCPUName() orelse return error.OutOfMemory;
+ target_specific_cpu_features = llvm.GetNativeFeatures() orelse return error.OutOfMemory;
+ }
+
+ comp.target_machine = llvm.CreateTargetMachine(
+ comp.llvm_target,
+ comp.llvm_triple.ptr(),
+ target_specific_cpu_args orelse c"",
+ target_specific_cpu_features orelse c"",
+ opt_level,
+ reloc_mode,
+ llvm.CodeModelDefault,
+ ) orelse return error.OutOfMemory;
+ errdefer llvm.DisposeTargetMachine(comp.target_machine);
+
+ comp.target_data_ref = llvm.CreateTargetDataLayout(comp.target_machine) orelse return error.OutOfMemory;
+ errdefer llvm.DisposeTargetData(comp.target_data_ref);
+
+ comp.target_layout_str = llvm.CopyStringRepOfTargetData(comp.target_data_ref) orelse return error.OutOfMemory;
+ errdefer llvm.DisposeMessage(comp.target_layout_str);
+
+ comp.events = try event.Channel(Event).create(comp.loop, 0);
+ errdefer comp.events.destroy();
+
+ if (root_src_path) |root_src| {
+ const dirname = std.os.path.dirname(root_src) orelse ".";
+ const basename = std.os.path.basename(root_src);
+
+ comp.root_package = try Package.create(comp.arena(), dirname, basename);
+ comp.std_package = try Package.create(comp.arena(), comp.zig_std_dir, "index.zig");
+ try comp.root_package.add("std", comp.std_package);
+ } else {
+ comp.root_package = try Package.create(comp.arena(), ".", "");
+ }
+
try comp.initTypes();
+
return comp;
}
fn initTypes(comp: *Compilation) !void {
- comp.meta_type = try comp.a().create(Type.MetaType{
+ comp.meta_type = try comp.gpa().create(Type.MetaType{
.base = Type{
.base = Value{
.id = Value.Id.Type,
@@ -333,9 +445,9 @@ pub const Compilation = struct {
});
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);
+ errdefer comp.gpa().destroy(comp.meta_type);
- comp.void_type = try comp.a().create(Type.Void{
+ comp.void_type = try comp.gpa().create(Type.Void{
.base = Type{
.base = Value{
.id = Value.Id.Type,
@@ -345,9 +457,9 @@ pub const Compilation = struct {
.id = builtin.TypeId.Void,
},
});
- errdefer comp.a().destroy(comp.void_type);
+ errdefer comp.gpa().destroy(comp.void_type);
- comp.noreturn_type = try comp.a().create(Type.NoReturn{
+ comp.noreturn_type = try comp.gpa().create(Type.NoReturn{
.base = Type{
.base = Value{
.id = Value.Id.Type,
@@ -357,9 +469,9 @@ pub const Compilation = struct {
.id = builtin.TypeId.NoReturn,
},
});
- errdefer comp.a().destroy(comp.noreturn_type);
+ errdefer comp.gpa().destroy(comp.noreturn_type);
- comp.bool_type = try comp.a().create(Type.Bool{
+ comp.bool_type = try comp.gpa().create(Type.Bool{
.base = Type{
.base = Value{
.id = Value.Id.Type,
@@ -369,18 +481,18 @@ pub const Compilation = struct {
.id = builtin.TypeId.Bool,
},
});
- errdefer comp.a().destroy(comp.bool_type);
+ errdefer comp.gpa().destroy(comp.bool_type);
- comp.void_value = try comp.a().create(Value.Void{
+ comp.void_value = try comp.gpa().create(Value.Void{
.base = Value{
.id = Value.Id.Void,
.typeof = &Type.Void.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
});
- errdefer comp.a().destroy(comp.void_value);
+ errdefer comp.gpa().destroy(comp.void_value);
- comp.true_value = try comp.a().create(Value.Bool{
+ comp.true_value = try comp.gpa().create(Value.Bool{
.base = Value{
.id = Value.Id.Bool,
.typeof = &Type.Bool.get(comp).base,
@@ -388,9 +500,9 @@ pub const Compilation = struct {
},
.x = true,
});
- errdefer comp.a().destroy(comp.true_value);
+ errdefer comp.gpa().destroy(comp.true_value);
- comp.false_value = try comp.a().create(Value.Bool{
+ comp.false_value = try comp.gpa().create(Value.Bool{
.base = Value{
.id = Value.Id.Bool,
.typeof = &Type.Bool.get(comp).base,
@@ -398,19 +510,23 @@ pub const Compilation = struct {
},
.x = false,
});
- errdefer comp.a().destroy(comp.false_value);
+ errdefer comp.gpa().destroy(comp.false_value);
- comp.noreturn_value = try comp.a().create(Value.NoReturn{
+ comp.noreturn_value = try comp.gpa().create(Value.NoReturn{
.base = Value{
.id = Value.Id.NoReturn,
.typeof = &Type.NoReturn.get(comp).base,
.ref_count = std.atomic.Int(usize).init(1),
},
});
- errdefer comp.a().destroy(comp.noreturn_value);
+ errdefer comp.gpa().destroy(comp.noreturn_value);
}
pub fn destroy(self: *Compilation) void {
+ if (self.tmp_dir.getOrNull()) |tmp_dir_result| if (tmp_dir_result.*) |tmp_dir| {
+ os.deleteTree(self.arena(), tmp_dir) catch {};
+ } else |_| {};
+
self.noreturn_value.base.deref(self);
self.void_value.base.deref(self);
self.false_value.base.deref(self);
@@ -420,14 +536,18 @@ pub const Compilation = struct {
self.meta_type.base.base.deref(self);
self.events.destroy();
- self.name.deinit();
- self.a().destroy(self);
+ llvm.DisposeMessage(self.target_layout_str);
+ llvm.DisposeTargetData(self.target_data_ref);
+ llvm.DisposeTargetMachine(self.target_machine);
+
+ self.arena_allocator.deinit();
+ self.gpa().destroy(self);
}
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{
+ var c_compatible_args = try std.cstr.NullTerminated2DArray.fromSlices(self.arena(), [][]const []const u8{
[][]const u8{"zig (LLVM option parsing)"},
self.llvm_argv,
});
@@ -436,7 +556,7 @@ pub const Compilation = struct {
c.ZigLLVMParseCommandLineOptions(self.llvm_argv.len + 1, c_compatible_args.ptr);
}
- _ = try async<self.a()> self.buildAsync();
+ _ = try async<self.gpa()> self.buildAsync();
}
async fn buildAsync(self: *Compilation) void {
@@ -464,7 +584,7 @@ pub const Compilation = struct {
}
} else |err| {
// if there's an error then the compile errors have dangling references
- self.a().free(compile_errors);
+ self.gpa().free(compile_errors);
await (async self.events.put(Event{ .Error = err }) catch unreachable);
}
@@ -477,26 +597,26 @@ pub const Compilation = struct {
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| {
+ const root_src_real_path = os.path.real(self.gpa(), root_src_path) catch |err| {
try printError("unable to get real path '{}': {}", root_src_path, err);
return err;
};
- errdefer self.a().free(root_src_real_path);
+ errdefer self.gpa().free(root_src_real_path);
// TODO async/await readFileAlloc()
- const source_code = io.readFileAlloc(self.a(), root_src_real_path) catch |err| {
+ const source_code = io.readFileAlloc(self.gpa(), root_src_real_path) catch |err| {
try printError("unable to open '{}': {}", root_src_real_path, err);
return err;
};
- errdefer self.a().free(source_code);
+ errdefer self.gpa().free(source_code);
- const parsed_file = try self.a().create(ParsedFile{
+ const parsed_file = try self.gpa().create(ParsedFile{
.tree = undefined,
.realpath = root_src_real_path,
});
- errdefer self.a().destroy(parsed_file);
+ errdefer self.gpa().destroy(parsed_file);
- parsed_file.tree = try std.zig.parse(self.a(), source_code);
+ parsed_file.tree = try std.zig.parse(self.gpa(), source_code);
errdefer parsed_file.tree.deinit();
const tree = &parsed_file.tree;
@@ -525,7 +645,7 @@ pub const Compilation = struct {
continue;
};
- const fn_decl = try self.a().create(Decl.Fn{
+ const fn_decl = try self.gpa().create(Decl.Fn{
.base = Decl{
.id = Decl.Id.Fn,
.name = name,
@@ -538,7 +658,7 @@ pub const Compilation = struct {
.value = Decl.Fn.Val{ .Unresolved = {} },
.fn_proto = fn_proto,
});
- errdefer self.a().destroy(fn_decl);
+ errdefer self.gpa().destroy(fn_decl);
try decl_group.call(addTopLevelDecl, self, &fn_decl.base);
},
@@ -547,15 +667,15 @@ pub const Compilation = struct {
}
}
try await (async decl_group.wait() catch unreachable);
- try await (async self.build_group.wait() catch unreachable);
+ try await (async self.prelink_group.wait() catch unreachable);
}
async fn addTopLevelDecl(self: *Compilation, decl: *Decl) !void {
const is_export = decl.isExported(&decl.parsed_file.tree);
if (is_export) {
- try self.build_group.call(verifyUniqueSymbol, self, decl);
- try self.build_group.call(resolveDecl, self, decl);
+ try self.prelink_group.call(verifyUniqueSymbol, self, decl);
+ try self.prelink_group.call(resolveDecl, self, decl);
}
}
@@ -563,7 +683,7 @@ pub const Compilation = struct {
const text = try std.fmt.allocPrint(self.loop.allocator, fmt, args);
errdefer self.loop.allocator.free(text);
- try self.build_group.call(addCompileErrorAsync, self, parsed_file, span, text);
+ try self.prelink_group.call(addCompileErrorAsync, self, parsed_file, span, text);
}
async fn addCompileErrorAsync(
@@ -625,11 +745,11 @@ pub const Compilation = struct {
}
}
- const link_lib = try self.a().create(LinkLib{
+ const link_lib = try self.gpa().create(LinkLib{
.name = name,
.path = null,
.provided_explicitly = provided_explicitly,
- .symbols = ArrayList([]u8).init(self.a()),
+ .symbols = ArrayList([]u8).init(self.gpa()),
});
try self.link_libs_list.append(link_lib);
if (is_libc) {
@@ -638,9 +758,71 @@ pub const Compilation = struct {
return link_lib;
}
- fn a(self: Compilation) *mem.Allocator {
+ /// General Purpose Allocator. Must free when done.
+ fn gpa(self: Compilation) *mem.Allocator {
return self.loop.allocator;
}
+
+ /// Arena Allocator. Automatically freed when the Compilation is destroyed.
+ fn arena(self: *Compilation) *mem.Allocator {
+ return &self.arena_allocator.allocator;
+ }
+
+ /// If the temporary directory for this compilation has not been created, it creates it.
+ /// Then it creates a random file name in that dir and returns it.
+ pub async fn createRandomOutputPath(self: *Compilation, suffix: []const u8) !Buffer {
+ const tmp_dir = try await (async self.getTmpDir() catch unreachable);
+ const file_prefix = await (async self.getRandomFileName() catch unreachable);
+
+ const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);
+ defer self.gpa().free(file_name);
+
+ const full_path = try os.path.join(self.gpa(), tmp_dir, file_name[0..]);
+ errdefer self.gpa().free(full_path);
+
+ return Buffer.fromOwnedSlice(self.gpa(), full_path);
+ }
+
+ /// If the temporary directory for this Compilation has not been created, creates it.
+ /// Then returns it. The directory is unique to this Compilation and cleaned up when
+ /// the Compilation deinitializes.
+ async fn getTmpDir(self: *Compilation) ![]const u8 {
+ if (await (async self.tmp_dir.start() catch unreachable)) |ptr| return ptr.*;
+ self.tmp_dir.data = await (async self.getTmpDirImpl() catch unreachable);
+ self.tmp_dir.resolve();
+ return self.tmp_dir.data;
+ }
+
+ async fn getTmpDirImpl(self: *Compilation) ![]u8 {
+ const comp_dir_name = await (async self.getRandomFileName() catch unreachable);
+ const zig_dir_path = try getZigDir(self.gpa());
+ defer self.gpa().free(zig_dir_path);
+
+ const tmp_dir = try os.path.join(self.arena(), zig_dir_path, comp_dir_name[0..]);
+ try os.makePath(self.gpa(), tmp_dir);
+ return tmp_dir;
+ }
+
+ async fn getRandomFileName(self: *Compilation) [12]u8 {
+ // here we replace the standard +/ with -_ so that it can be used in a file name
+ const b64_fs_encoder = std.base64.Base64Encoder.init(
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+ std.base64.standard_pad_char,
+ );
+
+ var rand_bytes: [9]u8 = undefined;
+
+ {
+ const held = await (async self.event_loop_local.prng.acquire() catch unreachable);
+ defer held.release();
+
+ held.value.random.bytes(rand_bytes[0..]);
+ }
+
+ var result: [12]u8 = undefined;
+ b64_fs_encoder.encode(result[0..], rand_bytes);
+ return result;
+ }
};
fn printError(comptime format: []const u8, args: ...) !void {
@@ -662,13 +844,11 @@ 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(comp: *Compilation, decl: *Decl) !void {
- if (@atomicRmw(u8, &decl.resolution_in_progress, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst) == 0) {
- decl.resolution.data = await (async generateDecl(comp, decl) catch unreachable);
- decl.resolution.resolve();
- return decl.resolution.data;
- } else {
- return (await (async decl.resolution.get() catch unreachable)).*;
- }
+ if (await (async decl.resolution.start() catch unreachable)) |ptr| return ptr.*;
+
+ decl.resolution.data = await (async generateDecl(comp, decl) catch unreachable);
+ decl.resolution.resolve();
+ return decl.resolution.data;
}
/// The function that actually does the generation.
@@ -698,7 +878,7 @@ async fn generateDeclFn(comp: *Compilation, fn_decl: *Decl.Fn) !void {
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(comp.a(), fn_decl.base.name);
+ var symbol_name = try std.Buffer.init(comp.gpa(), fn_decl.base.name);
errdefer symbol_name.deinit();
const fn_val = try Value.Fn.create(comp, fn_type, fndef_scope, symbol_name);
@@ -719,7 +899,7 @@ async fn generateDeclFn(comp: *Compilation, fn_decl: *Decl.Fn) !void {
error.SemanticAnalysisFailed => return {},
else => return err,
};
- defer unanalyzed_code.destroy(comp.a());
+ defer unanalyzed_code.destroy(comp.gpa());
if (comp.verbose_ir) {
std.debug.warn("unanalyzed:\n");
@@ -738,7 +918,7 @@ async fn generateDeclFn(comp: *Compilation, fn_decl: *Decl.Fn) !void {
error.SemanticAnalysisFailed => return {},
else => return err,
};
- errdefer analyzed_code.destroy(comp.a());
+ errdefer analyzed_code.destroy(comp.gpa());
if (comp.verbose_ir) {
std.debug.warn("analyzed:\n");
@@ -747,5 +927,30 @@ async fn generateDeclFn(comp: *Compilation, fn_decl: *Decl.Fn) !void {
// Kick off rendering to LLVM module, but it doesn't block the fn decl
// analysis from being complete.
- try comp.build_group.call(codegen.renderToLlvm, comp, fn_val, analyzed_code);
+ try comp.prelink_group.call(codegen.renderToLlvm, comp, fn_val, analyzed_code);
+ try comp.prelink_group.call(addFnToLinkSet, comp, fn_val);
+}
+
+async fn addFnToLinkSet(comp: *Compilation, fn_val: *Value.Fn) void {
+ fn_val.base.ref();
+ defer fn_val.base.deref(comp);
+
+ fn_val.link_set_node.data = fn_val;
+
+ const held = await (async comp.fn_link_set.acquire() catch unreachable);
+ defer held.release();
+
+ held.value.append(fn_val.link_set_node);
+}
+
+fn getZigDir(allocator: *mem.Allocator) ![]u8 {
+ const home_dir = try getHomeDir(allocator);
+ defer allocator.free(home_dir);
+
+ return os.path.join(allocator, home_dir, ".zig");
+}
+
+/// TODO move to zig std lib, and make it work for other OSes
+fn getHomeDir(allocator: *mem.Allocator) ![]u8 {
+ return os.getEnvVarOwned(allocator, "HOME");
}
src-self-hosted/ir.zig
@@ -453,7 +453,7 @@ pub const Code = struct {
arena: std.heap.ArenaAllocator,
return_type: ?*Type,
- /// allocator is comp.a()
+ /// allocator is comp.gpa()
pub fn destroy(self: *Code, allocator: *Allocator) void {
self.arena.deinit();
allocator.destroy(self);
@@ -483,13 +483,13 @@ pub const Builder = struct {
pub const Error = Analyze.Error;
pub fn init(comp: *Compilation, parsed_file: *ParsedFile) !Builder {
- const code = try comp.a().create(Code{
+ const code = try comp.gpa().create(Code{
.basic_block_list = undefined,
- .arena = std.heap.ArenaAllocator.init(comp.a()),
+ .arena = std.heap.ArenaAllocator.init(comp.gpa()),
.return_type = null,
});
code.basic_block_list = std.ArrayList(*BasicBlock).init(&code.arena.allocator);
- errdefer code.destroy(comp.a());
+ errdefer code.destroy(comp.gpa());
return Builder{
.comp = comp,
@@ -502,7 +502,7 @@ pub const Builder = struct {
}
pub fn abort(self: *Builder) void {
- self.code.destroy(self.comp.a());
+ self.code.destroy(self.comp.gpa());
}
/// Call code.destroy() when done
src-self-hosted/llvm.zig
@@ -2,6 +2,12 @@ const builtin = @import("builtin");
const c = @import("c.zig");
const assert = @import("std").debug.assert;
+// we wrap the c module for 3 reasons:
+// 1. to avoid accidentally calling the non-thread-safe functions
+// 2. patch up some of the types to remove nullability
+// 3. some functions have been augmented by zig_llvm.cpp to be more powerful,
+// such as ZigLLVMTargetMachineEmitToFile
+
pub const AttributeIndex = c_uint;
pub const Bool = c_int;
@@ -12,25 +18,51 @@ pub const ValueRef = removeNullability(c.LLVMValueRef);
pub const TypeRef = removeNullability(c.LLVMTypeRef);
pub const BasicBlockRef = removeNullability(c.LLVMBasicBlockRef);
pub const AttributeRef = removeNullability(c.LLVMAttributeRef);
+pub const TargetRef = removeNullability(c.LLVMTargetRef);
+pub const TargetMachineRef = removeNullability(c.LLVMTargetMachineRef);
+pub const TargetDataRef = removeNullability(c.LLVMTargetDataRef);
+pub const DIBuilder = c.ZigLLVMDIBuilder;
pub const AddAttributeAtIndex = c.LLVMAddAttributeAtIndex;
pub const AddFunction = c.LLVMAddFunction;
+pub const AddModuleCodeViewFlag = c.ZigLLVMAddModuleCodeViewFlag;
+pub const AddModuleDebugInfoFlag = c.ZigLLVMAddModuleDebugInfoFlag;
pub const ClearCurrentDebugLocation = c.ZigLLVMClearCurrentDebugLocation;
+pub const ConstAllOnes = c.LLVMConstAllOnes;
pub const ConstInt = c.LLVMConstInt;
+pub const ConstNull = c.LLVMConstNull;
pub const ConstStringInContext = c.LLVMConstStringInContext;
pub const ConstStructInContext = c.LLVMConstStructInContext;
+pub const CopyStringRepOfTargetData = c.LLVMCopyStringRepOfTargetData;
pub const CreateBuilderInContext = c.LLVMCreateBuilderInContext;
+pub const CreateCompileUnit = c.ZigLLVMCreateCompileUnit;
+pub const CreateDIBuilder = c.ZigLLVMCreateDIBuilder;
pub const CreateEnumAttribute = c.LLVMCreateEnumAttribute;
+pub const CreateFile = c.ZigLLVMCreateFile;
pub const CreateStringAttribute = c.LLVMCreateStringAttribute;
+pub const CreateTargetDataLayout = c.LLVMCreateTargetDataLayout;
+pub const CreateTargetMachine = c.LLVMCreateTargetMachine;
+pub const DIBuilderFinalize = c.ZigLLVMDIBuilderFinalize;
pub const DisposeBuilder = c.LLVMDisposeBuilder;
+pub const DisposeDIBuilder = c.ZigLLVMDisposeDIBuilder;
+pub const DisposeMessage = c.LLVMDisposeMessage;
pub const DisposeModule = c.LLVMDisposeModule;
+pub const DisposeTargetData = c.LLVMDisposeTargetData;
+pub const DisposeTargetMachine = c.LLVMDisposeTargetMachine;
pub const DoubleTypeInContext = c.LLVMDoubleTypeInContext;
pub const DumpModule = c.LLVMDumpModule;
pub const FP128TypeInContext = c.LLVMFP128TypeInContext;
pub const FloatTypeInContext = c.LLVMFloatTypeInContext;
pub const GetEnumAttributeKindForName = c.LLVMGetEnumAttributeKindForName;
+pub const GetHostCPUName = c.ZigLLVMGetHostCPUName;
pub const GetMDKindIDInContext = c.LLVMGetMDKindIDInContext;
+pub const GetNativeFeatures = c.ZigLLVMGetNativeFeatures;
pub const HalfTypeInContext = c.LLVMHalfTypeInContext;
+pub const InitializeAllAsmParsers = c.LLVMInitializeAllAsmParsers;
+pub const InitializeAllAsmPrinters = c.LLVMInitializeAllAsmPrinters;
+pub const InitializeAllTargetInfos = c.LLVMInitializeAllTargetInfos;
+pub const InitializeAllTargetMCs = c.LLVMInitializeAllTargetMCs;
+pub const InitializeAllTargets = c.LLVMInitializeAllTargets;
pub const InsertBasicBlockInContext = c.LLVMInsertBasicBlockInContext;
pub const Int128TypeInContext = c.LLVMInt128TypeInContext;
pub const Int16TypeInContext = c.LLVMInt16TypeInContext;
@@ -47,13 +79,16 @@ pub const MDStringInContext = c.LLVMMDStringInContext;
pub const MetadataTypeInContext = c.LLVMMetadataTypeInContext;
pub const ModuleCreateWithNameInContext = c.LLVMModuleCreateWithNameInContext;
pub const PPCFP128TypeInContext = c.LLVMPPCFP128TypeInContext;
+pub const SetDataLayout = c.LLVMSetDataLayout;
+pub const SetTarget = c.LLVMSetTarget;
pub const StructTypeInContext = c.LLVMStructTypeInContext;
pub const TokenTypeInContext = c.LLVMTokenTypeInContext;
pub const VoidTypeInContext = c.LLVMVoidTypeInContext;
pub const X86FP80TypeInContext = c.LLVMX86FP80TypeInContext;
pub const X86MMXTypeInContext = c.LLVMX86MMXTypeInContext;
-pub const ConstAllOnes = c.LLVMConstAllOnes;
-pub const ConstNull = c.LLVMConstNull;
+
+pub const GetTargetFromTriple = LLVMGetTargetFromTriple;
+extern fn LLVMGetTargetFromTriple(Triple: [*]const u8, T: *TargetRef, ErrorMessage: ?*[*]u8) Bool;
pub const VerifyModule = LLVMVerifyModule;
extern fn LLVMVerifyModule(M: ModuleRef, Action: VerifierFailureAction, OutMessage: *?[*]u8) Bool;
@@ -83,6 +118,31 @@ pub const PrintMessageAction = VerifierFailureAction.LLVMPrintMessageAction;
pub const ReturnStatusAction = VerifierFailureAction.LLVMReturnStatusAction;
pub const VerifierFailureAction = c.LLVMVerifierFailureAction;
+pub const CodeGenLevelNone = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelNone;
+pub const CodeGenLevelLess = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelLess;
+pub const CodeGenLevelDefault = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
+pub const CodeGenLevelAggressive = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelAggressive;
+pub const CodeGenOptLevel = c.LLVMCodeGenOptLevel;
+
+pub const RelocDefault = c.LLVMRelocMode.LLVMRelocDefault;
+pub const RelocStatic = c.LLVMRelocMode.LLVMRelocStatic;
+pub const RelocPIC = c.LLVMRelocMode.LLVMRelocPIC;
+pub const RelocDynamicNoPic = c.LLVMRelocMode.LLVMRelocDynamicNoPic;
+pub const RelocMode = c.LLVMRelocMode;
+
+pub const CodeModelDefault = c.LLVMCodeModel.LLVMCodeModelDefault;
+pub const CodeModelJITDefault = c.LLVMCodeModel.LLVMCodeModelJITDefault;
+pub const CodeModelSmall = c.LLVMCodeModel.LLVMCodeModelSmall;
+pub const CodeModelKernel = c.LLVMCodeModel.LLVMCodeModelKernel;
+pub const CodeModelMedium = c.LLVMCodeModel.LLVMCodeModelMedium;
+pub const CodeModelLarge = c.LLVMCodeModel.LLVMCodeModelLarge;
+pub const CodeModel = c.LLVMCodeModel;
+
+pub const EmitAssembly = EmitOutputType.ZigLLVM_EmitAssembly;
+pub const EmitBinary = EmitOutputType.ZigLLVM_EmitBinary;
+pub const EmitLLVMIr = EmitOutputType.ZigLLVM_EmitLLVMIr;
+pub const EmitOutputType = c.ZigLLVM_EmitOutputType;
+
fn removeNullability(comptime T: type) type {
comptime assert(@typeId(T) == builtin.TypeId.Optional);
return T.Child;
@@ -90,3 +150,14 @@ fn removeNullability(comptime T: type) type {
pub const BuildRet = LLVMBuildRet;
extern fn LLVMBuildRet(arg0: BuilderRef, V: ?ValueRef) ValueRef;
+
+pub const TargetMachineEmitToFile = ZigLLVMTargetMachineEmitToFile;
+extern fn ZigLLVMTargetMachineEmitToFile(
+ targ_machine_ref: TargetMachineRef,
+ module_ref: ModuleRef,
+ filename: [*]const u8,
+ output_type: EmitOutputType,
+ error_message: *[*]u8,
+ is_debug: bool,
+ is_small: bool,
+) bool;
src-self-hosted/main.zig
@@ -363,6 +363,8 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
}
};
+ const is_static = flags.present("static");
+
const assembly_files = flags.many("assembly");
const link_objects = flags.many("object");
if (root_source_file == null and link_objects.len == 0 and assembly_files.len == 0) {
@@ -389,7 +391,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
try loop.initMultiThreaded(allocator);
defer loop.deinit();
- var event_loop_local = EventLoopLocal.init(&loop);
+ var event_loop_local = try EventLoopLocal.init(&loop);
defer event_loop_local.deinit();
var comp = try Compilation.create(
@@ -399,6 +401,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
Target.Native,
out_type,
build_mode,
+ is_static,
zig_lib_dir,
full_cache_dir,
);
@@ -426,7 +429,6 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
comp.clang_argv = clang_argv_buf.toSliceConst();
comp.strip = flags.present("strip");
- comp.is_static = flags.present("static");
if (flags.single("libc-lib-dir")) |libc_lib_dir| {
comp.libc_lib_dir = libc_lib_dir;
@@ -481,9 +483,9 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
}
comp.emit_file_type = emit_type;
- comp.link_objects = link_objects;
comp.assembly_files = assembly_files;
comp.link_out_file = flags.single("out-file");
+ comp.link_objects = link_objects;
try comp.build();
const process_build_events_handle = try async<loop.allocator> processBuildEvents(comp, color);
src-self-hosted/package.zig
@@ -0,0 +1,29 @@
+const std = @import("std");
+const mem = std.mem;
+const assert = std.debug.assert;
+const Buffer = std.Buffer;
+
+pub const Package = struct {
+ root_src_dir: Buffer,
+ root_src_path: Buffer,
+
+ /// relative to root_src_dir
+ table: Table,
+
+ pub const Table = std.HashMap([]const u8, *Package, mem.hash_slice_u8, mem.eql_slice_u8);
+
+ /// makes internal copies of root_src_dir and root_src_path
+ /// allocator should be an arena allocator because Package never frees anything
+ pub fn create(allocator: *mem.Allocator, root_src_dir: []const u8, root_src_path: []const u8) !*Package {
+ return allocator.create(Package{
+ .root_src_dir = try Buffer.init(allocator, root_src_dir),
+ .root_src_path = try Buffer.init(allocator, root_src_path),
+ .table = Table.init(allocator),
+ });
+ }
+
+ pub fn add(self: *Package, name: []const u8, package: *Package) !void {
+ const entry = try self.table.put(try mem.dupe(self.table.allocator, u8, name), package);
+ assert(entry == null);
+ }
+};
src-self-hosted/scope.zig
@@ -64,7 +64,7 @@ pub const Scope = struct {
/// Creates a Decls scope with 1 reference
pub fn create(comp: *Compilation, parent: ?*Scope) !*Decls {
- const self = try comp.a().create(Decls{
+ const self = try comp.gpa().create(Decls{
.base = Scope{
.id = Id.Decls,
.parent = parent,
@@ -72,9 +72,9 @@ pub const Scope = struct {
},
.table = undefined,
});
- errdefer comp.a().destroy(self);
+ errdefer comp.gpa().destroy(self);
- self.table = Decl.Table.init(comp.a());
+ self.table = Decl.Table.init(comp.gpa());
errdefer self.table.deinit();
if (parent) |p| p.ref();
@@ -126,7 +126,7 @@ pub const Scope = struct {
/// Creates a Block scope with 1 reference
pub fn create(comp: *Compilation, parent: ?*Scope) !*Block {
- const self = try comp.a().create(Block{
+ const self = try comp.gpa().create(Block{
.base = Scope{
.id = Id.Block,
.parent = parent,
@@ -138,14 +138,14 @@ pub const Scope = struct {
.is_comptime = undefined,
.safety = Safety.Auto,
});
- errdefer comp.a().destroy(self);
+ errdefer comp.gpa().destroy(self);
if (parent) |p| p.ref();
return self;
}
pub fn destroy(self: *Block, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -158,7 +158,7 @@ pub const Scope = struct {
/// Creates a FnDef scope with 1 reference
/// Must set the fn_val later
pub fn create(comp: *Compilation, parent: ?*Scope) !*FnDef {
- const self = try comp.a().create(FnDef{
+ const self = try comp.gpa().create(FnDef{
.base = Scope{
.id = Id.FnDef,
.parent = parent,
@@ -173,7 +173,7 @@ pub const Scope = struct {
}
pub fn destroy(self: *FnDef, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -182,7 +182,7 @@ pub const Scope = struct {
/// Creates a CompTime scope with 1 reference
pub fn create(comp: *Compilation, parent: ?*Scope) !*CompTime {
- const self = try comp.a().create(CompTime{
+ const self = try comp.gpa().create(CompTime{
.base = Scope{
.id = Id.CompTime,
.parent = parent,
@@ -195,7 +195,7 @@ pub const Scope = struct {
}
pub fn destroy(self: *CompTime, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -216,7 +216,7 @@ pub const Scope = struct {
kind: Kind,
defer_expr_scope: *DeferExpr,
) !*Defer {
- const self = try comp.a().create(Defer{
+ const self = try comp.gpa().create(Defer{
.base = Scope{
.id = Id.Defer,
.parent = parent,
@@ -225,7 +225,7 @@ pub const Scope = struct {
.defer_expr_scope = defer_expr_scope,
.kind = kind,
});
- errdefer comp.a().destroy(self);
+ errdefer comp.gpa().destroy(self);
defer_expr_scope.base.ref();
@@ -235,7 +235,7 @@ pub const Scope = struct {
pub fn destroy(self: *Defer, comp: *Compilation) void {
self.defer_expr_scope.base.deref(comp);
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -245,7 +245,7 @@ pub const Scope = struct {
/// Creates a DeferExpr scope with 1 reference
pub fn create(comp: *Compilation, parent: ?*Scope, expr_node: *ast.Node) !*DeferExpr {
- const self = try comp.a().create(DeferExpr{
+ const self = try comp.gpa().create(DeferExpr{
.base = Scope{
.id = Id.DeferExpr,
.parent = parent,
@@ -253,14 +253,14 @@ pub const Scope = struct {
},
.expr_node = expr_node,
});
- errdefer comp.a().destroy(self);
+ errdefer comp.gpa().destroy(self);
if (parent) |p| p.ref();
return self;
}
pub fn destroy(self: *DeferExpr, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
};
src-self-hosted/target.zig
@@ -1,60 +1,118 @@
+const std = @import("std");
const builtin = @import("builtin");
-const c = @import("c.zig");
-
-pub const CrossTarget = struct {
- arch: builtin.Arch,
- os: builtin.Os,
- environ: builtin.Environ,
-};
+const llvm = @import("llvm.zig");
pub const Target = union(enum) {
Native,
- Cross: CrossTarget,
+ Cross: Cross,
- pub fn oFileExt(self: *const Target) []const u8 {
- const environ = switch (self.*) {
- Target.Native => builtin.environ,
- Target.Cross => |t| t.environ,
- };
- return switch (environ) {
- builtin.Environ.msvc => ".obj",
+ pub const Cross = struct {
+ arch: builtin.Arch,
+ os: builtin.Os,
+ environ: builtin.Environ,
+ object_format: builtin.ObjectFormat,
+ };
+
+ pub fn oFileExt(self: Target) []const u8 {
+ return switch (self.getObjectFormat()) {
+ builtin.ObjectFormat.coff => ".obj",
else => ".o",
};
}
- pub fn exeFileExt(self: *const Target) []const u8 {
+ pub fn exeFileExt(self: Target) []const u8 {
return switch (self.getOs()) {
builtin.Os.windows => ".exe",
else => "",
};
}
- pub fn getOs(self: *const Target) builtin.Os {
- return switch (self.*) {
+ pub fn getOs(self: Target) builtin.Os {
+ return switch (self) {
Target.Native => builtin.os,
- Target.Cross => |t| t.os,
+ @TagType(Target).Cross => |t| t.os,
+ };
+ }
+
+ pub fn getArch(self: Target) builtin.Arch {
+ return switch (self) {
+ Target.Native => builtin.arch,
+ @TagType(Target).Cross => |t| t.arch,
+ };
+ }
+
+ pub fn getEnviron(self: Target) builtin.Environ {
+ return switch (self) {
+ Target.Native => builtin.environ,
+ @TagType(Target).Cross => |t| t.environ,
+ };
+ }
+
+ pub fn getObjectFormat(self: Target) builtin.ObjectFormat {
+ return switch (self) {
+ Target.Native => builtin.object_format,
+ @TagType(Target).Cross => |t| t.object_format,
};
}
- pub fn isDarwin(self: *const Target) bool {
+ pub fn isWasm(self: Target) bool {
+ return switch (self.getArch()) {
+ builtin.Arch.wasm32, builtin.Arch.wasm64 => true,
+ else => false,
+ };
+ }
+
+ pub fn isDarwin(self: Target) bool {
return switch (self.getOs()) {
builtin.Os.ios, builtin.Os.macosx => true,
else => false,
};
}
- pub fn isWindows(self: *const Target) bool {
+ pub fn isWindows(self: Target) bool {
return switch (self.getOs()) {
builtin.Os.windows => true,
else => false,
};
}
-};
-pub fn initializeAll() void {
- c.LLVMInitializeAllTargets();
- c.LLVMInitializeAllTargetInfos();
- c.LLVMInitializeAllTargetMCs();
- c.LLVMInitializeAllAsmPrinters();
- c.LLVMInitializeAllAsmParsers();
-}
+ pub fn initializeAll() void {
+ llvm.InitializeAllTargets();
+ llvm.InitializeAllTargetInfos();
+ llvm.InitializeAllTargetMCs();
+ llvm.InitializeAllAsmPrinters();
+ llvm.InitializeAllAsmParsers();
+ }
+
+ pub fn getTriple(self: Target, allocator: *std.mem.Allocator) !std.Buffer {
+ var result = try std.Buffer.initSize(allocator, 0);
+ errdefer result.deinit();
+
+ // LLVM WebAssembly output support requires the target to be activated at
+ // build type with -DCMAKE_LLVM_EXPIERMENTAL_TARGETS_TO_BUILD=WebAssembly.
+ //
+ // LLVM determines the output format based on the environment suffix,
+ // defaulting to an object based on the architecture. The default format in
+ // LLVM 6 sets the wasm arch output incorrectly to ELF. We need to
+ // explicitly set this ourself in order for it to work.
+ //
+ // This is fixed in LLVM 7 and you will be able to get wasm output by
+ // using the target triple `wasm32-unknown-unknown-unknown`.
+ const env_name = if (self.isWasm()) "wasm" else @tagName(self.getEnviron());
+
+ var out = &std.io.BufferOutStream.init(&result).stream;
+ try out.print("{}-unknown-{}-{}", @tagName(self.getArch()), @tagName(self.getOs()), env_name);
+
+ return result;
+ }
+
+ pub fn llvmTargetFromTriple(triple: std.Buffer) !llvm.TargetRef {
+ var result: llvm.TargetRef = undefined;
+ var err_msg: [*]u8 = undefined;
+ if (llvm.GetTargetFromTriple(triple.ptr(), &result, &err_msg) != 0) {
+ std.debug.warn("triple: {s} error: {s}\n", triple.ptr(), err_msg);
+ return error.UnsupportedTarget;
+ }
+ return result;
+ }
+};
src-self-hosted/test.zig
@@ -46,7 +46,7 @@ pub const TestContext = struct {
try self.loop.initMultiThreaded(allocator);
errdefer self.loop.deinit();
- self.event_loop_local = EventLoopLocal.init(&self.loop);
+ self.event_loop_local = try EventLoopLocal.init(&self.loop);
errdefer self.event_loop_local.deinit();
self.group = std.event.Group(error!void).init(&self.loop);
@@ -107,6 +107,7 @@ pub const TestContext = struct {
Target.Native,
Compilation.Kind.Obj,
builtin.Mode.Debug,
+ true, // is_static
self.zig_lib_dir,
self.zig_cache_dir,
);
src-self-hosted/type.zig
@@ -160,7 +160,7 @@ pub const Type = struct {
decls: *Scope.Decls,
pub fn destroy(self: *Struct, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Struct, ofile: *ObjectFile) llvm.TypeRef {
@@ -180,7 +180,7 @@ pub const Type = struct {
};
pub fn create(comp: *Compilation, return_type: *Type, params: []Param, is_var_args: bool) !*Fn {
- const result = try comp.a().create(Fn{
+ const result = try comp.gpa().create(Fn{
.base = Type{
.base = Value{
.id = Value.Id.Type,
@@ -193,7 +193,7 @@ pub const Type = struct {
.params = params,
.is_var_args = is_var_args,
});
- errdefer comp.a().destroy(result);
+ errdefer comp.gpa().destroy(result);
result.return_type.base.ref();
for (result.params) |param| {
@@ -207,7 +207,7 @@ pub const Type = struct {
for (self.params) |param| {
param.typeof.base.deref(comp);
}
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Fn, ofile: *ObjectFile) !llvm.TypeRef {
@@ -215,8 +215,8 @@ pub const Type = struct {
Type.Id.Void => llvm.VoidTypeInContext(ofile.context) orelse return error.OutOfMemory,
else => try self.return_type.getLlvmType(ofile),
};
- const llvm_param_types = try ofile.a().alloc(llvm.TypeRef, self.params.len);
- defer ofile.a().free(llvm_param_types);
+ const llvm_param_types = try ofile.gpa().alloc(llvm.TypeRef, self.params.len);
+ defer ofile.gpa().free(llvm_param_types);
for (llvm_param_types) |*llvm_param_type, i| {
llvm_param_type.* = try self.params[i].typeof.getLlvmType(ofile);
}
@@ -241,7 +241,7 @@ pub const Type = struct {
}
pub fn destroy(self: *MetaType, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -255,7 +255,7 @@ pub const Type = struct {
}
pub fn destroy(self: *Void, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -269,7 +269,7 @@ pub const Type = struct {
}
pub fn destroy(self: *Bool, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Bool, ofile: *ObjectFile) llvm.TypeRef {
@@ -287,7 +287,7 @@ pub const Type = struct {
}
pub fn destroy(self: *NoReturn, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -295,7 +295,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Int, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Int, ofile: *ObjectFile) llvm.TypeRef {
@@ -307,7 +307,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Float, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Float, ofile: *ObjectFile) llvm.TypeRef {
@@ -332,7 +332,7 @@ pub const Type = struct {
pub const Size = builtin.TypeInfo.Pointer.Size;
pub fn destroy(self: *Pointer, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn get(
@@ -355,7 +355,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Array, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Array, ofile: *ObjectFile) llvm.TypeRef {
@@ -367,7 +367,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *ComptimeFloat, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -375,7 +375,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *ComptimeInt, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -383,7 +383,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Undefined, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -391,7 +391,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Null, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -399,7 +399,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Optional, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Optional, ofile: *ObjectFile) llvm.TypeRef {
@@ -411,7 +411,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *ErrorUnion, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *ErrorUnion, ofile: *ObjectFile) llvm.TypeRef {
@@ -423,7 +423,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *ErrorSet, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *ErrorSet, ofile: *ObjectFile) llvm.TypeRef {
@@ -435,7 +435,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Enum, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Enum, ofile: *ObjectFile) llvm.TypeRef {
@@ -447,7 +447,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Union, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Union, ofile: *ObjectFile) llvm.TypeRef {
@@ -459,7 +459,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Namespace, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -467,7 +467,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Block, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -475,7 +475,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *BoundFn, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *BoundFn, ofile: *ObjectFile) llvm.TypeRef {
@@ -487,7 +487,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *ArgTuple, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -495,7 +495,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Opaque, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Opaque, ofile: *ObjectFile) llvm.TypeRef {
@@ -507,7 +507,7 @@ pub const Type = struct {
base: Type,
pub fn destroy(self: *Promise, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmType(self: *Promise, ofile: *ObjectFile) llvm.TypeRef {
src-self-hosted/value.zig
@@ -4,6 +4,7 @@ const Scope = @import("scope.zig").Scope;
const Compilation = @import("compilation.zig").Compilation;
const ObjectFile = @import("codegen.zig").ObjectFile;
const llvm = @import("llvm.zig");
+const Buffer = std.Buffer;
/// Values are ref-counted, heap-allocated, and copy-on-write
/// If there is only 1 ref then write need not copy
@@ -68,7 +69,7 @@ pub const Value = struct {
/// The main external name that is used in the .o file.
/// TODO https://github.com/ziglang/zig/issues/265
- symbol_name: std.Buffer,
+ symbol_name: Buffer,
/// parent should be the top level decls or container decls
fndef_scope: *Scope.FnDef,
@@ -79,10 +80,22 @@ pub const Value = struct {
/// parent is child_scope
block_scope: *Scope.Block,
+ /// Path to the object file that contains this function
+ containing_object: Buffer,
+
+ link_set_node: *std.LinkedList(?*Value.Fn).Node,
+
/// Creates a Fn value with 1 ref
/// Takes ownership of symbol_name
- 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{
+ pub fn create(comp: *Compilation, fn_type: *Type.Fn, fndef_scope: *Scope.FnDef, symbol_name: Buffer) !*Fn {
+ const link_set_node = try comp.gpa().create(Compilation.FnLinkSet.Node{
+ .data = null,
+ .next = undefined,
+ .prev = undefined,
+ });
+ errdefer comp.gpa().destroy(link_set_node);
+
+ const self = try comp.gpa().create(Fn{
.base = Value{
.id = Value.Id.Fn,
.typeof = &fn_type.base,
@@ -92,6 +105,8 @@ pub const Value = struct {
.child_scope = &fndef_scope.base,
.block_scope = undefined,
.symbol_name = symbol_name,
+ .containing_object = Buffer.initNull(comp.gpa()),
+ .link_set_node = link_set_node,
});
fn_type.base.base.ref();
fndef_scope.fn_val = self;
@@ -100,9 +115,19 @@ pub const Value = struct {
}
pub fn destroy(self: *Fn, comp: *Compilation) void {
+ // remove with a tombstone so that we do not have to grab a lock
+ if (self.link_set_node.data != null) {
+ // it's now the job of the link step to find this tombstone and
+ // deallocate it.
+ self.link_set_node.data = null;
+ } else {
+ comp.gpa().destroy(self.link_set_node);
+ }
+
+ self.containing_object.deinit();
self.fndef_scope.base.deref(comp);
self.symbol_name.deinit();
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -115,7 +140,7 @@ pub const Value = struct {
}
pub fn destroy(self: *Void, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -134,7 +159,7 @@ pub const Value = struct {
}
pub fn destroy(self: *Bool, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
pub fn getLlvmConst(self: *Bool, ofile: *ObjectFile) ?llvm.ValueRef {
@@ -156,7 +181,7 @@ pub const Value = struct {
}
pub fn destroy(self: *NoReturn, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
@@ -170,7 +195,7 @@ pub const Value = struct {
};
pub fn destroy(self: *Ptr, comp: *Compilation) void {
- comp.a().destroy(self);
+ comp.gpa().destroy(self);
}
};
};
std/atomic/int.zig
@@ -25,5 +25,9 @@ pub fn Int(comptime T: type) type {
pub fn get(self: *Self) T {
return @atomicLoad(T, &self.unprotected_value, AtomicOrder.SeqCst);
}
+
+ pub fn xchg(self: *Self, new_value: T) T {
+ return @atomicRmw(T, &self.unprotected_value, builtin.AtomicRmwOp.Xchg, new_value, AtomicOrder.SeqCst);
+ }
};
}
std/event/future.zig
@@ -6,15 +6,20 @@ const AtomicOrder = builtin.AtomicOrder;
const Lock = std.event.Lock;
const Loop = std.event.Loop;
-/// This is a value that starts out unavailable, until a value is put().
+/// This is a value that starts out unavailable, until resolve() is called
/// While it is unavailable, coroutines suspend when they try to get() it,
-/// and then are resumed when the value is put().
-/// At this point the value remains forever available, and another put() is not allowed.
+/// and then are resumed when resolve() is called.
+/// At this point the value remains forever available, and another resolve() is not allowed.
pub fn Future(comptime T: type) type {
return struct {
lock: Lock,
data: T,
- available: u8, // TODO make this a bool
+
+ /// TODO make this an enum
+ /// 0 - not started
+ /// 1 - started
+ /// 2 - finished
+ available: u8,
const Self = this;
const Queue = std.atomic.Queue(promise);
@@ -31,7 +36,7 @@ pub fn Future(comptime T: type) type {
/// available.
/// Thread-safe.
pub async fn get(self: *Self) *T {
- if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 1) {
+ if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 2) {
return &self.data;
}
const held = await (async self.lock.acquire() catch unreachable);
@@ -43,18 +48,36 @@ pub fn Future(comptime T: type) type {
/// Gets the data without waiting for it. If it's available, a pointer is
/// returned. Otherwise, null is returned.
pub fn getOrNull(self: *Self) ?*T {
- if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 1) {
+ if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 2) {
return &self.data;
} else {
return null;
}
}
+ /// If someone else has started working on the data, wait for them to complete
+ /// and return a pointer to the data. Otherwise, return null, and the caller
+ /// should start working on the data.
+ /// It's not required to call start() before resolve() but it can be useful since
+ /// this method is thread-safe.
+ pub async fn start(self: *Self) ?*T {
+ const state = @cmpxchgStrong(u8, &self.available, 0, 1, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return null;
+ switch (state) {
+ 1 => {
+ const held = await (async self.lock.acquire() catch unreachable);
+ held.release();
+ return &self.data;
+ },
+ 2 => return &self.data,
+ else => unreachable,
+ }
+ }
+
/// Make the data become available. May be called only once.
/// Before calling this, modify the `data` property.
pub fn resolve(self: *Self) void {
- const prev = @atomicRmw(u8, &self.available, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
- assert(prev == 0); // put() called twice
+ const prev = @atomicRmw(u8, &self.available, AtomicRmwOp.Xchg, 2, AtomicOrder.SeqCst);
+ assert(prev == 0 or prev == 1); // resolve() called twice
Lock.Held.release(Lock.Held{ .lock = &self.lock });
}
};
std/buffer.zig
@@ -54,6 +54,19 @@ pub const Buffer = struct {
return result;
}
+ pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: ...) !Buffer {
+ const countSize = struct {
+ fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
+ size.* += bytes.len;
+ }
+ }.countSize;
+ var size: usize = 0;
+ std.fmt.format(&size, error{}, countSize, format, args) catch |err| switch (err) {};
+ var self = try Buffer.initSize(allocator, size);
+ assert((std.fmt.bufPrint(self.list.items, format, args) catch unreachable).len == size);
+ return self;
+ }
+
pub fn deinit(self: *Buffer) void {
self.list.deinit();
}
std/dwarf.zig
@@ -639,3 +639,40 @@ pub const LNE_define_file = 0x03;
pub const LNE_set_discriminator = 0x04;
pub const LNE_lo_user = 0x80;
pub const LNE_hi_user = 0xff;
+
+pub const LANG_C89 = 0x0001;
+pub const LANG_C = 0x0002;
+pub const LANG_Ada83 = 0x0003;
+pub const LANG_C_plus_plus = 0x0004;
+pub const LANG_Cobol74 = 0x0005;
+pub const LANG_Cobol85 = 0x0006;
+pub const LANG_Fortran77 = 0x0007;
+pub const LANG_Fortran90 = 0x0008;
+pub const LANG_Pascal83 = 0x0009;
+pub const LANG_Modula2 = 0x000a;
+pub const LANG_Java = 0x000b;
+pub const LANG_C99 = 0x000c;
+pub const LANG_Ada95 = 0x000d;
+pub const LANG_Fortran95 = 0x000e;
+pub const LANG_PLI = 0x000f;
+pub const LANG_ObjC = 0x0010;
+pub const LANG_ObjC_plus_plus = 0x0011;
+pub const LANG_UPC = 0x0012;
+pub const LANG_D = 0x0013;
+pub const LANG_Python = 0x0014;
+pub const LANG_Go = 0x0016;
+pub const LANG_C_plus_plus_11 = 0x001a;
+pub const LANG_Rust = 0x001c;
+pub const LANG_C11 = 0x001d;
+pub const LANG_C_plus_plus_14 = 0x0021;
+pub const LANG_Fortran03 = 0x0022;
+pub const LANG_Fortran08 = 0x0023;
+pub const LANG_lo_user = 0x8000;
+pub const LANG_hi_user = 0xffff;
+pub const LANG_Mips_Assembler = 0x8001;
+pub const LANG_Upc = 0x8765;
+pub const LANG_HP_Bliss = 0x8003;
+pub const LANG_HP_Basic91 = 0x8004;
+pub const LANG_HP_Pascal91 = 0x8005;
+pub const LANG_HP_IMacro = 0x8006;
+pub const LANG_HP_Assembler = 0x8007;
std/index.zig
@@ -36,6 +36,8 @@ pub const sort = @import("sort.zig");
pub const unicode = @import("unicode.zig");
pub const zig = @import("zig/index.zig");
+pub const lazyInit = @import("lazy_init.zig").lazyInit;
+
test "std" {
// run tests from these
_ = @import("atomic/index.zig");
@@ -71,4 +73,5 @@ test "std" {
_ = @import("sort.zig");
_ = @import("unicode.zig");
_ = @import("zig/index.zig");
+ _ = @import("lazy_init.zig");
}
std/lazy_init.zig
@@ -0,0 +1,85 @@
+const std = @import("index.zig");
+const builtin = @import("builtin");
+const assert = std.debug.assert;
+const AtomicRmwOp = builtin.AtomicRmwOp;
+const AtomicOrder = builtin.AtomicOrder;
+
+/// Thread-safe initialization of global data.
+/// TODO use a mutex instead of a spinlock
+pub fn lazyInit(comptime T: type) LazyInit(T) {
+ return LazyInit(T){
+ .data = undefined,
+ .state = 0,
+ };
+}
+
+fn LazyInit(comptime T: type) type {
+ return struct {
+ state: u8, // TODO make this an enum
+ data: Data,
+
+ const Self = this;
+
+ // TODO this isn't working for void, investigate and then remove this special case
+ const Data = if (@sizeOf(T) == 0) u8 else T;
+ const Ptr = if (T == void) void else *T;
+
+ /// Returns a usable pointer to the initialized data,
+ /// or returns null, indicating that the caller should
+ /// perform the initialization and then call resolve().
+ pub fn get(self: *Self) ?Ptr {
+ while (true) {
+ var state = @cmpxchgWeak(u8, &self.state, 0, 1, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return null;
+ switch (state) {
+ 0 => continue,
+ 1 => {
+ // TODO mutex instead of a spinlock
+ continue;
+ },
+ 2 => {
+ if (@sizeOf(T) == 0) {
+ return T(undefined);
+ } else {
+ return &self.data;
+ }
+ },
+ else => unreachable,
+ }
+ }
+ }
+
+ pub fn resolve(self: *Self) void {
+ const prev = @atomicRmw(u8, &self.state, AtomicRmwOp.Xchg, 2, AtomicOrder.SeqCst);
+ assert(prev == 1); // resolve() called twice
+ }
+ };
+}
+
+var global_number = lazyInit(i32);
+
+test "std.lazyInit" {
+ if (global_number.get()) |_| @panic("bad") else {
+ global_number.data = 1234;
+ global_number.resolve();
+ }
+ if (global_number.get()) |x| {
+ assert(x.* == 1234);
+ } else {
+ @panic("bad");
+ }
+ if (global_number.get()) |x| {
+ assert(x.* == 1234);
+ } else {
+ @panic("bad");
+ }
+}
+
+var global_void = lazyInit(void);
+
+test "std.lazyInit(void)" {
+ if (global_void.get()) |_| @panic("bad") else {
+ global_void.resolve();
+ }
+ assert(global_void.get() != null);
+ assert(global_void.get() != null);
+}
CMakeLists.txt
@@ -479,6 +479,7 @@ set(ZIG_STD_FILES
"index.zig"
"io.zig"
"json.zig"
+ "lazy_init.zig"
"linked_list.zig"
"macho.zig"
"math/acos.zig"