Commit 97bfeac13f89e1b5a22fcd7d4705341b4c3e1950 | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-07-16 20:52:50-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-07-16 20:52:50-04:00
log	97bfeac13f89e1b5a22fcd7d4705341b4c3e1950
tree	4a3e23a8b3908450b23f2dbba72e5f6c091d7114
parent	0fa24b6b7568557c29c9b3ee213ce2b06fcd6367

self-hosted: create tmp dir for .o files and emit .o file for fn

20 files changed, 808 insertions(+), 175 deletions(-)

CMakeLists.txt
src-self-hosted
src
- zig_llvm.cpp
- zig_llvm.h
std
- atomic
  - int.zig
- buffer.zig
- dwarf.zig
- event
  - future.zig
- index.zig
- lazy_init.zig

CMakeLists.txt+1

...	...	@@ -479,6 +479,7 @@ set(ZIG_STD_FILES
479	479	"index.zig"
480	480	"io.zig"
481	481	"json.zig"
	482	"lazy_init.zig"
482	483	"linked_list.zig"
483	484	"macho.zig"
484	485	"math/acos.zig"

src-self-hosted/codegen.zig+78-8

...	...	@@ -1,19 +1,22 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const Compilation = @import("compilation.zig").Compilation;
3		// we go through llvm instead of c for 2 reasons:
4		// 1. to avoid accidentally calling the non-thread-safe functions
5		// 2. patch up some of the types to remove nullability
6	4	const llvm = @import("llvm.zig");
	5	const c = @import("c.zig");
7	6	const ir = @import("ir.zig");
8	7	const Value = @import("value.zig").Value;
9	8	const Type = @import("type.zig").Type;
10	9	const event = std.event;
11	10	const assert = std.debug.assert;
	11	const DW = std.dwarf;
12	12
13	13	pub async fn renderToLlvm(comp: Compilation, fn_val: Value.Fn, code: *ir.Code) !void {
14	14	fn_val.base.ref();
15	15	defer fn_val.base.deref(comp);
16		defer code.destroy(comp.a());
	16	defer code.destroy(comp.gpa());
	17
	18	var output_path = try await (async comp.createRandomOutputPath(comp.target.oFileExt()) catch unreachable);
	19	errdefer output_path.deinit();
17	20
18	21	const llvm_handle = try comp.event_loop_local.getAnyLlvmContext();
19	22	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)
23	26	const module = llvm.ModuleCreateWithNameInContext(comp.name.ptr(), context) orelse return error.OutOfMemory;
24	27	defer llvm.DisposeModule(module);
25	28
	29	llvm.SetTarget(module, comp.llvm_triple.ptr());
	30	llvm.SetDataLayout(module, comp.target_layout_str);
	31
	32	if (comp.target.getObjectFormat() == builtin.ObjectFormat.coff) {
	33	llvm.AddModuleCodeViewFlag(module);
	34	} else {
	35	llvm.AddModuleDebugInfoFlag(module);
	36	}
	37
26	38	const builder = llvm.CreateBuilderInContext(context) orelse return error.OutOfMemory;
27	39	defer llvm.DisposeBuilder(builder);
28	40
	41	const dibuilder = llvm.CreateDIBuilder(module, true) orelse return error.OutOfMemory;
	42	defer llvm.DisposeDIBuilder(dibuilder);
	43
	44	// Don't use ZIG_VERSION_STRING here. LLVM misparses it when it includes
	45	// the git revision.
	46	const producer = try std.Buffer.allocPrint(
	47	&code.arena.allocator,
	48	"zig {}.{}.{}",
	49	u32(c.ZIG_VERSION_MAJOR),
	50	u32(c.ZIG_VERSION_MINOR),
	51	u32(c.ZIG_VERSION_PATCH),
	52	);
	53	const flags = c"";
	54	const runtime_version = 0;
	55	const compile_unit_file = llvm.CreateFile(
	56	dibuilder,
	57	comp.name.ptr(),
	58	comp.root_package.root_src_dir.ptr(),
	59	) orelse return error.OutOfMemory;
	60	const is_optimized = comp.build_mode != builtin.Mode.Debug;
	61	const compile_unit = llvm.CreateCompileUnit(
	62	dibuilder,
	63	DW.LANG_C99,
	64	compile_unit_file,
	65	producer.ptr(),
	66	is_optimized,
	67	flags,
	68	runtime_version,
	69	c"",
	70	0,
	71	!comp.strip,
	72	) orelse return error.OutOfMemory;
	73
29	74	var ofile = ObjectFile{
30	75	.comp = comp,
31	76	.module = module,
32	77	.builder = builder,
	78	.dibuilder = dibuilder,
33	79	.context = context,
34	80	.lock = event.Lock.init(comp.loop),
35	81	};
...	...	@@ -41,8 +87,7 @@ pub async fn renderToLlvm(comp: Compilation, fn_val: Value.Fn, code: *ir.Code)
41	87	// LLVMSetModuleInlineAsm(g->module, buf_ptr(&g->global_asm));
42	88	//}
43	89
44		// TODO
45		//ZigLLVMDIBuilderFinalize(g->dbuilder);
	90	llvm.DIBuilderFinalize(dibuilder);
46	91
47	92	if (comp.verbose_llvm_ir) {
48	93	llvm.DumpModule(ofile.module);
...	...	@@ -53,17 +98,42 @@ pub async fn renderToLlvm(comp: Compilation, fn_val: Value.Fn, code: *ir.Code)
53	98	var error_ptr: ?[*]u8 = null;
54	99	_ = llvm.VerifyModule(ofile.module, llvm.AbortProcessAction, &error_ptr);
55	100	}
	101
	102	assert(comp.emit_file_type == Compilation.Emit.Binary); // TODO support other types
	103
	104	const is_small = comp.build_mode == builtin.Mode.ReleaseSmall;
	105	const is_debug = comp.build_mode == builtin.Mode.Debug;
	106
	107	var err_msg: [*]u8 = undefined;
	108	// TODO integrate this with evented I/O
	109	if (llvm.TargetMachineEmitToFile(
	110	comp.target_machine,
	111	module,
	112	output_path.ptr(),
	113	llvm.EmitBinary,
	114	&err_msg,
	115	is_debug,
	116	is_small,
	117	)) {
	118	if (std.debug.runtime_safety) {
	119	std.debug.panic("unable to write object file {}: {s}\n", output_path.toSliceConst(), err_msg);
	120	}
	121	return error.WritingObjectFileFailed;
	122	}
	123	//validate_inline_fns(g); TODO
	124	fn_val.containing_object = output_path;
56	125	}
57	126
58	127	pub const ObjectFile = struct {
59	128	comp: *Compilation,
60	129	module: llvm.ModuleRef,
61	130	builder: llvm.BuilderRef,
	131	dibuilder: *llvm.DIBuilder,
62	132	context: llvm.ContextRef,
63	133	lock: event.Lock,
64	134
65		fn a(self: ObjectFile) std.mem.Allocator {
66		return self.comp.a();
	135	fn gpa(self: ObjectFile) std.mem.Allocator {
	136	return self.comp.gpa();
67	137	}
68	138	};
69	139

src-self-hosted/compilation.zig+270-65

...	...	@@ -26,16 +26,31 @@ const Value = @import("value.zig").Value;
26	26	const Type = Value.Type;
27	27	const Span = errmsg.Span;
28	28	const codegen = @import("codegen.zig");
	29	const Package = @import("package.zig").Package;
29	30
30	31	/// Data that is local to the event loop.
31	32	pub const EventLoopLocal = struct {
32	33	loop: *event.Loop,
33	34	llvm_handle_pool: std.atomic.Stack(llvm.ContextRef),
34	35
35		fn init(loop: *event.Loop) EventLoopLocal {
	36	/// TODO pool these so that it doesn't have to lock
	37	prng: event.Locked(std.rand.DefaultPrng),
	38
	39	var lazy_init_targets = std.lazyInit(void);
	40
	41	fn init(loop: *event.Loop) !EventLoopLocal {
	42	lazy_init_targets.get() orelse {
	43	Target.initializeAll();
	44	lazy_init_targets.resolve();
	45	};
	46
	47	var seed_bytes: [@sizeOf(u64)]u8 = undefined;
	48	try std.os.getRandomBytes(seed_bytes[0..]);
	49	const seed = std.mem.readInt(seed_bytes, u64, builtin.Endian.Big);
36	50	return EventLoopLocal{
37	51	.loop = loop,
38	52	.llvm_handle_pool = std.atomic.Stack(llvm.ContextRef).init(),
	53	.prng = event.Locked(std.rand.DefaultPrng).init(loop, std.rand.DefaultPrng.init(seed)),
39	54	};
40	55	}
41	56
...	...	@@ -76,10 +91,16 @@ pub const Compilation = struct {
76	91	event_loop_local: *EventLoopLocal,
77	92	loop: *event.Loop,
78	93	name: Buffer,
	94	llvm_triple: Buffer,
79	95	root_src_path: ?[]const u8,
80	96	target: Target,
	97	llvm_target: llvm.TargetRef,
81	98	build_mode: builtin.Mode,
82	99	zig_lib_dir: []const u8,
	100	zig_std_dir: []const u8,
	101
	102	/// lazily created when we need it
	103	tmp_dir: event.Future(BuildError![]u8),
83	104
84	105	version_major: u32,
85	106	version_minor: u32,
...	...	@@ -106,8 +127,16 @@ pub const Compilation = struct {
106	127	lib_dirs: []const []const u8,
107	128	rpath_list: []const []const u8,
108	129	assembly_files: []const []const u8,
	130
	131	/// paths that are explicitly provided by the user to link against
109	132	link_objects: []const []const u8,
110	133
	134	/// functions that have their own objects that we need to link
	135	/// it uses an optional pointer so that tombstone removals are possible
	136	fn_link_set: event.Locked(FnLinkSet),
	137
	138	pub const FnLinkSet = std.LinkedList(?*Value.Fn);
	139
111	140	windows_subsystem_windows: bool,
112	141	windows_subsystem_console: bool,
113	142
...	...	@@ -141,7 +170,7 @@ pub const Compilation = struct {
141	170
142	171	/// Before code generation starts, must wait on this group to make sure
143	172	/// the build is complete.
144		build_group: event.Group(BuildError!void),
	173	prelink_group: event.Group(BuildError!void),
145	174
146	175	compile_errors: event.Locked(CompileErrList),
147	176
...	...	@@ -155,6 +184,16 @@ pub const Compilation = struct {
155	184	false_value: *Value.Bool,
156	185	noreturn_value: *Value.NoReturn,
157	186
	187	target_machine: llvm.TargetMachineRef,
	188	target_data_ref: llvm.TargetDataRef,
	189	target_layout_str: [*]u8,
	190
	191	/// for allocating things which have the same lifetime as this Compilation
	192	arena_allocator: std.heap.ArenaAllocator,
	193
	194	root_package: *Package,
	195	std_package: *Package,
	196
158	197	const CompileErrList = std.ArrayList(*errmsg.Msg);
159	198
160	199	// TODO handle some of these earlier and report them in a way other than error codes
...	...	@@ -195,6 +234,9 @@ pub const Compilation = struct {
195	234	BufferTooSmall,
196	235	Unimplemented, // TODO remove this one
197	236	SemanticAnalysisFailed, // TODO remove this one
	237	ReadOnlyFileSystem,
	238	LinkQuotaExceeded,
	239	EnvironmentVariableNotFound,
198	240	};
199	241
200	242	pub const Event = union(enum) {
...	...	@@ -234,31 +276,31 @@ pub const Compilation = struct {
234	276	event_loop_local: *EventLoopLocal,
235	277	name: []const u8,
236	278	root_src_path: ?[]const u8,
237		target: *const Target,
	279	target: Target,
238	280	kind: Kind,
239	281	build_mode: builtin.Mode,
	282	is_static: bool,
240	283	zig_lib_dir: []const u8,
241	284	cache_dir: []const u8,
242	285	) !*Compilation {
243	286	const loop = event_loop_local.loop;
244
245		var name_buffer = try Buffer.init(loop.allocator, name);
246		errdefer name_buffer.deinit();
247
248		const events = try event.Channel(Event).create(loop, 0);
249		errdefer events.destroy();
250
251		const comp = try loop.allocator.create(Compilation{
	287	const comp = try event_loop_local.loop.allocator.create(Compilation{
252	288	.loop = loop,
	289	.arena_allocator = std.heap.ArenaAllocator.init(loop.allocator),
253	290	.event_loop_local = event_loop_local,
254		.events = events,
255		.name = name_buffer,
	291	.events = undefined,
256	292	.root_src_path = root_src_path,
257		.target = target.*,
	293	.target = target,
	294	.llvm_target = undefined,
258	295	.kind = kind,
259	296	.build_mode = build_mode,
260	297	.zig_lib_dir = zig_lib_dir,
	298	.zig_std_dir = undefined,
261	299	.cache_dir = cache_dir,
	300	.tmp_dir = event.Future(BuildError![]u8).init(loop),
	301
	302	.name = undefined,
	303	.llvm_triple = undefined,
262	304
263	305	.version_major = 0,
264	306	.version_minor = 0,
...	...	@@ -283,7 +325,7 @@ pub const Compilation = struct {
283	325	.is_test = false,
284	326	.each_lib_rpath = false,
285	327	.strip = false,
286		.is_static = false,
	328	.is_static = is_static,
287	329	.linker_rdynamic = false,
288	330	.clang_argv = [][]const u8{},
289	331	.llvm_argv = [][]const u8{},
...	...	@@ -291,9 +333,10 @@ pub const Compilation = struct {
291	333	.rpath_list = [][]const u8{},
292	334	.assembly_files = [][]const u8{},
293	335	.link_objects = [][]const u8{},
	336	.fn_link_set = event.Locked(FnLinkSet).init(loop, FnLinkSet.init()),
294	337	.windows_subsystem_windows = false,
295	338	.windows_subsystem_console = false,
296		.link_libs_list = ArrayList(*LinkLib).init(loop.allocator),
	339	.link_libs_list = undefined,
297	340	.libc_link_lib = null,
298	341	.err_color = errmsg.Color.Auto,
299	342	.darwin_frameworks = [][]const u8{},
...	...	@@ -303,7 +346,7 @@ pub const Compilation = struct {
303	346	.emit_file_type = Emit.Binary,
304	347	.link_out_file = null,
305	348	.exported_symbol_names = event.Locked(Decl.Table).init(loop, Decl.Table.init(loop.allocator)),
306		.build_group = event.Group(BuildError!void).init(loop),
	349	.prelink_group = event.Group(BuildError!void).init(loop),
307	350	.compile_errors = event.Locked(CompileErrList).init(loop, CompileErrList.init(loop.allocator)),
308	351
309	352	.meta_type = undefined,
...	...	@@ -314,13 +357,82 @@ pub const Compilation = struct {
314	357	.false_value = undefined,
315	358	.noreturn_type = undefined,
316	359	.noreturn_value = undefined,
	360
	361	.target_machine = undefined,
	362	.target_data_ref = undefined,
	363	.target_layout_str = undefined,
	364
	365	.root_package = undefined,
	366	.std_package = undefined,
317	367	});
	368	errdefer {
	369	comp.arena_allocator.deinit();
	370	comp.loop.allocator.destroy(comp);
	371	}
	372
	373	comp.name = try Buffer.init(comp.arena(), name);
	374	comp.llvm_triple = try target.getTriple(comp.arena());
	375	comp.llvm_target = try Target.llvmTargetFromTriple(comp.llvm_triple);
	376	comp.link_libs_list = ArrayList(*LinkLib).init(comp.arena());
	377	comp.zig_std_dir = try std.os.path.join(comp.arena(), zig_lib_dir, "std");
	378
	379	const opt_level = switch (build_mode) {
	380	builtin.Mode.Debug => llvm.CodeGenLevelNone,
	381	else => llvm.CodeGenLevelAggressive,
	382	};
	383
	384	const reloc_mode = if (is_static) llvm.RelocStatic else llvm.RelocPIC;
	385
	386	// LLVM creates invalid binaries on Windows sometimes.
	387	// See https://github.com/ziglang/zig/issues/508
	388	// As a workaround we do not use target native features on Windows.
	389	var target_specific_cpu_args: ?[*]u8 = null;
	390	var target_specific_cpu_features: ?[*]u8 = null;
	391	errdefer llvm.DisposeMessage(target_specific_cpu_args);
	392	errdefer llvm.DisposeMessage(target_specific_cpu_features);
	393	if (target == Target.Native and !target.isWindows()) {
	394	target_specific_cpu_args = llvm.GetHostCPUName() orelse return error.OutOfMemory;
	395	target_specific_cpu_features = llvm.GetNativeFeatures() orelse return error.OutOfMemory;
	396	}
	397
	398	comp.target_machine = llvm.CreateTargetMachine(
	399	comp.llvm_target,
	400	comp.llvm_triple.ptr(),
	401	target_specific_cpu_args orelse c"",
	402	target_specific_cpu_features orelse c"",
	403	opt_level,
	404	reloc_mode,
	405	llvm.CodeModelDefault,
	406	) orelse return error.OutOfMemory;
	407	errdefer llvm.DisposeTargetMachine(comp.target_machine);
	408
	409	comp.target_data_ref = llvm.CreateTargetDataLayout(comp.target_machine) orelse return error.OutOfMemory;
	410	errdefer llvm.DisposeTargetData(comp.target_data_ref);
	411
	412	comp.target_layout_str = llvm.CopyStringRepOfTargetData(comp.target_data_ref) orelse return error.OutOfMemory;
	413	errdefer llvm.DisposeMessage(comp.target_layout_str);
	414
	415	comp.events = try event.Channel(Event).create(comp.loop, 0);
	416	errdefer comp.events.destroy();
	417
	418	if (root_src_path) \|root_src\| {
	419	const dirname = std.os.path.dirname(root_src) orelse ".";
	420	const basename = std.os.path.basename(root_src);
	421
	422	comp.root_package = try Package.create(comp.arena(), dirname, basename);
	423	comp.std_package = try Package.create(comp.arena(), comp.zig_std_dir, "index.zig");
	424	try comp.root_package.add("std", comp.std_package);
	425	} else {
	426	comp.root_package = try Package.create(comp.arena(), ".", "");
	427	}
	428
318	429	try comp.initTypes();
	430
319	431	return comp;
320	432	}
321	433
322	434	fn initTypes(comp: *Compilation) !void {
323		comp.meta_type = try comp.a().create(Type.MetaType{
	435	comp.meta_type = try comp.gpa().create(Type.MetaType{
324	436	.base = Type{
325	437	.base = Value{
326	438	.id = Value.Id.Type,
...	...	@@ -333,9 +445,9 @@ pub const Compilation = struct {
333	445	});
334	446	comp.meta_type.value = &comp.meta_type.base;
335	447	comp.meta_type.base.base.typeof = &comp.meta_type.base;
336		errdefer comp.a().destroy(comp.meta_type);
	448	errdefer comp.gpa().destroy(comp.meta_type);
337	449
338		comp.void_type = try comp.a().create(Type.Void{
	450	comp.void_type = try comp.gpa().create(Type.Void{
339	451	.base = Type{
340	452	.base = Value{
341	453	.id = Value.Id.Type,
...	...	@@ -345,9 +457,9 @@ pub const Compilation = struct {
345	457	.id = builtin.TypeId.Void,
346	458	},
347	459	});
348		errdefer comp.a().destroy(comp.void_type);
	460	errdefer comp.gpa().destroy(comp.void_type);
349	461
350		comp.noreturn_type = try comp.a().create(Type.NoReturn{
	462	comp.noreturn_type = try comp.gpa().create(Type.NoReturn{
351	463	.base = Type{
352	464	.base = Value{
353	465	.id = Value.Id.Type,
...	...	@@ -357,9 +469,9 @@ pub const Compilation = struct {
357	469	.id = builtin.TypeId.NoReturn,
358	470	},
359	471	});
360		errdefer comp.a().destroy(comp.noreturn_type);
	472	errdefer comp.gpa().destroy(comp.noreturn_type);
361	473
362		comp.bool_type = try comp.a().create(Type.Bool{
	474	comp.bool_type = try comp.gpa().create(Type.Bool{
363	475	.base = Type{
364	476	.base = Value{
365	477	.id = Value.Id.Type,
...	...	@@ -369,18 +481,18 @@ pub const Compilation = struct {
369	481	.id = builtin.TypeId.Bool,
370	482	},
371	483	});
372		errdefer comp.a().destroy(comp.bool_type);
	484	errdefer comp.gpa().destroy(comp.bool_type);
373	485
374		comp.void_value = try comp.a().create(Value.Void{
	486	comp.void_value = try comp.gpa().create(Value.Void{
375	487	.base = Value{
376	488	.id = Value.Id.Void,
377	489	.typeof = &Type.Void.get(comp).base,
378	490	.ref_count = std.atomic.Int(usize).init(1),
379	491	},
380	492	});
381		errdefer comp.a().destroy(comp.void_value);
	493	errdefer comp.gpa().destroy(comp.void_value);
382	494
383		comp.true_value = try comp.a().create(Value.Bool{
	495	comp.true_value = try comp.gpa().create(Value.Bool{
384	496	.base = Value{
385	497	.id = Value.Id.Bool,
386	498	.typeof = &Type.Bool.get(comp).base,
...	...	@@ -388,9 +500,9 @@ pub const Compilation = struct {
388	500	},
389	501	.x = true,
390	502	});
391		errdefer comp.a().destroy(comp.true_value);
	503	errdefer comp.gpa().destroy(comp.true_value);
392	504
393		comp.false_value = try comp.a().create(Value.Bool{
	505	comp.false_value = try comp.gpa().create(Value.Bool{
394	506	.base = Value{
395	507	.id = Value.Id.Bool,
396	508	.typeof = &Type.Bool.get(comp).base,
...	...	@@ -398,19 +510,23 @@ pub const Compilation = struct {
398	510	},
399	511	.x = false,
400	512	});
401		errdefer comp.a().destroy(comp.false_value);
	513	errdefer comp.gpa().destroy(comp.false_value);
402	514
403		comp.noreturn_value = try comp.a().create(Value.NoReturn{
	515	comp.noreturn_value = try comp.gpa().create(Value.NoReturn{
404	516	.base = Value{
405	517	.id = Value.Id.NoReturn,
406	518	.typeof = &Type.NoReturn.get(comp).base,
407	519	.ref_count = std.atomic.Int(usize).init(1),
408	520	},
409	521	});
410		errdefer comp.a().destroy(comp.noreturn_value);
	522	errdefer comp.gpa().destroy(comp.noreturn_value);
411	523	}
412	524
413	525	pub fn destroy(self: *Compilation) void {
	526	if (self.tmp_dir.getOrNull()) \|tmp_dir_result\| if (tmp_dir_result.*) \|tmp_dir\| {
	527	os.deleteTree(self.arena(), tmp_dir) catch {};
	528	} else \|_\| {};
	529
414	530	self.noreturn_value.base.deref(self);
415	531	self.void_value.base.deref(self);
416	532	self.false_value.base.deref(self);
...	...	@@ -420,14 +536,18 @@ pub const Compilation = struct {
420	536	self.meta_type.base.base.deref(self);
421	537
422	538	self.events.destroy();
423		self.name.deinit();
424	539
425		self.a().destroy(self);
	540	llvm.DisposeMessage(self.target_layout_str);
	541	llvm.DisposeTargetData(self.target_data_ref);
	542	llvm.DisposeTargetMachine(self.target_machine);
	543
	544	self.arena_allocator.deinit();
	545	self.gpa().destroy(self);
426	546	}
427	547
428	548	pub fn build(self: *Compilation) !void {
429	549	if (self.llvm_argv.len != 0) {
430		var c_compatible_args = try std.cstr.NullTerminated2DArray.fromSlices(self.a(), [][]const []const u8{
	550	var c_compatible_args = try std.cstr.NullTerminated2DArray.fromSlices(self.arena(), [][]const []const u8{
431	551	[][]const u8{"zig (LLVM option parsing)"},
432	552	self.llvm_argv,
433	553	});
...	...	@@ -436,7 +556,7 @@ pub const Compilation = struct {
436	556	c.ZigLLVMParseCommandLineOptions(self.llvm_argv.len + 1, c_compatible_args.ptr);
437	557	}
438	558
439		_ = try async<self.a()> self.buildAsync();
	559	_ = try async<self.gpa()> self.buildAsync();
440	560	}
441	561
442	562	async fn buildAsync(self: *Compilation) void {
...	...	@@ -464,7 +584,7 @@ pub const Compilation = struct {
464	584	}
465	585	} else \|err\| {
466	586	// if there's an error then the compile errors have dangling references
467		self.a().free(compile_errors);
	587	self.gpa().free(compile_errors);
468	588
469	589	await (async self.events.put(Event{ .Error = err }) catch unreachable);
470	590	}
...	...	@@ -477,26 +597,26 @@ pub const Compilation = struct {
477	597	async fn addRootSrc(self: *Compilation) !void {
478	598	const root_src_path = self.root_src_path orelse @panic("TODO handle null root src path");
479	599	// TODO async/await os.path.real
480		const root_src_real_path = os.path.real(self.a(), root_src_path) catch \|err\| {
	600	const root_src_real_path = os.path.real(self.gpa(), root_src_path) catch \|err\| {
481	601	try printError("unable to get real path '{}': {}", root_src_path, err);
482	602	return err;
483	603	};
484		errdefer self.a().free(root_src_real_path);
	604	errdefer self.gpa().free(root_src_real_path);
485	605
486	606	// TODO async/await readFileAlloc()
487		const source_code = io.readFileAlloc(self.a(), root_src_real_path) catch \|err\| {
	607	const source_code = io.readFileAlloc(self.gpa(), root_src_real_path) catch \|err\| {
488	608	try printError("unable to open '{}': {}", root_src_real_path, err);
489	609	return err;
490	610	};
491		errdefer self.a().free(source_code);
	611	errdefer self.gpa().free(source_code);
492	612
493		const parsed_file = try self.a().create(ParsedFile{
	613	const parsed_file = try self.gpa().create(ParsedFile{
494	614	.tree = undefined,
495	615	.realpath = root_src_real_path,
496	616	});
497		errdefer self.a().destroy(parsed_file);
	617	errdefer self.gpa().destroy(parsed_file);
498	618
499		parsed_file.tree = try std.zig.parse(self.a(), source_code);
	619	parsed_file.tree = try std.zig.parse(self.gpa(), source_code);
500	620	errdefer parsed_file.tree.deinit();
501	621
502	622	const tree = &parsed_file.tree;
...	...	@@ -525,7 +645,7 @@ pub const Compilation = struct {
525	645	continue;
526	646	};
527	647
528		const fn_decl = try self.a().create(Decl.Fn{
	648	const fn_decl = try self.gpa().create(Decl.Fn{
529	649	.base = Decl{
530	650	.id = Decl.Id.Fn,
531	651	.name = name,
...	...	@@ -538,7 +658,7 @@ pub const Compilation = struct {
538	658	.value = Decl.Fn.Val{ .Unresolved = {} },
539	659	.fn_proto = fn_proto,
540	660	});
541		errdefer self.a().destroy(fn_decl);
	661	errdefer self.gpa().destroy(fn_decl);
542	662
543	663	try decl_group.call(addTopLevelDecl, self, &fn_decl.base);
544	664	},
...	...	@@ -547,15 +667,15 @@ pub const Compilation = struct {
547	667	}
548	668	}
549	669	try await (async decl_group.wait() catch unreachable);
550		try await (async self.build_group.wait() catch unreachable);
	670	try await (async self.prelink_group.wait() catch unreachable);
551	671	}
552	672
553	673	async fn addTopLevelDecl(self: Compilation, decl: Decl) !void {
554	674	const is_export = decl.isExported(&decl.parsed_file.tree);
555	675
556	676	if (is_export) {
557		try self.build_group.call(verifyUniqueSymbol, self, decl);
558		try self.build_group.call(resolveDecl, self, decl);
	677	try self.prelink_group.call(verifyUniqueSymbol, self, decl);
	678	try self.prelink_group.call(resolveDecl, self, decl);
559	679	}
560	680	}
561	681
...	...	@@ -563,7 +683,7 @@ pub const Compilation = struct {
563	683	const text = try std.fmt.allocPrint(self.loop.allocator, fmt, args);
564	684	errdefer self.loop.allocator.free(text);
565	685
566		try self.build_group.call(addCompileErrorAsync, self, parsed_file, span, text);
	686	try self.prelink_group.call(addCompileErrorAsync, self, parsed_file, span, text);
567	687	}
568	688
569	689	async fn addCompileErrorAsync(
...	...	@@ -625,11 +745,11 @@ pub const Compilation = struct {
625	745	}
626	746	}
627	747
628		const link_lib = try self.a().create(LinkLib{
	748	const link_lib = try self.gpa().create(LinkLib{
629	749	.name = name,
630	750	.path = null,
631	751	.provided_explicitly = provided_explicitly,
632		.symbols = ArrayList([]u8).init(self.a()),
	752	.symbols = ArrayList([]u8).init(self.gpa()),
633	753	});
634	754	try self.link_libs_list.append(link_lib);
635	755	if (is_libc) {
...	...	@@ -638,9 +758,71 @@ pub const Compilation = struct {
638	758	return link_lib;
639	759	}
640	760
641		fn a(self: Compilation) *mem.Allocator {
	761	/// General Purpose Allocator. Must free when done.
	762	fn gpa(self: Compilation) *mem.Allocator {
642	763	return self.loop.allocator;
643	764	}
	765
	766	/// Arena Allocator. Automatically freed when the Compilation is destroyed.
	767	fn arena(self: Compilation) mem.Allocator {
	768	return &self.arena_allocator.allocator;
	769	}
	770
	771	/// If the temporary directory for this compilation has not been created, it creates it.
	772	/// Then it creates a random file name in that dir and returns it.
	773	pub async fn createRandomOutputPath(self: *Compilation, suffix: []const u8) !Buffer {
	774	const tmp_dir = try await (async self.getTmpDir() catch unreachable);
	775	const file_prefix = await (async self.getRandomFileName() catch unreachable);
	776
	777	const file_name = try std.fmt.allocPrint(self.gpa(), "{}{}", file_prefix[0..], suffix);
	778	defer self.gpa().free(file_name);
	779
	780	const full_path = try os.path.join(self.gpa(), tmp_dir, file_name[0..]);
	781	errdefer self.gpa().free(full_path);
	782
	783	return Buffer.fromOwnedSlice(self.gpa(), full_path);
	784	}
	785
	786	/// If the temporary directory for this Compilation has not been created, creates it.
	787	/// Then returns it. The directory is unique to this Compilation and cleaned up when
	788	/// the Compilation deinitializes.
	789	async fn getTmpDir(self: *Compilation) ![]const u8 {
	790	if (await (async self.tmp_dir.start() catch unreachable)) \|ptr\| return ptr.*;
	791	self.tmp_dir.data = await (async self.getTmpDirImpl() catch unreachable);
	792	self.tmp_dir.resolve();
	793	return self.tmp_dir.data;
	794	}
	795
	796	async fn getTmpDirImpl(self: *Compilation) ![]u8 {
	797	const comp_dir_name = await (async self.getRandomFileName() catch unreachable);
	798	const zig_dir_path = try getZigDir(self.gpa());
	799	defer self.gpa().free(zig_dir_path);
	800
	801	const tmp_dir = try os.path.join(self.arena(), zig_dir_path, comp_dir_name[0..]);
	802	try os.makePath(self.gpa(), tmp_dir);
	803	return tmp_dir;
	804	}
	805
	806	async fn getRandomFileName(self: *Compilation) [12]u8 {
	807	// here we replace the standard +/ with -_ so that it can be used in a file name
	808	const b64_fs_encoder = std.base64.Base64Encoder.init(
	809	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
	810	std.base64.standard_pad_char,
	811	);
	812
	813	var rand_bytes: [9]u8 = undefined;
	814
	815	{
	816	const held = await (async self.event_loop_local.prng.acquire() catch unreachable);
	817	defer held.release();
	818
	819	held.value.random.bytes(rand_bytes[0..]);
	820	}
	821
	822	var result: [12]u8 = undefined;
	823	b64_fs_encoder.encode(result[0..], rand_bytes);
	824	return result;
	825	}
644	826	};
645	827
646	828	fn printError(comptime format: []const u8, args: ...) !void {
...	...	@@ -662,13 +844,11 @@ fn parseVisibToken(tree: *ast.Tree, optional_token_index: ?ast.TokenIndex) Visib
662	844
663	845	/// This declaration has been blessed as going into the final code generation.
664	846	pub async fn resolveDecl(comp: Compilation, decl: Decl) !void {
665		if (@atomicRmw(u8, &decl.resolution_in_progress, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst) == 0) {
666		decl.resolution.data = await (async generateDecl(comp, decl) catch unreachable);
667		decl.resolution.resolve();
668		return decl.resolution.data;
669		} else {
670		return (await (async decl.resolution.get() catch unreachable)).*;
671		}
	847	if (await (async decl.resolution.start() catch unreachable)) \|ptr\| return ptr.*;
	848
	849	decl.resolution.data = await (async generateDecl(comp, decl) catch unreachable);
	850	decl.resolution.resolve();
	851	return decl.resolution.data;
672	852	}
673	853
674	854	/// The function that actually does the generation.
...	...	@@ -698,7 +878,7 @@ async fn generateDeclFn(comp: Compilation, fn_decl: Decl.Fn) !void {
698	878	const fn_type = try Type.Fn.create(comp, return_type, params, is_var_args);
699	879	defer fn_type.base.base.deref(comp);
700	880
701		var symbol_name = try std.Buffer.init(comp.a(), fn_decl.base.name);
	881	var symbol_name = try std.Buffer.init(comp.gpa(), fn_decl.base.name);
702	882	errdefer symbol_name.deinit();
703	883
704	884	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 {
719	899	error.SemanticAnalysisFailed => return {},
720	900	else => return err,
721	901	};
722		defer unanalyzed_code.destroy(comp.a());
	902	defer unanalyzed_code.destroy(comp.gpa());
723	903
724	904	if (comp.verbose_ir) {
725	905	std.debug.warn("unanalyzed:\n");
...	...	@@ -738,7 +918,7 @@ async fn generateDeclFn(comp: Compilation, fn_decl: Decl.Fn) !void {
738	918	error.SemanticAnalysisFailed => return {},
739	919	else => return err,
740	920	};
741		errdefer analyzed_code.destroy(comp.a());
	921	errdefer analyzed_code.destroy(comp.gpa());
742	922
743	923	if (comp.verbose_ir) {
744	924	std.debug.warn("analyzed:\n");
...	...	@@ -747,5 +927,30 @@ async fn generateDeclFn(comp: Compilation, fn_decl: Decl.Fn) !void {
747	927
748	928	// Kick off rendering to LLVM module, but it doesn't block the fn decl
749	929	// analysis from being complete.
750		try comp.build_group.call(codegen.renderToLlvm, comp, fn_val, analyzed_code);
	930	try comp.prelink_group.call(codegen.renderToLlvm, comp, fn_val, analyzed_code);
	931	try comp.prelink_group.call(addFnToLinkSet, comp, fn_val);
	932	}
	933
	934	async fn addFnToLinkSet(comp: Compilation, fn_val: Value.Fn) void {
	935	fn_val.base.ref();
	936	defer fn_val.base.deref(comp);
	937
	938	fn_val.link_set_node.data = fn_val;
	939
	940	const held = await (async comp.fn_link_set.acquire() catch unreachable);
	941	defer held.release();
	942
	943	held.value.append(fn_val.link_set_node);
	944	}
	945
	946	fn getZigDir(allocator: *mem.Allocator) ![]u8 {
	947	const home_dir = try getHomeDir(allocator);
	948	defer allocator.free(home_dir);
	949
	950	return os.path.join(allocator, home_dir, ".zig");
	951	}
	952
	953	/// TODO move to zig std lib, and make it work for other OSes
	954	fn getHomeDir(allocator: *mem.Allocator) ![]u8 {
	955	return os.getEnvVarOwned(allocator, "HOME");
751	956	}

src-self-hosted/ir.zig+5-5

...	...	@@ -453,7 +453,7 @@ pub const Code = struct {
453	453	arena: std.heap.ArenaAllocator,
454	454	return_type: ?*Type,
455	455
456		/// allocator is comp.a()
	456	/// allocator is comp.gpa()
457	457	pub fn destroy(self: Code, allocator: Allocator) void {
458	458	self.arena.deinit();
459	459	allocator.destroy(self);
...	...	@@ -483,13 +483,13 @@ pub const Builder = struct {
483	483	pub const Error = Analyze.Error;
484	484
485	485	pub fn init(comp: Compilation, parsed_file: ParsedFile) !Builder {
486		const code = try comp.a().create(Code{
	486	const code = try comp.gpa().create(Code{
487	487	.basic_block_list = undefined,
488		.arena = std.heap.ArenaAllocator.init(comp.a()),
	488	.arena = std.heap.ArenaAllocator.init(comp.gpa()),
489	489	.return_type = null,
490	490	});
491	491	code.basic_block_list = std.ArrayList(*BasicBlock).init(&code.arena.allocator);
492		errdefer code.destroy(comp.a());
	492	errdefer code.destroy(comp.gpa());
493	493
494	494	return Builder{
495	495	.comp = comp,
...	...	@@ -502,7 +502,7 @@ pub const Builder = struct {
502	502	}
503	503
504	504	pub fn abort(self: *Builder) void {
505		self.code.destroy(self.comp.a());
	505	self.code.destroy(self.comp.gpa());
506	506	}
507	507
508	508	/// Call code.destroy() when done

src-self-hosted/llvm.zig+73-2

...	...	@@ -2,6 +2,12 @@ const builtin = @import("builtin");
2	2	const c = @import("c.zig");
3	3	const assert = @import("std").debug.assert;
4	4
	5	// we wrap the c module for 3 reasons:
	6	// 1. to avoid accidentally calling the non-thread-safe functions
	7	// 2. patch up some of the types to remove nullability
	8	// 3. some functions have been augmented by zig_llvm.cpp to be more powerful,
	9	// such as ZigLLVMTargetMachineEmitToFile
	10
5	11	pub const AttributeIndex = c_uint;
6	12	pub const Bool = c_int;
7	13
...	...	@@ -12,25 +18,51 @@ pub const ValueRef = removeNullability(c.LLVMValueRef);
12	18	pub const TypeRef = removeNullability(c.LLVMTypeRef);
13	19	pub const BasicBlockRef = removeNullability(c.LLVMBasicBlockRef);
14	20	pub const AttributeRef = removeNullability(c.LLVMAttributeRef);
	21	pub const TargetRef = removeNullability(c.LLVMTargetRef);
	22	pub const TargetMachineRef = removeNullability(c.LLVMTargetMachineRef);
	23	pub const TargetDataRef = removeNullability(c.LLVMTargetDataRef);
	24	pub const DIBuilder = c.ZigLLVMDIBuilder;
15	25
16	26	pub const AddAttributeAtIndex = c.LLVMAddAttributeAtIndex;
17	27	pub const AddFunction = c.LLVMAddFunction;
	28	pub const AddModuleCodeViewFlag = c.ZigLLVMAddModuleCodeViewFlag;
	29	pub const AddModuleDebugInfoFlag = c.ZigLLVMAddModuleDebugInfoFlag;
18	30	pub const ClearCurrentDebugLocation = c.ZigLLVMClearCurrentDebugLocation;
	31	pub const ConstAllOnes = c.LLVMConstAllOnes;
19	32	pub const ConstInt = c.LLVMConstInt;
	33	pub const ConstNull = c.LLVMConstNull;
20	34	pub const ConstStringInContext = c.LLVMConstStringInContext;
21	35	pub const ConstStructInContext = c.LLVMConstStructInContext;
	36	pub const CopyStringRepOfTargetData = c.LLVMCopyStringRepOfTargetData;
22	37	pub const CreateBuilderInContext = c.LLVMCreateBuilderInContext;
	38	pub const CreateCompileUnit = c.ZigLLVMCreateCompileUnit;
	39	pub const CreateDIBuilder = c.ZigLLVMCreateDIBuilder;
23	40	pub const CreateEnumAttribute = c.LLVMCreateEnumAttribute;
	41	pub const CreateFile = c.ZigLLVMCreateFile;
24	42	pub const CreateStringAttribute = c.LLVMCreateStringAttribute;
	43	pub const CreateTargetDataLayout = c.LLVMCreateTargetDataLayout;
	44	pub const CreateTargetMachine = c.LLVMCreateTargetMachine;
	45	pub const DIBuilderFinalize = c.ZigLLVMDIBuilderFinalize;
25	46	pub const DisposeBuilder = c.LLVMDisposeBuilder;
	47	pub const DisposeDIBuilder = c.ZigLLVMDisposeDIBuilder;
	48	pub const DisposeMessage = c.LLVMDisposeMessage;
26	49	pub const DisposeModule = c.LLVMDisposeModule;
	50	pub const DisposeTargetData = c.LLVMDisposeTargetData;
	51	pub const DisposeTargetMachine = c.LLVMDisposeTargetMachine;
27	52	pub const DoubleTypeInContext = c.LLVMDoubleTypeInContext;
28	53	pub const DumpModule = c.LLVMDumpModule;
29	54	pub const FP128TypeInContext = c.LLVMFP128TypeInContext;
30	55	pub const FloatTypeInContext = c.LLVMFloatTypeInContext;
31	56	pub const GetEnumAttributeKindForName = c.LLVMGetEnumAttributeKindForName;
	57	pub const GetHostCPUName = c.ZigLLVMGetHostCPUName;
32	58	pub const GetMDKindIDInContext = c.LLVMGetMDKindIDInContext;
	59	pub const GetNativeFeatures = c.ZigLLVMGetNativeFeatures;
33	60	pub const HalfTypeInContext = c.LLVMHalfTypeInContext;
	61	pub const InitializeAllAsmParsers = c.LLVMInitializeAllAsmParsers;
	62	pub const InitializeAllAsmPrinters = c.LLVMInitializeAllAsmPrinters;
	63	pub const InitializeAllTargetInfos = c.LLVMInitializeAllTargetInfos;
	64	pub const InitializeAllTargetMCs = c.LLVMInitializeAllTargetMCs;
	65	pub const InitializeAllTargets = c.LLVMInitializeAllTargets;
34	66	pub const InsertBasicBlockInContext = c.LLVMInsertBasicBlockInContext;
35	67	pub const Int128TypeInContext = c.LLVMInt128TypeInContext;
36	68	pub const Int16TypeInContext = c.LLVMInt16TypeInContext;
...	...	@@ -47,13 +79,16 @@ pub const MDStringInContext = c.LLVMMDStringInContext;
47	79	pub const MetadataTypeInContext = c.LLVMMetadataTypeInContext;
48	80	pub const ModuleCreateWithNameInContext = c.LLVMModuleCreateWithNameInContext;
49	81	pub const PPCFP128TypeInContext = c.LLVMPPCFP128TypeInContext;
	82	pub const SetDataLayout = c.LLVMSetDataLayout;
	83	pub const SetTarget = c.LLVMSetTarget;
50	84	pub const StructTypeInContext = c.LLVMStructTypeInContext;
51	85	pub const TokenTypeInContext = c.LLVMTokenTypeInContext;
52	86	pub const VoidTypeInContext = c.LLVMVoidTypeInContext;
53	87	pub const X86FP80TypeInContext = c.LLVMX86FP80TypeInContext;
54	88	pub const X86MMXTypeInContext = c.LLVMX86MMXTypeInContext;
55		pub const ConstAllOnes = c.LLVMConstAllOnes;
56		pub const ConstNull = c.LLVMConstNull;
	89
	90	pub const GetTargetFromTriple = LLVMGetTargetFromTriple;
	91	extern fn LLVMGetTargetFromTriple(Triple: []const u8, T: TargetRef, ErrorMessage: ?[]u8) Bool;
57	92
58	93	pub const VerifyModule = LLVMVerifyModule;
59	94	extern fn LLVMVerifyModule(M: ModuleRef, Action: VerifierFailureAction, OutMessage: ?[]u8) Bool;
...	...	@@ -83,6 +118,31 @@ pub const PrintMessageAction = VerifierFailureAction.LLVMPrintMessageAction;
83	118	pub const ReturnStatusAction = VerifierFailureAction.LLVMReturnStatusAction;
84	119	pub const VerifierFailureAction = c.LLVMVerifierFailureAction;
85	120
	121	pub const CodeGenLevelNone = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelNone;
	122	pub const CodeGenLevelLess = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelLess;
	123	pub const CodeGenLevelDefault = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault;
	124	pub const CodeGenLevelAggressive = c.LLVMCodeGenOptLevel.LLVMCodeGenLevelAggressive;
	125	pub const CodeGenOptLevel = c.LLVMCodeGenOptLevel;
	126
	127	pub const RelocDefault = c.LLVMRelocMode.LLVMRelocDefault;
	128	pub const RelocStatic = c.LLVMRelocMode.LLVMRelocStatic;
	129	pub const RelocPIC = c.LLVMRelocMode.LLVMRelocPIC;
	130	pub const RelocDynamicNoPic = c.LLVMRelocMode.LLVMRelocDynamicNoPic;
	131	pub const RelocMode = c.LLVMRelocMode;
	132
	133	pub const CodeModelDefault = c.LLVMCodeModel.LLVMCodeModelDefault;
	134	pub const CodeModelJITDefault = c.LLVMCodeModel.LLVMCodeModelJITDefault;
	135	pub const CodeModelSmall = c.LLVMCodeModel.LLVMCodeModelSmall;
	136	pub const CodeModelKernel = c.LLVMCodeModel.LLVMCodeModelKernel;
	137	pub const CodeModelMedium = c.LLVMCodeModel.LLVMCodeModelMedium;
	138	pub const CodeModelLarge = c.LLVMCodeModel.LLVMCodeModelLarge;
	139	pub const CodeModel = c.LLVMCodeModel;
	140
	141	pub const EmitAssembly = EmitOutputType.ZigLLVM_EmitAssembly;
	142	pub const EmitBinary = EmitOutputType.ZigLLVM_EmitBinary;
	143	pub const EmitLLVMIr = EmitOutputType.ZigLLVM_EmitLLVMIr;
	144	pub const EmitOutputType = c.ZigLLVM_EmitOutputType;
	145
86	146	fn removeNullability(comptime T: type) type {
87	147	comptime assert(@typeId(T) == builtin.TypeId.Optional);
88	148	return T.Child;
...	...	@@ -90,3 +150,14 @@ fn removeNullability(comptime T: type) type {
90	150
91	151	pub const BuildRet = LLVMBuildRet;
92	152	extern fn LLVMBuildRet(arg0: BuilderRef, V: ?ValueRef) ValueRef;
	153
	154	pub const TargetMachineEmitToFile = ZigLLVMTargetMachineEmitToFile;
	155	extern fn ZigLLVMTargetMachineEmitToFile(
	156	targ_machine_ref: TargetMachineRef,
	157	module_ref: ModuleRef,
	158	filename: [*]const u8,
	159	output_type: EmitOutputType,
	160	error_message: []u8,
	161	is_debug: bool,
	162	is_small: bool,
	163	) bool;

src-self-hosted/main.zig+5-3

...	...	@@ -363,6 +363,8 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
363	363	}
364	364	};
365	365
	366	const is_static = flags.present("static");
	367
366	368	const assembly_files = flags.many("assembly");
367	369	const link_objects = flags.many("object");
368	370	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
389	391	try loop.initMultiThreaded(allocator);
390	392	defer loop.deinit();
391	393
392		var event_loop_local = EventLoopLocal.init(&loop);
	394	var event_loop_local = try EventLoopLocal.init(&loop);
393	395	defer event_loop_local.deinit();
394	396
395	397	var comp = try Compilation.create(
...	...	@@ -399,6 +401,7 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
399	401	Target.Native,
400	402	out_type,
401	403	build_mode,
	404	is_static,
402	405	zig_lib_dir,
403	406	full_cache_dir,
404	407	);
...	...	@@ -426,7 +429,6 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
426	429	comp.clang_argv = clang_argv_buf.toSliceConst();
427	430
428	431	comp.strip = flags.present("strip");
429		comp.is_static = flags.present("static");
430	432
431	433	if (flags.single("libc-lib-dir")) \|libc_lib_dir\| {
432	434	comp.libc_lib_dir = libc_lib_dir;
...	...	@@ -481,9 +483,9 @@ fn buildOutputType(allocator: *Allocator, args: []const []const u8, out_type: Co
481	483	}
482	484
483	485	comp.emit_file_type = emit_type;
484		comp.link_objects = link_objects;
485	486	comp.assembly_files = assembly_files;
486	487	comp.link_out_file = flags.single("out-file");
	488	comp.link_objects = link_objects;
487	489
488	490	try comp.build();
489	491	const process_build_events_handle = try async<loop.allocator> processBuildEvents(comp, color);

src-self-hosted/package.zig created+29

...	...	@@ -0,0 +1,29 @@
	1	const std = @import("std");
	2	const mem = std.mem;
	3	const assert = std.debug.assert;
	4	const Buffer = std.Buffer;
	5
	6	pub const Package = struct {
	7	root_src_dir: Buffer,
	8	root_src_path: Buffer,
	9
	10	/// relative to root_src_dir
	11	table: Table,
	12
	13	pub const Table = std.HashMap([]const u8, *Package, mem.hash_slice_u8, mem.eql_slice_u8);
	14
	15	/// makes internal copies of root_src_dir and root_src_path
	16	/// allocator should be an arena allocator because Package never frees anything
	17	pub fn create(allocator: mem.Allocator, root_src_dir: []const u8, root_src_path: []const u8) !Package {
	18	return allocator.create(Package{
	19	.root_src_dir = try Buffer.init(allocator, root_src_dir),
	20	.root_src_path = try Buffer.init(allocator, root_src_path),
	21	.table = Table.init(allocator),
	22	});
	23	}
	24
	25	pub fn add(self: Package, name: []const u8, package: Package) !void {
	26	const entry = try self.table.put(try mem.dupe(self.table.allocator, u8, name), package);
	27	assert(entry == null);
	28	}
	29	};

src-self-hosted/scope.zig+16-16

...	...	@@ -64,7 +64,7 @@ pub const Scope = struct {
64	64
65	65	/// Creates a Decls scope with 1 reference
66	66	pub fn create(comp: Compilation, parent: ?Scope) !*Decls {
67		const self = try comp.a().create(Decls{
	67	const self = try comp.gpa().create(Decls{
68	68	.base = Scope{
69	69	.id = Id.Decls,
70	70	.parent = parent,
...	...	@@ -72,9 +72,9 @@ pub const Scope = struct {
72	72	},
73	73	.table = undefined,
74	74	});
75		errdefer comp.a().destroy(self);
	75	errdefer comp.gpa().destroy(self);
76	76
77		self.table = Decl.Table.init(comp.a());
	77	self.table = Decl.Table.init(comp.gpa());
78	78	errdefer self.table.deinit();
79	79
80	80	if (parent) \|p\| p.ref();
...	...	@@ -126,7 +126,7 @@ pub const Scope = struct {
126	126
127	127	/// Creates a Block scope with 1 reference
128	128	pub fn create(comp: Compilation, parent: ?Scope) !*Block {
129		const self = try comp.a().create(Block{
	129	const self = try comp.gpa().create(Block{
130	130	.base = Scope{
131	131	.id = Id.Block,
132	132	.parent = parent,
...	...	@@ -138,14 +138,14 @@ pub const Scope = struct {
138	138	.is_comptime = undefined,
139	139	.safety = Safety.Auto,
140	140	});
141		errdefer comp.a().destroy(self);
	141	errdefer comp.gpa().destroy(self);
142	142
143	143	if (parent) \|p\| p.ref();
144	144	return self;
145	145	}
146	146
147	147	pub fn destroy(self: Block, comp: Compilation) void {
148		comp.a().destroy(self);
	148	comp.gpa().destroy(self);
149	149	}
150	150	};
151	151
...	...	@@ -158,7 +158,7 @@ pub const Scope = struct {
158	158	/// Creates a FnDef scope with 1 reference
159	159	/// Must set the fn_val later
160	160	pub fn create(comp: Compilation, parent: ?Scope) !*FnDef {
161		const self = try comp.a().create(FnDef{
	161	const self = try comp.gpa().create(FnDef{
162	162	.base = Scope{
163	163	.id = Id.FnDef,
164	164	.parent = parent,
...	...	@@ -173,7 +173,7 @@ pub const Scope = struct {
173	173	}
174	174
175	175	pub fn destroy(self: FnDef, comp: Compilation) void {
176		comp.a().destroy(self);
	176	comp.gpa().destroy(self);
177	177	}
178	178	};
179	179
...	...	@@ -182,7 +182,7 @@ pub const Scope = struct {
182	182
183	183	/// Creates a CompTime scope with 1 reference
184	184	pub fn create(comp: Compilation, parent: ?Scope) !*CompTime {
185		const self = try comp.a().create(CompTime{
	185	const self = try comp.gpa().create(CompTime{
186	186	.base = Scope{
187	187	.id = Id.CompTime,
188	188	.parent = parent,
...	...	@@ -195,7 +195,7 @@ pub const Scope = struct {
195	195	}
196	196
197	197	pub fn destroy(self: CompTime, comp: Compilation) void {
198		comp.a().destroy(self);
	198	comp.gpa().destroy(self);
199	199	}
200	200	};
201	201
...	...	@@ -216,7 +216,7 @@ pub const Scope = struct {
216	216	kind: Kind,
217	217	defer_expr_scope: *DeferExpr,
218	218	) !*Defer {
219		const self = try comp.a().create(Defer{
	219	const self = try comp.gpa().create(Defer{
220	220	.base = Scope{
221	221	.id = Id.Defer,
222	222	.parent = parent,
...	...	@@ -225,7 +225,7 @@ pub const Scope = struct {
225	225	.defer_expr_scope = defer_expr_scope,
226	226	.kind = kind,
227	227	});
228		errdefer comp.a().destroy(self);
	228	errdefer comp.gpa().destroy(self);
229	229
230	230	defer_expr_scope.base.ref();
231	231
...	...	@@ -235,7 +235,7 @@ pub const Scope = struct {
235	235
236	236	pub fn destroy(self: Defer, comp: Compilation) void {
237	237	self.defer_expr_scope.base.deref(comp);
238		comp.a().destroy(self);
	238	comp.gpa().destroy(self);
239	239	}
240	240	};
241	241
...	...	@@ -245,7 +245,7 @@ pub const Scope = struct {
245	245
246	246	/// Creates a DeferExpr scope with 1 reference
247	247	pub fn create(comp: Compilation, parent: ?Scope, expr_node: ast.Node) !DeferExpr {
248		const self = try comp.a().create(DeferExpr{
	248	const self = try comp.gpa().create(DeferExpr{
249	249	.base = Scope{
250	250	.id = Id.DeferExpr,
251	251	.parent = parent,
...	...	@@ -253,14 +253,14 @@ pub const Scope = struct {
253	253	},
254	254	.expr_node = expr_node,
255	255	});
256		errdefer comp.a().destroy(self);
	256	errdefer comp.gpa().destroy(self);
257	257
258	258	if (parent) \|p\| p.ref();
259	259	return self;
260	260	}
261	261
262	262	pub fn destroy(self: DeferExpr, comp: Compilation) void {
263		comp.a().destroy(self);
	263	comp.gpa().destroy(self);
264	264	}
265	265	};
266	266	};

src-self-hosted/target.zig+87-29

...	...	@@ -1,60 +1,118 @@
	1	const std = @import("std");
1	2	const builtin = @import("builtin");
2		const c = @import("c.zig");
3
4		pub const CrossTarget = struct {
5		arch: builtin.Arch,
6		os: builtin.Os,
7		environ: builtin.Environ,
8		};
	3	const llvm = @import("llvm.zig");
9	4
10	5	pub const Target = union(enum) {
11	6	Native,
12		Cross: CrossTarget,
	7	Cross: Cross,
13	8
14		pub fn oFileExt(self: *const Target) []const u8 {
15		const environ = switch (self.*) {
16		Target.Native => builtin.environ,
17		Target.Cross => \|t\| t.environ,
18		};
19		return switch (environ) {
20		builtin.Environ.msvc => ".obj",
	9	pub const Cross = struct {
	10	arch: builtin.Arch,
	11	os: builtin.Os,
	12	environ: builtin.Environ,
	13	object_format: builtin.ObjectFormat,
	14	};
	15
	16	pub fn oFileExt(self: Target) []const u8 {
	17	return switch (self.getObjectFormat()) {
	18	builtin.ObjectFormat.coff => ".obj",
21	19	else => ".o",
22	20	};
23	21	}
24	22
25		pub fn exeFileExt(self: *const Target) []const u8 {
	23	pub fn exeFileExt(self: Target) []const u8 {
26	24	return switch (self.getOs()) {
27	25	builtin.Os.windows => ".exe",
28	26	else => "",
29	27	};
30	28	}
31	29
32		pub fn getOs(self: *const Target) builtin.Os {
33		return switch (self.*) {
	30	pub fn getOs(self: Target) builtin.Os {
	31	return switch (self) {
34	32	Target.Native => builtin.os,
35		Target.Cross => \|t\| t.os,
	33	@TagType(Target).Cross => \|t\| t.os,
	34	};
	35	}
	36
	37	pub fn getArch(self: Target) builtin.Arch {
	38	return switch (self) {
	39	Target.Native => builtin.arch,
	40	@TagType(Target).Cross => \|t\| t.arch,
	41	};
	42	}
	43
	44	pub fn getEnviron(self: Target) builtin.Environ {
	45	return switch (self) {
	46	Target.Native => builtin.environ,
	47	@TagType(Target).Cross => \|t\| t.environ,
	48	};
	49	}
	50
	51	pub fn getObjectFormat(self: Target) builtin.ObjectFormat {
	52	return switch (self) {
	53	Target.Native => builtin.object_format,
	54	@TagType(Target).Cross => \|t\| t.object_format,
36	55	};
37	56	}
38	57
39		pub fn isDarwin(self: *const Target) bool {
	58	pub fn isWasm(self: Target) bool {
	59	return switch (self.getArch()) {
	60	builtin.Arch.wasm32, builtin.Arch.wasm64 => true,
	61	else => false,
	62	};
	63	}
	64
	65	pub fn isDarwin(self: Target) bool {
40	66	return switch (self.getOs()) {
41	67	builtin.Os.ios, builtin.Os.macosx => true,
42	68	else => false,
43	69	};
44	70	}
45	71
46		pub fn isWindows(self: *const Target) bool {
	72	pub fn isWindows(self: Target) bool {
47	73	return switch (self.getOs()) {
48	74	builtin.Os.windows => true,
49	75	else => false,
50	76	};
51	77	}
52		};
53	78
54		pub fn initializeAll() void {
55		c.LLVMInitializeAllTargets();
56		c.LLVMInitializeAllTargetInfos();
57		c.LLVMInitializeAllTargetMCs();
58		c.LLVMInitializeAllAsmPrinters();
59		c.LLVMInitializeAllAsmParsers();
60		}
	79	pub fn initializeAll() void {
	80	llvm.InitializeAllTargets();
	81	llvm.InitializeAllTargetInfos();
	82	llvm.InitializeAllTargetMCs();
	83	llvm.InitializeAllAsmPrinters();
	84	llvm.InitializeAllAsmParsers();
	85	}
	86
	87	pub fn getTriple(self: Target, allocator: *std.mem.Allocator) !std.Buffer {
	88	var result = try std.Buffer.initSize(allocator, 0);
	89	errdefer result.deinit();
	90
	91	// LLVM WebAssembly output support requires the target to be activated at
	92	// build type with -DCMAKE_LLVM_EXPIERMENTAL_TARGETS_TO_BUILD=WebAssembly.
	93	//
	94	// LLVM determines the output format based on the environment suffix,
	95	// defaulting to an object based on the architecture. The default format in
	96	// LLVM 6 sets the wasm arch output incorrectly to ELF. We need to
	97	// explicitly set this ourself in order for it to work.
	98	//
	99	// This is fixed in LLVM 7 and you will be able to get wasm output by
	100	// using the target triple `wasm32-unknown-unknown-unknown`.
	101	const env_name = if (self.isWasm()) "wasm" else @tagName(self.getEnviron());
	102
	103	var out = &std.io.BufferOutStream.init(&result).stream;
	104	try out.print("{}-unknown-{}-{}", @tagName(self.getArch()), @tagName(self.getOs()), env_name);
	105
	106	return result;
	107	}
	108
	109	pub fn llvmTargetFromTriple(triple: std.Buffer) !llvm.TargetRef {
	110	var result: llvm.TargetRef = undefined;
	111	var err_msg: [*]u8 = undefined;
	112	if (llvm.GetTargetFromTriple(triple.ptr(), &result, &err_msg) != 0) {
	113	std.debug.warn("triple: {s} error: {s}\n", triple.ptr(), err_msg);
	114	return error.UnsupportedTarget;
	115	}
	116	return result;
	117	}
	118	};

src-self-hosted/test.zig+2-1

...	...	@@ -46,7 +46,7 @@ pub const TestContext = struct {
46	46	try self.loop.initMultiThreaded(allocator);
47	47	errdefer self.loop.deinit();
48	48
49		self.event_loop_local = EventLoopLocal.init(&self.loop);
	49	self.event_loop_local = try EventLoopLocal.init(&self.loop);
50	50	errdefer self.event_loop_local.deinit();
51	51
52	52	self.group = std.event.Group(error!void).init(&self.loop);
...	...	@@ -107,6 +107,7 @@ pub const TestContext = struct {
107	107	Target.Native,
108	108	Compilation.Kind.Obj,
109	109	builtin.Mode.Debug,
	110	true, // is_static
110	111	self.zig_lib_dir,
111	112	self.zig_cache_dir,
112	113	);

src-self-hosted/type.zig+29-29

...	...	@@ -160,7 +160,7 @@ pub const Type = struct {
160	160	decls: *Scope.Decls,
161	161
162	162	pub fn destroy(self: Struct, comp: Compilation) void {
163		comp.a().destroy(self);
	163	comp.gpa().destroy(self);
164	164	}
165	165
166	166	pub fn getLlvmType(self: Struct, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -180,7 +180,7 @@ pub const Type = struct {
180	180	};
181	181
182	182	pub fn create(comp: Compilation, return_type: Type, params: []Param, is_var_args: bool) !*Fn {
183		const result = try comp.a().create(Fn{
	183	const result = try comp.gpa().create(Fn{
184	184	.base = Type{
185	185	.base = Value{
186	186	.id = Value.Id.Type,
...	...	@@ -193,7 +193,7 @@ pub const Type = struct {
193	193	.params = params,
194	194	.is_var_args = is_var_args,
195	195	});
196		errdefer comp.a().destroy(result);
	196	errdefer comp.gpa().destroy(result);
197	197
198	198	result.return_type.base.ref();
199	199	for (result.params) \|param\| {
...	...	@@ -207,7 +207,7 @@ pub const Type = struct {
207	207	for (self.params) \|param\| {
208	208	param.typeof.base.deref(comp);
209	209	}
210		comp.a().destroy(self);
	210	comp.gpa().destroy(self);
211	211	}
212	212
213	213	pub fn getLlvmType(self: Fn, ofile: ObjectFile) !llvm.TypeRef {
...	...	@@ -215,8 +215,8 @@ pub const Type = struct {
215	215	Type.Id.Void => llvm.VoidTypeInContext(ofile.context) orelse return error.OutOfMemory,
216	216	else => try self.return_type.getLlvmType(ofile),
217	217	};
218		const llvm_param_types = try ofile.a().alloc(llvm.TypeRef, self.params.len);
219		defer ofile.a().free(llvm_param_types);
	218	const llvm_param_types = try ofile.gpa().alloc(llvm.TypeRef, self.params.len);
	219	defer ofile.gpa().free(llvm_param_types);
220	220	for (llvm_param_types) \|*llvm_param_type, i\| {
221	221	llvm_param_type.* = try self.params[i].typeof.getLlvmType(ofile);
222	222	}
...	...	@@ -241,7 +241,7 @@ pub const Type = struct {
241	241	}
242	242
243	243	pub fn destroy(self: MetaType, comp: Compilation) void {
244		comp.a().destroy(self);
	244	comp.gpa().destroy(self);
245	245	}
246	246	};
247	247
...	...	@@ -255,7 +255,7 @@ pub const Type = struct {
255	255	}
256	256
257	257	pub fn destroy(self: Void, comp: Compilation) void {
258		comp.a().destroy(self);
	258	comp.gpa().destroy(self);
259	259	}
260	260	};
261	261
...	...	@@ -269,7 +269,7 @@ pub const Type = struct {
269	269	}
270	270
271	271	pub fn destroy(self: Bool, comp: Compilation) void {
272		comp.a().destroy(self);
	272	comp.gpa().destroy(self);
273	273	}
274	274
275	275	pub fn getLlvmType(self: Bool, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -287,7 +287,7 @@ pub const Type = struct {
287	287	}
288	288
289	289	pub fn destroy(self: NoReturn, comp: Compilation) void {
290		comp.a().destroy(self);
	290	comp.gpa().destroy(self);
291	291	}
292	292	};
293	293
...	...	@@ -295,7 +295,7 @@ pub const Type = struct {
295	295	base: Type,
296	296
297	297	pub fn destroy(self: Int, comp: Compilation) void {
298		comp.a().destroy(self);
	298	comp.gpa().destroy(self);
299	299	}
300	300
301	301	pub fn getLlvmType(self: Int, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -307,7 +307,7 @@ pub const Type = struct {
307	307	base: Type,
308	308
309	309	pub fn destroy(self: Float, comp: Compilation) void {
310		comp.a().destroy(self);
	310	comp.gpa().destroy(self);
311	311	}
312	312
313	313	pub fn getLlvmType(self: Float, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -332,7 +332,7 @@ pub const Type = struct {
332	332	pub const Size = builtin.TypeInfo.Pointer.Size;
333	333
334	334	pub fn destroy(self: Pointer, comp: Compilation) void {
335		comp.a().destroy(self);
	335	comp.gpa().destroy(self);
336	336	}
337	337
338	338	pub fn get(
...	...	@@ -355,7 +355,7 @@ pub const Type = struct {
355	355	base: Type,
356	356
357	357	pub fn destroy(self: Array, comp: Compilation) void {
358		comp.a().destroy(self);
	358	comp.gpa().destroy(self);
359	359	}
360	360
361	361	pub fn getLlvmType(self: Array, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -367,7 +367,7 @@ pub const Type = struct {
367	367	base: Type,
368	368
369	369	pub fn destroy(self: ComptimeFloat, comp: Compilation) void {
370		comp.a().destroy(self);
	370	comp.gpa().destroy(self);
371	371	}
372	372	};
373	373
...	...	@@ -375,7 +375,7 @@ pub const Type = struct {
375	375	base: Type,
376	376
377	377	pub fn destroy(self: ComptimeInt, comp: Compilation) void {
378		comp.a().destroy(self);
	378	comp.gpa().destroy(self);
379	379	}
380	380	};
381	381
...	...	@@ -383,7 +383,7 @@ pub const Type = struct {
383	383	base: Type,
384	384
385	385	pub fn destroy(self: Undefined, comp: Compilation) void {
386		comp.a().destroy(self);
	386	comp.gpa().destroy(self);
387	387	}
388	388	};
389	389
...	...	@@ -391,7 +391,7 @@ pub const Type = struct {
391	391	base: Type,
392	392
393	393	pub fn destroy(self: Null, comp: Compilation) void {
394		comp.a().destroy(self);
	394	comp.gpa().destroy(self);
395	395	}
396	396	};
397	397
...	...	@@ -399,7 +399,7 @@ pub const Type = struct {
399	399	base: Type,
400	400
401	401	pub fn destroy(self: Optional, comp: Compilation) void {
402		comp.a().destroy(self);
	402	comp.gpa().destroy(self);
403	403	}
404	404
405	405	pub fn getLlvmType(self: Optional, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -411,7 +411,7 @@ pub const Type = struct {
411	411	base: Type,
412	412
413	413	pub fn destroy(self: ErrorUnion, comp: Compilation) void {
414		comp.a().destroy(self);
	414	comp.gpa().destroy(self);
415	415	}
416	416
417	417	pub fn getLlvmType(self: ErrorUnion, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -423,7 +423,7 @@ pub const Type = struct {
423	423	base: Type,
424	424
425	425	pub fn destroy(self: ErrorSet, comp: Compilation) void {
426		comp.a().destroy(self);
	426	comp.gpa().destroy(self);
427	427	}
428	428
429	429	pub fn getLlvmType(self: ErrorSet, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -435,7 +435,7 @@ pub const Type = struct {
435	435	base: Type,
436	436
437	437	pub fn destroy(self: Enum, comp: Compilation) void {
438		comp.a().destroy(self);
	438	comp.gpa().destroy(self);
439	439	}
440	440
441	441	pub fn getLlvmType(self: Enum, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -447,7 +447,7 @@ pub const Type = struct {
447	447	base: Type,
448	448
449	449	pub fn destroy(self: Union, comp: Compilation) void {
450		comp.a().destroy(self);
	450	comp.gpa().destroy(self);
451	451	}
452	452
453	453	pub fn getLlvmType(self: Union, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -459,7 +459,7 @@ pub const Type = struct {
459	459	base: Type,
460	460
461	461	pub fn destroy(self: Namespace, comp: Compilation) void {
462		comp.a().destroy(self);
	462	comp.gpa().destroy(self);
463	463	}
464	464	};
465	465
...	...	@@ -467,7 +467,7 @@ pub const Type = struct {
467	467	base: Type,
468	468
469	469	pub fn destroy(self: Block, comp: Compilation) void {
470		comp.a().destroy(self);
	470	comp.gpa().destroy(self);
471	471	}
472	472	};
473	473
...	...	@@ -475,7 +475,7 @@ pub const Type = struct {
475	475	base: Type,
476	476
477	477	pub fn destroy(self: BoundFn, comp: Compilation) void {
478		comp.a().destroy(self);
	478	comp.gpa().destroy(self);
479	479	}
480	480
481	481	pub fn getLlvmType(self: BoundFn, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -487,7 +487,7 @@ pub const Type = struct {
487	487	base: Type,
488	488
489	489	pub fn destroy(self: ArgTuple, comp: Compilation) void {
490		comp.a().destroy(self);
	490	comp.gpa().destroy(self);
491	491	}
492	492	};
493	493
...	...	@@ -495,7 +495,7 @@ pub const Type = struct {
495	495	base: Type,
496	496
497	497	pub fn destroy(self: Opaque, comp: Compilation) void {
498		comp.a().destroy(self);
	498	comp.gpa().destroy(self);
499	499	}
500	500
501	501	pub fn getLlvmType(self: Opaque, ofile: ObjectFile) llvm.TypeRef {
...	...	@@ -507,7 +507,7 @@ pub const Type = struct {
507	507	base: Type,
508	508
509	509	pub fn destroy(self: Promise, comp: Compilation) void {
510		comp.a().destroy(self);
	510	comp.gpa().destroy(self);
511	511	}
512	512
513	513	pub fn getLlvmType(self: Promise, ofile: ObjectFile) llvm.TypeRef {

src-self-hosted/value.zig+33-8

...	...	@@ -4,6 +4,7 @@ const Scope = @import("scope.zig").Scope;
4	4	const Compilation = @import("compilation.zig").Compilation;
5	5	const ObjectFile = @import("codegen.zig").ObjectFile;
6	6	const llvm = @import("llvm.zig");
	7	const Buffer = std.Buffer;
7	8
8	9	/// Values are ref-counted, heap-allocated, and copy-on-write
9	10	/// If there is only 1 ref then write need not copy
...	...	@@ -68,7 +69,7 @@ pub const Value = struct {
68	69
69	70	/// The main external name that is used in the .o file.
70	71	/// TODO https://github.com/ziglang/zig/issues/265
71		symbol_name: std.Buffer,
	72	symbol_name: Buffer,
72	73
73	74	/// parent should be the top level decls or container decls
74	75	fndef_scope: *Scope.FnDef,
...	...	@@ -79,10 +80,22 @@ pub const Value = struct {
79	80	/// parent is child_scope
80	81	block_scope: *Scope.Block,
81	82
	83	/// Path to the object file that contains this function
	84	containing_object: Buffer,
	85
	86	link_set_node: std.LinkedList(?Value.Fn).Node,
	87
82	88	/// Creates a Fn value with 1 ref
83	89	/// Takes ownership of symbol_name
84		pub fn create(comp: Compilation, fn_type: Type.Fn, fndef_scope: Scope.FnDef, symbol_name: std.Buffer) !Fn {
85		const self = try comp.a().create(Fn{
	90	pub fn create(comp: Compilation, fn_type: Type.Fn, fndef_scope: Scope.FnDef, symbol_name: Buffer) !Fn {
	91	const link_set_node = try comp.gpa().create(Compilation.FnLinkSet.Node{
	92	.data = null,
	93	.next = undefined,
	94	.prev = undefined,
	95	});
	96	errdefer comp.gpa().destroy(link_set_node);
	97
	98	const self = try comp.gpa().create(Fn{
86	99	.base = Value{
87	100	.id = Value.Id.Fn,
88	101	.typeof = &fn_type.base,
...	...	@@ -92,6 +105,8 @@ pub const Value = struct {
92	105	.child_scope = &fndef_scope.base,
93	106	.block_scope = undefined,
94	107	.symbol_name = symbol_name,
	108	.containing_object = Buffer.initNull(comp.gpa()),
	109	.link_set_node = link_set_node,
95	110	});
96	111	fn_type.base.base.ref();
97	112	fndef_scope.fn_val = self;
...	...	@@ -100,9 +115,19 @@ pub const Value = struct {
100	115	}
101	116
102	117	pub fn destroy(self: Fn, comp: Compilation) void {
	118	// remove with a tombstone so that we do not have to grab a lock
	119	if (self.link_set_node.data != null) {
	120	// it's now the job of the link step to find this tombstone and
	121	// deallocate it.
	122	self.link_set_node.data = null;
	123	} else {
	124	comp.gpa().destroy(self.link_set_node);
	125	}
	126
	127	self.containing_object.deinit();
103	128	self.fndef_scope.base.deref(comp);
104	129	self.symbol_name.deinit();
105		comp.a().destroy(self);
	130	comp.gpa().destroy(self);
106	131	}
107	132	};
108	133
...	...	@@ -115,7 +140,7 @@ pub const Value = struct {
115	140	}
116	141
117	142	pub fn destroy(self: Void, comp: Compilation) void {
118		comp.a().destroy(self);
	143	comp.gpa().destroy(self);
119	144	}
120	145	};
121	146
...	...	@@ -134,7 +159,7 @@ pub const Value = struct {
134	159	}
135	160
136	161	pub fn destroy(self: Bool, comp: Compilation) void {
137		comp.a().destroy(self);
	162	comp.gpa().destroy(self);
138	163	}
139	164
140	165	pub fn getLlvmConst(self: Bool, ofile: ObjectFile) ?llvm.ValueRef {
...	...	@@ -156,7 +181,7 @@ pub const Value = struct {
156	181	}
157	182
158	183	pub fn destroy(self: NoReturn, comp: Compilation) void {
159		comp.a().destroy(self);
	184	comp.gpa().destroy(self);
160	185	}
161	186	};
162	187
...	...	@@ -170,7 +195,7 @@ pub const Value = struct {
170	195	};
171	196
172	197	pub fn destroy(self: Ptr, comp: Compilation) void {
173		comp.a().destroy(self);
	198	comp.gpa().destroy(self);
174	199	}
175	200	};
176	201	};

src/zig_llvm.cpp+5

...	...	@@ -440,6 +440,11 @@ ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unreso
440	440	return reinterpret_cast<ZigLLVMDIBuilder *>(di_builder);
441	441	}
442	442
	443	void ZigLLVMDisposeDIBuilder(ZigLLVMDIBuilder *dbuilder) {
	444	DIBuilder di_builder = reinterpret_cast<DIBuilder >(dbuilder);
	445	delete di_builder;
	446	}
	447
443	448	void ZigLLVMSetCurrentDebugLocation(LLVMBuilderRef builder, int line, int column, ZigLLVMDIScope *scope) {
444	449	unwrap(builder)->SetCurrentDebugLocation(DebugLoc::get(
445	450	line, column, reinterpret_cast<DIScope*>(scope)));

src/zig_llvm.h+2-1

...	...	@@ -39,7 +39,7 @@ struct ZigLLVMInsertionPoint;
39	39	ZIG_EXTERN_C void ZigLLVMInitializeLoopStrengthReducePass(LLVMPassRegistryRef R);
40	40	ZIG_EXTERN_C void ZigLLVMInitializeLowerIntrinsicsPass(LLVMPassRegistryRef R);
41	41
42		/// Caller must free memory.
	42	/// Caller must free memory with LLVMDisposeMessage
43	43	ZIG_EXTERN_C char *ZigLLVMGetHostCPUName(void);
44	44	ZIG_EXTERN_C char *ZigLLVMGetNativeFeatures(void);
45	45
...	...	@@ -139,6 +139,7 @@ ZIG_EXTERN_C unsigned ZigLLVMTag_DW_enumeration_type(void);
139	139	ZIG_EXTERN_C unsigned ZigLLVMTag_DW_union_type(void);
140	140
141	141	ZIG_EXTERN_C struct ZigLLVMDIBuilder *ZigLLVMCreateDIBuilder(LLVMModuleRef module, bool allow_unresolved);
	142	ZIG_EXTERN_C void ZigLLVMDisposeDIBuilder(struct ZigLLVMDIBuilder *dbuilder);
142	143	ZIG_EXTERN_C void ZigLLVMAddModuleDebugInfoFlag(LLVMModuleRef module);
143	144	ZIG_EXTERN_C void ZigLLVMAddModuleCodeViewFlag(LLVMModuleRef module);
144	145

std/atomic/int.zig+4

...	...	@@ -25,5 +25,9 @@ pub fn Int(comptime T: type) type {
25	25	pub fn get(self: *Self) T {
26	26	return @atomicLoad(T, &self.unprotected_value, AtomicOrder.SeqCst);
27	27	}
	28
	29	pub fn xchg(self: *Self, new_value: T) T {
	30	return @atomicRmw(T, &self.unprotected_value, builtin.AtomicRmwOp.Xchg, new_value, AtomicOrder.SeqCst);
	31	}
28	32	};
29	33	}

std/buffer.zig+13

...	...	@@ -54,6 +54,19 @@ pub const Buffer = struct {
54	54	return result;
55	55	}
56	56
	57	pub fn allocPrint(allocator: *Allocator, comptime format: []const u8, args: ...) !Buffer {
	58	const countSize = struct {
	59	fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
	60	size.* += bytes.len;
	61	}
	62	}.countSize;
	63	var size: usize = 0;
	64	std.fmt.format(&size, error{}, countSize, format, args) catch \|err\| switch (err) {};
	65	var self = try Buffer.initSize(allocator, size);
	66	assert((std.fmt.bufPrint(self.list.items, format, args) catch unreachable).len == size);
	67	return self;
	68	}
	69
57	70	pub fn deinit(self: *Buffer) void {
58	71	self.list.deinit();
59	72	}

std/dwarf.zig+37

...	...	@@ -639,3 +639,40 @@ pub const LNE_define_file = 0x03;
639	639	pub const LNE_set_discriminator = 0x04;
640	640	pub const LNE_lo_user = 0x80;
641	641	pub const LNE_hi_user = 0xff;
	642
	643	pub const LANG_C89 = 0x0001;
	644	pub const LANG_C = 0x0002;
	645	pub const LANG_Ada83 = 0x0003;
	646	pub const LANG_C_plus_plus = 0x0004;
	647	pub const LANG_Cobol74 = 0x0005;
	648	pub const LANG_Cobol85 = 0x0006;
	649	pub const LANG_Fortran77 = 0x0007;
	650	pub const LANG_Fortran90 = 0x0008;
	651	pub const LANG_Pascal83 = 0x0009;
	652	pub const LANG_Modula2 = 0x000a;
	653	pub const LANG_Java = 0x000b;
	654	pub const LANG_C99 = 0x000c;
	655	pub const LANG_Ada95 = 0x000d;
	656	pub const LANG_Fortran95 = 0x000e;
	657	pub const LANG_PLI = 0x000f;
	658	pub const LANG_ObjC = 0x0010;
	659	pub const LANG_ObjC_plus_plus = 0x0011;
	660	pub const LANG_UPC = 0x0012;
	661	pub const LANG_D = 0x0013;
	662	pub const LANG_Python = 0x0014;
	663	pub const LANG_Go = 0x0016;
	664	pub const LANG_C_plus_plus_11 = 0x001a;
	665	pub const LANG_Rust = 0x001c;
	666	pub const LANG_C11 = 0x001d;
	667	pub const LANG_C_plus_plus_14 = 0x0021;
	668	pub const LANG_Fortran03 = 0x0022;
	669	pub const LANG_Fortran08 = 0x0023;
	670	pub const LANG_lo_user = 0x8000;
	671	pub const LANG_hi_user = 0xffff;
	672	pub const LANG_Mips_Assembler = 0x8001;
	673	pub const LANG_Upc = 0x8765;
	674	pub const LANG_HP_Bliss = 0x8003;
	675	pub const LANG_HP_Basic91 = 0x8004;
	676	pub const LANG_HP_Pascal91 = 0x8005;
	677	pub const LANG_HP_IMacro = 0x8006;
	678	pub const LANG_HP_Assembler = 0x8007;

std/event/future.zig+31-8

...	...	@@ -6,15 +6,20 @@ const AtomicOrder = builtin.AtomicOrder;
6	6	const Lock = std.event.Lock;
7	7	const Loop = std.event.Loop;
8	8
9		/// This is a value that starts out unavailable, until a value is put().
	9	/// This is a value that starts out unavailable, until resolve() is called
10	10	/// While it is unavailable, coroutines suspend when they try to get() it,
11		/// and then are resumed when the value is put().
12		/// At this point the value remains forever available, and another put() is not allowed.
	11	/// and then are resumed when resolve() is called.
	12	/// At this point the value remains forever available, and another resolve() is not allowed.
13	13	pub fn Future(comptime T: type) type {
14	14	return struct {
15	15	lock: Lock,
16	16	data: T,
17		available: u8, // TODO make this a bool
	17
	18	/// TODO make this an enum
	19	/// 0 - not started
	20	/// 1 - started
	21	/// 2 - finished
	22	available: u8,
18	23
19	24	const Self = this;
20	25	const Queue = std.atomic.Queue(promise);
...	...	@@ -31,7 +36,7 @@ pub fn Future(comptime T: type) type {
31	36	/// available.
32	37	/// Thread-safe.
33	38	pub async fn get(self: Self) T {
34		if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 1) {
	39	if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 2) {
35	40	return &self.data;
36	41	}
37	42	const held = await (async self.lock.acquire() catch unreachable);
...	...	@@ -43,18 +48,36 @@ pub fn Future(comptime T: type) type {
43	48	/// Gets the data without waiting for it. If it's available, a pointer is
44	49	/// returned. Otherwise, null is returned.
45	50	pub fn getOrNull(self: Self) ?T {
46		if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 1) {
	51	if (@atomicLoad(u8, &self.available, AtomicOrder.SeqCst) == 2) {
47	52	return &self.data;
48	53	} else {
49	54	return null;
50	55	}
51	56	}
52	57
	58	/// If someone else has started working on the data, wait for them to complete
	59	/// and return a pointer to the data. Otherwise, return null, and the caller
	60	/// should start working on the data.
	61	/// It's not required to call start() before resolve() but it can be useful since
	62	/// this method is thread-safe.
	63	pub async fn start(self: Self) ?T {
	64	const state = @cmpxchgStrong(u8, &self.available, 0, 1, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return null;
	65	switch (state) {
	66	1 => {
	67	const held = await (async self.lock.acquire() catch unreachable);
	68	held.release();
	69	return &self.data;
	70	},
	71	2 => return &self.data,
	72	else => unreachable,
	73	}
	74	}
	75
53	76	/// Make the data become available. May be called only once.
54	77	/// Before calling this, modify the `data` property.
55	78	pub fn resolve(self: *Self) void {
56		const prev = @atomicRmw(u8, &self.available, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
57		assert(prev == 0); // put() called twice
	79	const prev = @atomicRmw(u8, &self.available, AtomicRmwOp.Xchg, 2, AtomicOrder.SeqCst);
	80	assert(prev == 0 or prev == 1); // resolve() called twice
58	81	Lock.Held.release(Lock.Held{ .lock = &self.lock });
59	82	}
60	83	};

std/index.zig+3

...	...	@@ -36,6 +36,8 @@ pub const sort = @import("sort.zig");
36	36	pub const unicode = @import("unicode.zig");
37	37	pub const zig = @import("zig/index.zig");
38	38
	39	pub const lazyInit = @import("lazy_init.zig").lazyInit;
	40
39	41	test "std" {
40	42	// run tests from these
41	43	_ = @import("atomic/index.zig");
...	...	@@ -71,4 +73,5 @@ test "std" {
71	73	_ = @import("sort.zig");
72	74	_ = @import("unicode.zig");
73	75	_ = @import("zig/index.zig");
	76	_ = @import("lazy_init.zig");
74	77	}

std/lazy_init.zig created+85

...	...	@@ -0,0 +1,85 @@
	1	const std = @import("index.zig");
	2	const builtin = @import("builtin");
	3	const assert = std.debug.assert;
	4	const AtomicRmwOp = builtin.AtomicRmwOp;
	5	const AtomicOrder = builtin.AtomicOrder;
	6
	7	/// Thread-safe initialization of global data.
	8	/// TODO use a mutex instead of a spinlock
	9	pub fn lazyInit(comptime T: type) LazyInit(T) {
	10	return LazyInit(T){
	11	.data = undefined,
	12	.state = 0,
	13	};
	14	}
	15
	16	fn LazyInit(comptime T: type) type {
	17	return struct {
	18	state: u8, // TODO make this an enum
	19	data: Data,
	20
	21	const Self = this;
	22
	23	// TODO this isn't working for void, investigate and then remove this special case
	24	const Data = if (@sizeOf(T) == 0) u8 else T;
	25	const Ptr = if (T == void) void else *T;
	26
	27	/// Returns a usable pointer to the initialized data,
	28	/// or returns null, indicating that the caller should
	29	/// perform the initialization and then call resolve().
	30	pub fn get(self: *Self) ?Ptr {
	31	while (true) {
	32	var state = @cmpxchgWeak(u8, &self.state, 0, 1, AtomicOrder.SeqCst, AtomicOrder.SeqCst) orelse return null;
	33	switch (state) {
	34	0 => continue,
	35	1 => {
	36	// TODO mutex instead of a spinlock
	37	continue;
	38	},
	39	2 => {
	40	if (@sizeOf(T) == 0) {
	41	return T(undefined);
	42	} else {
	43	return &self.data;
	44	}
	45	},
	46	else => unreachable,
	47	}
	48	}
	49	}
	50
	51	pub fn resolve(self: *Self) void {
	52	const prev = @atomicRmw(u8, &self.state, AtomicRmwOp.Xchg, 2, AtomicOrder.SeqCst);
	53	assert(prev == 1); // resolve() called twice
	54	}
	55	};
	56	}
	57
	58	var global_number = lazyInit(i32);
	59
	60	test "std.lazyInit" {
	61	if (global_number.get()) \|_\| @panic("bad") else {
	62	global_number.data = 1234;
	63	global_number.resolve();
	64	}
	65	if (global_number.get()) \|x\| {
	66	assert(x.* == 1234);
	67	} else {
	68	@panic("bad");
	69	}
	70	if (global_number.get()) \|x\| {
	71	assert(x.* == 1234);
	72	} else {
	73	@panic("bad");
	74	}
	75	}
	76
	77	var global_void = lazyInit(void);
	78
	79	test "std.lazyInit(void)" {
	80	if (global_void.get()) \|_\| @panic("bad") else {
	81	global_void.resolve();
	82	}
	83	assert(global_void.get() != null);
	84	assert(global_void.get() != null);
	85	}