Commit ef7fa76001f873824b0f64dfc2172ed2f304c348 | zig

author	Andrew Kelley <andrew@ziglang.org> 2021-09-24 00:54:44-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-09-24 01:00:15-07:00
log	ef7fa76001f873824b0f64dfc2172ed2f304c348
tree	ea739ef9170f446568c6a328ff9428f78c0ad165
parent	f215d98043ef948a996ac036609f4b71fa9c3c13

stage2: enable building freestanding libc with LLVM backend

 * LLVM backend: respect `sub_path` just like the other stage2 backends
   do.
 * Compilation has some new logic to only emit work queue jobs for
   building stuff when it believes itself to be capable. The linker
   backends no longer have duplicate logic; instead they respect the
   optional bit on the respective asset.

7 files changed, 60 insertions(+), 61 deletions(-)

src
- Compilation.zig
- codegen
  - llvm.zig
- link.zig
- link

src/Compilation.zig+22-18

...	@@ -1574,25 +1574,29 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {	...	@@ -1574,25 +1574,29 @@ pub fn create(gpa: Allocator, options: InitOptions) !Compilation {
1574	// also test the use case of `build-obj -fcompiler-rt` with the self-hosted compiler	1574	// also test the use case of `build-obj -fcompiler-rt` with the self-hosted compiler
1575	// and make sure the compiler-rt symbols are emitted. Currently this is hooked up for	1575	// and make sure the compiler-rt symbols are emitted. Currently this is hooked up for
1576	// stage1 but not stage2.	1576	// stage1 but not stage2.
1577	if (comp.bin_file.options.use_stage1) {	1577	const capable_of_building_compiler_rt = comp.bin_file.options.use_stage1;
1578	if (comp.bin_file.options.include_compiler_rt) {	1578	const capable_of_building_ssp = comp.bin_file.options.use_stage1;
1579	if (is_exe_or_dyn_lib) {	1579	const capable_of_building_zig_libc = comp.bin_file.options.use_stage1 or
1580	try comp.work_queue.writeItem(.{ .compiler_rt_lib = {} });	1580	comp.bin_file.options.use_llvm;
1581	} else if (options.output_mode != .Obj) {	1581
1582	// If build-obj with -fcompiler-rt is requested, that is handled specially	1582	if (comp.bin_file.options.include_compiler_rt and capable_of_building_compiler_rt) {
1583	// elsewhere. In this case we are making a static library, so we ask	1583	if (is_exe_or_dyn_lib) {
1584	// for a compiler-rt object to put in it.	1584	try comp.work_queue.writeItem(.{ .compiler_rt_lib = {} });
1585	try comp.work_queue.writeItem(.{ .compiler_rt_obj = {} });	1585	} else if (options.output_mode != .Obj) {
1586	}	1586	// If build-obj with -fcompiler-rt is requested, that is handled specially
		1587	// elsewhere. In this case we are making a static library, so we ask
		1588	// for a compiler-rt object to put in it.
		1589	try comp.work_queue.writeItem(.{ .compiler_rt_obj = {} });
1587	}	1590	}
1588	if (needs_c_symbols) {	1591	}
1589	// MinGW provides no libssp, use our own implementation.	1592	if (needs_c_symbols) {
1590	if (comp.getTarget().isMinGW()) {	1593	// MinGW provides no libssp, use our own implementation.
1591	try comp.work_queue.writeItem(.{ .libssp = {} });	1594	if (comp.getTarget().isMinGW() and capable_of_building_ssp) {
1592	}	1595	try comp.work_queue.writeItem(.{ .libssp = {} });
1593	if (!comp.bin_file.options.link_libc) {	1596	}
1594	try comp.work_queue.writeItem(.{ .zig_libc = {} });	1597
1595	}	1598	if (!comp.bin_file.options.link_libc and capable_of_building_zig_libc) {
		1599	try comp.work_queue.writeItem(.{ .zig_libc = {} });
1596	}	1600	}
1597	}	1601	}
1598	}	1602	}

src/codegen/llvm.zig+13-15

 @@ -164,15 +164,17 @@ pub const Object = struct {
     /// * it works for functions not all globals.
     /// Therefore, this table keeps track of the mapping.
     decl_map: std.AutoHashMapUnmanaged(*const Module.Decl, *const llvm.Value),
+    /// Where to put the output object file, relative to bin_file.options.emit directory.
+    sub_path: []const u8,
-    pub fn create(gpa: *Allocator, options: link.Options) !*Object {
+    pub fn create(gpa: *Allocator, sub_path: []const u8, options: link.Options) !*Object {
         const obj = try gpa.create(Object);
         errdefer gpa.destroy(obj);
-        obj.* = try Object.init(gpa, options);
+        obj.* = try Object.init(gpa, sub_path, options);
         return obj;
     }
-    pub fn init(gpa: *Allocator, options: link.Options) !Object {
+    pub fn init(gpa: *Allocator, sub_path: []const u8, options: link.Options) !Object {
         const context = llvm.Context.create();
         errdefer context.dispose();
 @@ -251,6 +253,7 @@ pub const Object = struct {
             .context = context,
             .target_machine = target_machine,
             .decl_map = .{},
+            .sub_path = sub_path,
         };
     }
 @@ -301,23 +304,18 @@ pub const Object = struct {
         const mod = comp.bin_file.options.module.?;
         const cache_dir = mod.zig_cache_artifact_directory;
-        const emit_bin_path: ?[*:0]const u8 = if (comp.bin_file.options.emit != null) blk: {
+        const emit_bin_path: ?[*:0]const u8 = if (comp.bin_file.options.emit) |emit|
-            const obj_basename = try std.zig.binNameAlloc(arena, .{
+            try emit.directory.joinZ(arena, &[_][]const u8{self.sub_path})
-                .root_name = comp.bin_file.options.root_name,
+        else
-                .target = comp.bin_file.options.target,
+            null;
-                .output_mode = .Obj,
-            });
-            if (cache_dir.joinZ(arena, &[_][]const u8{obj_basename})) |p| {
-                break :blk p.ptr;
-            } else |err| {
-                return err;
-            }
-        } else null;
         const emit_asm_path = try locPath(arena, comp.emit_asm, cache_dir);
         const emit_llvm_ir_path = try locPath(arena, comp.emit_llvm_ir, cache_dir);
         const emit_llvm_bc_path = try locPath(arena, comp.emit_llvm_bc, cache_dir);
+        const debug_emit_path = emit_bin_path orelse "(none)";
+        log.debug("emit LLVM object to {s}", .{debug_emit_path});
         var error_message: [*:0]const u8 = undefined;
         if (self.target_machine.emitToFile(
             self.llvm_module,

src/link.zig+3

 @@ -245,6 +245,9 @@ pub const File = struct {
         };
         if (use_lld) {
+            // TODO this intermediary_basename isn't enough; in the case of `zig build-exe`,
+            // we also want to put the intermediary object file in the cache while the
+            // main emit directory is the cwd.
             file.intermediary_basename = sub_path;
         }

src/link/Coff.zig+13-15

 @@ -132,7 +132,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
         const self = try createEmpty(allocator, options);
         errdefer self.base.destroy();
-        self.llvm_object = try LlvmObject.create(allocator, options);
+        self.llvm_object = try LlvmObject.create(allocator, sub_path, options);
         return self;
     }
 @@ -884,11 +884,8 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
     // If there is no Zig code to compile, then we should skip flushing the output file because it
     // will not be part of the linker line anyway.
     const module_obj_path: ?[]const u8 = if (self.base.options.module) |module| blk: {
-        // Both stage1 and stage2 LLVM backend put the object file in the cache directory.
+        const use_stage1 = build_options.is_stage1 and self.base.options.use_stage1;
-        if (self.base.options.use_llvm) {
+        if (use_stage1) {
-            // Stage2 has to call flushModule since that outputs the LLVM object file.
-            if (!build_options.is_stage1 or !self.base.options.use_stage1) try self.flushModule(comp);
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
                 .target = self.base.options.target,
 @@ -1269,22 +1266,23 @@ fn linkWithLLD(self: *Coff, comp: *Compilation) !void {
             try argv.append(comp.libunwind_static_lib.?.full_object_path);
         }
-        // TODO: remove when stage2 can build compiler_rt.zig, c.zig and ssp.zig
+        if (is_exe_or_dyn_lib and !self.base.options.skip_linker_dependencies) {
-        // compiler-rt, libc and libssp
-        if (is_exe_or_dyn_lib and
-            !self.base.options.skip_linker_dependencies and
-            build_options.is_stage1 and self.base.options.use_stage1)
-        {
             if (!self.base.options.link_libc) {
-                try argv.append(comp.libc_static_lib.?.full_object_path);
+                if (comp.libc_static_lib) |lib| {
+                    try argv.append(lib.full_object_path);
+                }
             }
             // MinGW doesn't provide libssp symbols
             if (target.abi.isGnu()) {
-                try argv.append(comp.libssp_static_lib.?.full_object_path);
+                if (comp.libssp_static_lib) |lib| {
+                    try argv.append(lib.full_object_path);
+                }
             }
             // MSVC compiler_rt is missing some stuff, so we build it unconditionally but
             // and rely on weak linkage to allow MSVC compiler_rt functions to override ours.
-            try argv.append(comp.compiler_rt_static_lib.?.full_object_path);
+            if (comp.compiler_rt_static_lib) |lib| {
+                try argv.append(lib.full_object_path);
+            }
         }
         try argv.ensureUnusedCapacity(self.base.options.system_libs.count());

src/link/Elf.zig+7-11

 @@ -235,7 +235,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
         const self = try createEmpty(allocator, options);
         errdefer self.base.destroy();
-        self.llvm_object = try LlvmObject.create(allocator, options);
+        self.llvm_object = try LlvmObject.create(allocator, sub_path, options);
         return self;
     }
 @@ -1254,11 +1254,8 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
     // If there is no Zig code to compile, then we should skip flushing the output file because it
     // will not be part of the linker line anyway.
     const module_obj_path: ?[]const u8 = if (self.base.options.module) |module| blk: {
-        // Both stage1 and stage2 LLVM backend put the object file in the cache directory.
+        // stage1 puts the object file in the cache directory.
-        if (self.base.options.use_llvm) {
+        if (self.base.options.use_stage1) {
-            // Stage2 has to call flushModule since that outputs the LLVM object file.
-            if (!build_options.is_stage1 or !self.base.options.use_stage1) try self.flushModule(comp);
             const obj_basename = try std.zig.binNameAlloc(arena, .{
                 .root_name = self.base.options.root_name,
                 .target = self.base.options.target,
 @@ -1621,14 +1618,13 @@ fn linkWithLLD(self: *Elf, comp: *Compilation) !void {
         }
         // libc
-        // TODO: enable when stage2 can build c.zig
         if (is_exe_or_dyn_lib and
             !self.base.options.skip_linker_dependencies and
-            !self.base.options.link_libc and
+            !self.base.options.link_libc)
-            build_options.is_stage1 and
-            self.base.options.use_stage1)
         {
-            try argv.append(comp.libc_static_lib.?.full_object_path);
+            if (comp.libc_static_lib) |lib| {
+                try argv.append(lib.full_object_path);
+            }
         }
         // compiler-rt

src/link/MachO.zig+1-1

...	@@ -290,7 +290,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio	...	@@ -290,7 +290,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
290	const self = try createEmpty(allocator, options);	290	const self = try createEmpty(allocator, options);
291	errdefer self.base.destroy();	291	errdefer self.base.destroy();
292		292
293	self.llvm_object = try LlvmObject.create(allocator, options);	293	self.llvm_object = try LlvmObject.create(allocator, sub_path, options);
294	return self;	294	return self;
295	}	295	}
296		296

src/link/Wasm.zig+1-1

...	@@ -121,7 +121,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio	...	@@ -121,7 +121,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
121	const self = try createEmpty(allocator, options);	121	const self = try createEmpty(allocator, options);
122	errdefer self.base.destroy();	122	errdefer self.base.destroy();
123		123
124	self.llvm_object = try LlvmObject.create(allocator, options);	124	self.llvm_object = try LlvmObject.create(allocator, sub_path, options);
125	return self;	125	return self;
126	}	126	}
127		127