Commit 5533f77054acad376f2fce0d529569a7449e9949 | zig

CMakeLists.txt+1

...	@@ -792,6 +792,7 @@ set(BUILD_ZIG1_ARGS	...	@@ -792,6 +792,7 @@ set(BUILD_ZIG1_ARGS
792	--name zig1	792	--name zig1
793	--zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"	793	--zig-lib-dir "${CMAKE_SOURCE_DIR}/lib"
794	"-femit-bin=${ZIG1_OBJECT}"	794	"-femit-bin=${ZIG1_OBJECT}"
		795	-fcompiler-rt
795	"${ZIG1_RELEASE_ARG}"	796	"${ZIG1_RELEASE_ARG}"
796	"${ZIG1_SINGLE_THREADED_ARG}"	797	"${ZIG1_SINGLE_THREADED_ARG}"
797	-lc	798	-lc

doc/docgen.zig+4-4

...	@@ -1,5 +1,5 @@	...	@@ -1,5 +1,5 @@
1	const std = @import("std");	1	const std = @import("std");
2	const builtin = std.builtin;	2	const builtin = @import("builtin");
3	const io = std.io;	3	const io = std.io;
4	const fs = std.fs;	4	const fs = std.fs;
5	const process = std.process;	5	const process = std.process;
...	@@ -13,7 +13,7 @@ const Allocator = std.mem.Allocator;	...	@@ -13,7 +13,7 @@ const Allocator = std.mem.Allocator;
13	const max_doc_file_size = 10 * 1024 * 1024;	13	const max_doc_file_size = 10 * 1024 * 1024;
14		14
15	const exe_ext = @as(std.zig.CrossTarget, .{}).exeFileExt();	15	const exe_ext = @as(std.zig.CrossTarget, .{}).exeFileExt();
16	const obj_ext = @as(std.zig.CrossTarget, .{}).oFileExt();	16	const obj_ext = builtin.object_format.fileExt(builtin.cpu.arch);
17	const tmp_dir_name = "docgen_tmp";	17	const tmp_dir_name = "docgen_tmp";
18	const test_out_path = tmp_dir_name ++ fs.path.sep_str ++ "test" ++ exe_ext;	18	const test_out_path = tmp_dir_name ++ fs.path.sep_str ++ "test" ++ exe_ext;
19		19
...	@@ -281,7 +281,7 @@ const Code = struct {	...	@@ -281,7 +281,7 @@ const Code = struct {
281	name: []const u8,	281	name: []const u8,
282	source_token: Token,	282	source_token: Token,
283	is_inline: bool,	283	is_inline: bool,
284	mode: builtin.Mode,	284	mode: std.builtin.Mode,
285	link_objects: []const []const u8,	285	link_objects: []const []const u8,
286	target_str: ?[]const u8,	286	target_str: ?[]const u8,
287	link_libc: bool,	287	link_libc: bool,
...	@@ -531,7 +531,7 @@ fn genToc(allocator: Allocator, tokenizer: Tokenizer) !Toc {	...	@@ -531,7 +531,7 @@ fn genToc(allocator: Allocator, tokenizer: Tokenizer) !Toc {
531	return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {s}", .{code_kind_str});	531	return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {s}", .{code_kind_str});
532	}	532	}
533		533
534	var mode: builtin.Mode = .Debug;	534	var mode: std.builtin.Mode = .Debug;
535	var link_objects = std.ArrayList([]const u8).init(allocator);	535	var link_objects = std.ArrayList([]const u8).init(allocator);
536	defer link_objects.deinit();	536	defer link_objects.deinit();
537	var target_str: ?[]const u8 = null;	537	var target_str: ?[]const u8 = null;

doc/langref.html.in+8-9

 @@ -5337,16 +5337,15 @@ test "implicit cast to comptime_int" {
 }
       {#code_end#}
       {#header_close#}
-      {#header_open|Type Coercion: Arrays and Pointers#}
+      {#header_open|Type Coercion: Slices, Arrays and Pointers#}
-      {#code_begin|test|coerce_arrays_and_ptrs#}
+      {#code_begin|test|coerce__slices_arrays_and_ptrs#}
 const std = @import("std");
 const expect = std.testing.expect;
-// This cast exists primarily so that string literals can be
+// You can assign constant pointers to arrays to a slice with
-// passed to functions that accept const slices. However
+// const modifier on the element type. Useful in particular for
-// it is probably going to be removed from the language when
+// String literals.
-// https://github.com/ziglang/zig/issues/265 is implemented.
+test "*const [N]T to []const T" {
-test "[N]T to []const T" {
     var x1: []const u8 = "hello";
     var x2: []const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
     try expect(std.mem.eql(u8, x1, x2));
 @@ -5356,7 +5355,7 @@ test "[N]T to []const T" {
 }
 // Likewise, it works when the destination type is an error union.
-test "[N]T to E![]const T" {
+test "*const [N]T to E![]const T" {
     var x1: anyerror![]const u8 = "hello";
     var x2: anyerror![]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
     try expect(std.mem.eql(u8, try x1, try x2));
 @@ -5366,7 +5365,7 @@ test "[N]T to E![]const T" {
 }
 // Likewise, it works when the destination type is an optional.
-test "[N]T to ?[]const T" {
+test "*const [N]T to ?[]const T" {
     var x1: ?[]const u8 = "hello";
     var x2: ?[]const u8 = &[5]u8{ 'h', 'e', 'l', 'l', 111 };
     try expect(std.mem.eql(u8, x1.?, x2.?));

lib/std/crypto/25519/field.zig+2-2

...	@@ -93,7 +93,7 @@ pub const Fe = struct {	...	@@ -93,7 +93,7 @@ pub const Fe = struct {
93	return s;	93	return s;
94	}	94	}
95		95
96	/// Map a 64-bit big endian string into a field element	96	/// Map a 64 bytes big endian string into a field element
97	pub fn fromBytes64(s: [64]u8) Fe {	97	pub fn fromBytes64(s: [64]u8) Fe {
98	var fl: [32]u8 = undefined;	98	var fl: [32]u8 = undefined;
99	var gl: [32]u8 = undefined;	99	var gl: [32]u8 = undefined;
...	@@ -106,7 +106,7 @@ pub const Fe = struct {	...	@@ -106,7 +106,7 @@ pub const Fe = struct {
106	gl[31] &= 0x7f;	106	gl[31] &= 0x7f;
107	var fe_f = fromBytes(fl);	107	var fe_f = fromBytes(fl);
108	const fe_g = fromBytes(gl);	108	const fe_g = fromBytes(gl);
109	fe_f.limbs[0] += (s[32] >> 7) * 19;	109	fe_f.limbs[0] += (s[32] >> 7) * 19 + @as(u10, s[0] >> 7) * 722;
110	i = 0;	110	i = 0;
111	while (i < 5) : (i += 1) {	111	while (i < 5) : (i += 1) {
112	fe_f.limbs[i] += 38 * fe_g.limbs[i];	112	fe_f.limbs[i] += 38 * fe_g.limbs[i];

lib/std/os/bits/linux.zig+5-5

...	@@ -339,19 +339,19 @@ pub const O_RDWR = 0o2;	...	@@ -339,19 +339,19 @@ pub const O_RDWR = 0o2;
339	pub const kernel_rwf = u32;	339	pub const kernel_rwf = u32;
340		340
341	/// high priority request, poll if possible	341	/// high priority request, poll if possible
342	pub const RWF_HIPRI = kernel_rwf(0x00000001);	342	pub const RWF_HIPRI: kernel_rwf = 0x00000001;
343		343
344	/// per-IO O_DSYNC	344	/// per-IO O_DSYNC
345	pub const RWF_DSYNC = kernel_rwf(0x00000002);	345	pub const RWF_DSYNC: kernel_rwf = 0x00000002;
346		346
347	/// per-IO O_SYNC	347	/// per-IO O_SYNC
348	pub const RWF_SYNC = kernel_rwf(0x00000004);	348	pub const RWF_SYNC: kernel_rwf = 0x00000004;
349		349
350	/// per-IO, return -EAGAIN if operation would block	350	/// per-IO, return -EAGAIN if operation would block
351	pub const RWF_NOWAIT = kernel_rwf(0x00000008);	351	pub const RWF_NOWAIT: kernel_rwf = 0x00000008;
352		352
353	/// per-IO O_APPEND	353	/// per-IO O_APPEND
354	pub const RWF_APPEND = kernel_rwf(0x00000010);	354	pub const RWF_APPEND: kernel_rwf = 0x00000010;
355		355
356	pub const SEEK_SET = 0;	356	pub const SEEK_SET = 0;
357	pub const SEEK_CUR = 1;	357	pub const SEEK_CUR = 1;

lib/std/os/windows/user32.zig+1-1

...	@@ -1336,7 +1336,7 @@ pub extern "user32" fn AdjustWindowRectEx(lpRect: *RECT, dwStyle: DWORD, bMenu:	...	@@ -1336,7 +1336,7 @@ pub extern "user32" fn AdjustWindowRectEx(lpRect: *RECT, dwStyle: DWORD, bMenu:
1336	pub fn adjustWindowRectEx(lpRect: *RECT, dwStyle: u32, bMenu: bool, dwExStyle: u32) !void {	1336	pub fn adjustWindowRectEx(lpRect: *RECT, dwStyle: u32, bMenu: bool, dwExStyle: u32) !void {
1337	assert(dwStyle & WS_OVERLAPPED == 0);	1337	assert(dwStyle & WS_OVERLAPPED == 0);
1338		1338
1339	if (AdjustWindowRectEx(lpRect, dwStyle, bMenu, dwExStyle) == 0) {	1339	if (AdjustWindowRectEx(lpRect, dwStyle, @boolToInt(bMenu), dwExStyle) == 0) {
1340	switch (GetLastError()) {	1340	switch (GetLastError()) {
1341	.INVALID_PARAMETER => unreachable,	1341	.INVALID_PARAMETER => unreachable,
1342	else => \|err\| return windows.unexpectedError(err),	1342	else => \|err\| return windows.unexpectedError(err),

lib/std/target.zig+63-37

 @@ -549,16 +549,36 @@ pub const Target = struct {
     };
     pub const ObjectFormat = enum {
+        /// Common Object File Format (Windows)
         coff,
-        pe,
+        /// Executable and Linking Format
         elf,
+        /// macOS relocatables
         macho,
+        /// WebAssembly
         wasm,
+        /// C source code
         c,
+        /// Standard, Portable Intermediate Representation V
         spirv,
+        /// Intel IHEX
         hex,
+        /// Machine code with no metadata.
         raw,
+        /// Plan 9 from Bell Labs
         plan9,
+        pub fn fileExt(of: ObjectFormat, cpu_arch: Cpu.Arch) [:0]const u8 {
+            return switch (of) {
+                .coff => ".obj",
+                .elf, .macho, .wasm => ".o",
+                .c => ".c",
+                .spirv => ".spv",
+                .hex => ".ihex",
+                .raw => ".bin",
+                .plan9 => plan9Ext(cpu_arch),
+            };
+        }
     };
     pub const SubSystem = enum {
 @@ -1290,30 +1310,16 @@ pub const Target = struct {
         return linuxTripleSimple(allocator, self.cpu.arch, self.os.tag, self.abi);
     }
-    pub fn oFileExt_os_abi(os_tag: Os.Tag, abi: Abi) [:0]const u8 {
-        if (abi == .msvc) {
-            return ".obj";
-        }
-        switch (os_tag) {
-            .windows, .uefi => return ".obj",
-            else => return ".o",
-        }
-    }
-    pub fn oFileExt(self: Target) [:0]const u8 {
-        return oFileExt_os_abi(self.os.tag, self.abi);
-    }
     pub fn exeFileExtSimple(cpu_arch: Cpu.Arch, os_tag: Os.Tag) [:0]const u8 {
-        switch (os_tag) {
+        return switch (os_tag) {
-            .windows => return ".exe",
+            .windows => ".exe",
-            .uefi => return ".efi",
+            .uefi => ".efi",
-            else => if (cpu_arch.isWasm()) {
+            .plan9 => plan9Ext(cpu_arch),
-                return ".wasm";
+            else => switch (cpu_arch) {
-            } else {
+                .wasm32, .wasm64 => ".wasm",
-                return "";
+                else => "",
             },
-        }
+        };
     }
     pub fn exeFileExt(self: Target) [:0]const u8 {
 @@ -1353,20 +1359,16 @@ pub const Target = struct {
     }
     pub fn getObjectFormatSimple(os_tag: Os.Tag, cpu_arch: Cpu.Arch) ObjectFormat {
-        if (os_tag == .windows or os_tag == .uefi) {
+        return switch (os_tag) {
-            return .coff;
+            .windows, .uefi => .coff,
-        } else if (os_tag.isDarwin()) {
+            .ios, .macos, .watchos, .tvos => .macho,
-            return .macho;
+            .plan9 => .plan9,
-        }
+            else => return switch (cpu_arch) {
-        if (cpu_arch.isWasm()) {
+                .wasm32, .wasm64 => .wasm,
-            return .wasm;
+                .spirv32, .spirv64 => .spirv,
-        }
+                else => .elf,
-        if (cpu_arch.isSPIRV()) {
+            },
-            return .spirv;
+        };
-        }
-        if (os_tag == .plan9)
-            return .plan9;
-        return .elf;
     }
     pub fn getObjectFormat(self: Target) ObjectFormat {
 @@ -1677,6 +1679,30 @@ pub const Target = struct {
         return false;
     }
+    /// 0c spim    little-endian MIPS 3000 family
+    /// 1c 68000   Motorola MC68000
+    /// 2c 68020   Motorola MC68020
+    /// 5c arm     little-endian ARM
+    /// 6c amd64   AMD64 and compatibles (e.g., Intel EM64T)
+    /// 7c arm64   ARM64 (ARMv8)
+    /// 8c 386     Intel i386, i486, Pentium, etc.
+    /// kc sparc   Sun SPARC
+    /// qc power   Power PC
+    /// vc mips    big-endian MIPS 3000 family
+    pub fn plan9Ext(cpu_arch: Cpu.Arch) [:0]const u8 {
+        return switch (cpu_arch) {
+            .arm => ".5",
+            .x86_64 => ".6",
+            .aarch64 => ".7",
+            .i386 => ".8",
+            .sparc => ".k",
+            .powerpc, .powerpcle => ".q",
+            .mips, .mipsel => ".v",
+            // ISAs without designated characters get 'X' for lack of a better option.
+            else => ".X",
+        };
+    }
 };
 test {

lib/std/zig.zig+10-30

 @@ -108,8 +108,9 @@ pub const BinNameOptions = struct {
 pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) error{OutOfMemory}![]u8 {
     const root_name = options.root_name;
     const target = options.target;
-    switch (options.object_format orelse target.getObjectFormat()) {
+    const ofmt = options.object_format orelse target.getObjectFormat();
-        .coff, .pe => switch (options.output_mode) {
+    switch (ofmt) {
+        .coff => switch (options.output_mode) {
             .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.exeFileExt() }),
             .Lib => {
                 const suffix = switch (options.link_mode orelse .Static) {
 @@ -118,7 +119,7 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
                 };
                 return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, suffix });
             },
-            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.oFileExt() }),
+            .Obj => return std.fmt.allocPrint(allocator, "{s}.obj", .{root_name}),
         },
         .elf => switch (options.output_mode) {
             .Exe => return allocator.dupe(u8, root_name),
 @@ -140,7 +141,7 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
                     },
                 }
             },
-            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.oFileExt() }),
+            .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
         },
         .macho => switch (options.output_mode) {
             .Exe => return allocator.dupe(u8, root_name),
 @@ -163,7 +164,7 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
                 }
                 return std.fmt.allocPrint(allocator, "{s}{s}{s}", .{ target.libPrefix(), root_name, suffix });
             },
-            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.oFileExt() }),
+            .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
         },
         .wasm => switch (options.output_mode) {
             .Exe => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.exeFileExt() }),
 @@ -175,36 +176,15 @@ pub fn binNameAlloc(allocator: *std.mem.Allocator, options: BinNameOptions) erro
                     .Dynamic => return std.fmt.allocPrint(allocator, "{s}.wasm", .{root_name}),
                 }
             },
-            .Obj => return std.fmt.allocPrint(allocator, "{s}{s}", .{ root_name, target.oFileExt() }),
+            .Obj => return std.fmt.allocPrint(allocator, "{s}.o", .{root_name}),
         },
         .c => return std.fmt.allocPrint(allocator, "{s}.c", .{root_name}),
         .spirv => return std.fmt.allocPrint(allocator, "{s}.spv", .{root_name}),
         .hex => return std.fmt.allocPrint(allocator, "{s}.ihex", .{root_name}),
         .raw => return std.fmt.allocPrint(allocator, "{s}.bin", .{root_name}),
-        .plan9 => {
+        .plan9 => return std.fmt.allocPrint(allocator, "{s}{s}", .{
-            // copied from 2c(1)
+            root_name, ofmt.fileExt(target.cpu.arch),
-            // 0c spim    little-endian MIPS 3000 family
+        }),
-            // 1c 68000   Motorola MC68000
-            // 2c 68020   Motorola MC68020
-            // 5c arm     little-endian ARM
-            // 6c amd64   AMD64 and compatibles (e.g., Intel EM64T)
-            // 7c arm64   ARM64 (ARMv8)
-            // 8c 386     Intel i386, i486, Pentium, etc.
-            // kc sparc   Sun SPARC
-            // qc power   Power PC
-            // vc mips    big-endian MIPS 3000 family
-            const char: u8 = switch (target.cpu.arch) {
-                .arm => '5',
-                .x86_64 => '6',
-                .aarch64 => '7',
-                .i386 => '8',
-                .sparc => 'k',
-                .powerpc, .powerpcle => 'q',
-                .mips, .mipsel => 'v',
-                else => 'X', // this arch does not have a char or maybe was not ported to plan9 so we just use X
-            };
-            return std.fmt.allocPrint(allocator, "{s}.{c}", .{ root_name, char });
-        },
     }
 }

lib/std/zig/c_translation.zig+132

...	@@ -350,3 +350,135 @@ test "Flexible Array Type" {	...	@@ -350,3 +350,135 @@ test "Flexible Array Type" {
350	try testing.expectEqual(FlexibleArrayType(volatile Container, c_int), [c]volatile c_int);	350	try testing.expectEqual(FlexibleArrayType(volatile Container, c_int), [c]volatile c_int);
351	try testing.expectEqual(FlexibleArrayType(const volatile Container, c_int), [c]const volatile c_int);	351	try testing.expectEqual(FlexibleArrayType(const volatile Container, c_int), [c]const volatile c_int);
352	}	352	}
		353
		354	pub const Macros = struct {
		355	pub fn U_SUFFIX(comptime n: comptime_int) @TypeOf(promoteIntLiteral(c_uint, n, .decimal)) {
		356	return promoteIntLiteral(c_uint, n, .decimal);
		357	}
		358
		359	fn L_SUFFIX_ReturnType(comptime number: anytype) type {
		360	switch (@TypeOf(number)) {
		361	comptime_int => return @TypeOf(promoteIntLiteral(c_long, number, .decimal)),
		362	comptime_float => return c_longdouble,
		363	else => @compileError("Invalid value for L suffix"),
		364	}
		365	}
		366	pub fn L_SUFFIX(comptime number: anytype) L_SUFFIX_ReturnType(number) {
		367	switch (@TypeOf(number)) {
		368	comptime_int => return promoteIntLiteral(c_long, number, .decimal),
		369	comptime_float => @compileError("TODO: c_longdouble initialization from comptime_float not supported"),
		370	else => @compileError("Invalid value for L suffix"),
		371	}
		372	}
		373
		374	pub fn UL_SUFFIX(comptime n: comptime_int) @TypeOf(promoteIntLiteral(c_ulong, n, .decimal)) {
		375	return promoteIntLiteral(c_ulong, n, .decimal);
		376	}
		377
		378	pub fn LL_SUFFIX(comptime n: comptime_int) @TypeOf(promoteIntLiteral(c_longlong, n, .decimal)) {
		379	return promoteIntLiteral(c_longlong, n, .decimal);
		380	}
		381
		382	pub fn ULL_SUFFIX(comptime n: comptime_int) @TypeOf(promoteIntLiteral(c_ulonglong, n, .decimal)) {
		383	return promoteIntLiteral(c_ulonglong, n, .decimal);
		384	}
		385
		386	pub fn F_SUFFIX(comptime f: comptime_float) f32 {
		387	return @as(f32, f);
		388	}
		389
		390	pub fn WL_CONTAINER_OF(ptr: anytype, sample: anytype, comptime member: []const u8) @TypeOf(sample) {
		391	return @fieldParentPtr(@TypeOf(sample.*), member, ptr);
		392	}
		393
		394	/// A 2-argument function-like macro defined as #define FOO(A, B) (A)(B)
		395	/// could be either: cast B to A, or call A with the value B.
		396	pub fn CAST_OR_CALL(a: anytype, b: anytype) switch (@typeInfo(@TypeOf(a))) {
		397	.Type => a,
		398	.Fn => \|fn_info\| fn_info.return_type orelse void,
		399	else => \|info\| @compileError("Unexpected argument type: " ++ @tagName(info)),
		400	} {
		401	switch (@typeInfo(@TypeOf(a))) {
		402	.Type => return cast(a, b),
		403	.Fn => return a(b),
		404	else => unreachable, // return type will be a compile error otherwise
		405	}
		406	}
		407	};
		408
		409	test "Macro suffix functions" {
		410	try testing.expect(@TypeOf(Macros.F_SUFFIX(1)) == f32);
		411
		412	try testing.expect(@TypeOf(Macros.U_SUFFIX(1)) == c_uint);
		413	if (math.maxInt(c_ulong) > math.maxInt(c_uint)) {
		414	try testing.expect(@TypeOf(Macros.U_SUFFIX(math.maxInt(c_uint) + 1)) == c_ulong);
		415	}
		416	if (math.maxInt(c_ulonglong) > math.maxInt(c_ulong)) {
		417	try testing.expect(@TypeOf(Macros.U_SUFFIX(math.maxInt(c_ulong) + 1)) == c_ulonglong);
		418	}
		419
		420	try testing.expect(@TypeOf(Macros.L_SUFFIX(1)) == c_long);
		421	if (math.maxInt(c_long) > math.maxInt(c_int)) {
		422	try testing.expect(@TypeOf(Macros.L_SUFFIX(math.maxInt(c_int) + 1)) == c_long);
		423	}
		424	if (math.maxInt(c_longlong) > math.maxInt(c_long)) {
		425	try testing.expect(@TypeOf(Macros.L_SUFFIX(math.maxInt(c_long) + 1)) == c_longlong);
		426	}
		427
		428	try testing.expect(@TypeOf(Macros.UL_SUFFIX(1)) == c_ulong);
		429	if (math.maxInt(c_ulonglong) > math.maxInt(c_ulong)) {
		430	try testing.expect(@TypeOf(Macros.UL_SUFFIX(math.maxInt(c_ulong) + 1)) == c_ulonglong);
		431	}
		432
		433	try testing.expect(@TypeOf(Macros.LL_SUFFIX(1)) == c_longlong);
		434	try testing.expect(@TypeOf(Macros.ULL_SUFFIX(1)) == c_ulonglong);
		435	}
		436
		437	test "WL_CONTAINER_OF" {
		438	const S = struct {
		439	a: u32 = 0,
		440	b: u32 = 0,
		441	};
		442	var x = S{};
		443	var y = S{};
		444	var ptr = Macros.WL_CONTAINER_OF(&x.b, &y, "b");
		445	try testing.expectEqual(&x, ptr);
		446	}
		447
		448	test "CAST_OR_CALL casting" {
		449	var arg = @as(c_int, 1000);
		450	var casted = Macros.CAST_OR_CALL(u8, arg);
		451	try testing.expectEqual(cast(u8, arg), casted);
		452
		453	const S = struct {
		454	x: u32 = 0,
		455	};
		456	var s = S{};
		457	var casted_ptr = Macros.CAST_OR_CALL(*u8, &s);
		458	try testing.expectEqual(cast(*u8, &s), casted_ptr);
		459	}
		460
		461	test "CAST_OR_CALL calling" {
		462	const Helper = struct {
		463	var last_val: bool = false;
		464	fn returnsVoid(val: bool) void {
		465	last_val = val;
		466	}
		467	fn returnsBool(f: f32) bool {
		468	return f > 0;
		469	}
		470	fn identity(self: c_uint) c_uint {
		471	return self;
		472	}
		473	};
		474
		475	Macros.CAST_OR_CALL(Helper.returnsVoid, true);
		476	try testing.expectEqual(true, Helper.last_val);
		477	Macros.CAST_OR_CALL(Helper.returnsVoid, false);
		478	try testing.expectEqual(false, Helper.last_val);
		479
		480	try testing.expectEqual(Helper.returnsBool(1), Macros.CAST_OR_CALL(Helper.returnsBool, @as(f32, 1)));
		481	try testing.expectEqual(Helper.returnsBool(-1), Macros.CAST_OR_CALL(Helper.returnsBool, @as(f32, -1)));
		482
		483	try testing.expectEqual(Helper.identity(@as(c_uint, 100)), Macros.CAST_OR_CALL(Helper.identity, @as(c_uint, 100)));
		484	}

lib/std/zig/cross_target.zig-4

 @@ -473,10 +473,6 @@ pub const CrossTarget = struct {
         return self.getOsTag() == .windows;
     }
-    pub fn oFileExt(self: CrossTarget) [:0]const u8 {
-        return Target.oFileExt_os_abi(self.getOsTag(), self.getAbi());
-    }
     pub fn exeFileExt(self: CrossTarget) [:0]const u8 {
         return Target.exeFileExtSimple(self.getCpuArch(), self.getOsTag());
     }

src/AstGen.zig+10-1

...	@@ -5009,6 +5009,7 @@ fn ifExpr(	...	@@ -5009,6 +5009,7 @@ fn ifExpr(
5009	const token_name_str = tree.tokenSlice(token_name_index);	5009	const token_name_str = tree.tokenSlice(token_name_index);
5010	if (mem.eql(u8, "_", token_name_str))	5010	if (mem.eql(u8, "_", token_name_str))
5011	break :s &then_scope.base;	5011	break :s &then_scope.base;
		5012	try astgen.detectLocalShadowing(&then_scope.base, ident_name, token_name_index);
5012	payload_val_scope = .{	5013	payload_val_scope = .{
5013	.parent = &then_scope.base,	5014	.parent = &then_scope.base,
5014	.gen_zir = &then_scope,	5015	.gen_zir = &then_scope,
...	@@ -5031,6 +5032,7 @@ fn ifExpr(	...	@@ -5031,6 +5032,7 @@ fn ifExpr(
5031	break :s &then_scope.base;	5032	break :s &then_scope.base;
5032	const payload_inst = try then_scope.addUnNode(tag, cond.inst, node);	5033	const payload_inst = try then_scope.addUnNode(tag, cond.inst, node);
5033	const ident_name = try astgen.identAsString(ident_token);	5034	const ident_name = try astgen.identAsString(ident_token);
		5035	try astgen.detectLocalShadowing(&then_scope.base, ident_name, ident_token);
5034	payload_val_scope = .{	5036	payload_val_scope = .{
5035	.parent = &then_scope.base,	5037	.parent = &then_scope.base,
5036	.gen_zir = &then_scope,	5038	.gen_zir = &then_scope,
...	@@ -5072,6 +5074,7 @@ fn ifExpr(	...	@@ -5072,6 +5074,7 @@ fn ifExpr(
5072	const error_token_str = tree.tokenSlice(error_token);	5074	const error_token_str = tree.tokenSlice(error_token);
5073	if (mem.eql(u8, "_", error_token_str))	5075	if (mem.eql(u8, "_", error_token_str))
5074	break :s &else_scope.base;	5076	break :s &else_scope.base;
		5077	try astgen.detectLocalShadowing(&else_scope.base, ident_name, error_token);
5075	payload_val_scope = .{	5078	payload_val_scope = .{
5076	.parent = &else_scope.base,	5079	.parent = &else_scope.base,
5077	.gen_zir = &else_scope,	5080	.gen_zir = &else_scope,
...	@@ -5265,7 +5268,9 @@ fn whileExpr(	...	@@ -5265,7 +5268,9 @@ fn whileExpr(
5265	const ident_token = if (payload_is_ref) payload_token + 1 else payload_token;	5268	const ident_token = if (payload_is_ref) payload_token + 1 else payload_token;
5266	if (mem.eql(u8, "_", tree.tokenSlice(ident_token)))	5269	if (mem.eql(u8, "_", tree.tokenSlice(ident_token)))
5267	break :s &then_scope.base;	5270	break :s &then_scope.base;
5268	const ident_name = try astgen.identAsString(payload_token + @boolToInt(payload_is_ref));	5271	const payload_name_loc = payload_token + @boolToInt(payload_is_ref);
		5272	const ident_name = try astgen.identAsString(payload_name_loc);
		5273	try astgen.detectLocalShadowing(&then_scope.base, ident_name, payload_name_loc);
5269	payload_val_scope = .{	5274	payload_val_scope = .{
5270	.parent = &then_scope.base,	5275	.parent = &then_scope.base,
5271	.gen_zir = &then_scope,	5276	.gen_zir = &then_scope,
...	@@ -5288,6 +5293,7 @@ fn whileExpr(	...	@@ -5288,6 +5293,7 @@ fn whileExpr(
5288	const ident_name = try astgen.identAsString(ident_token);	5293	const ident_name = try astgen.identAsString(ident_token);
5289	if (mem.eql(u8, "_", tree.tokenSlice(ident_token)))	5294	if (mem.eql(u8, "_", tree.tokenSlice(ident_token)))
5290	break :s &then_scope.base;	5295	break :s &then_scope.base;
		5296	try astgen.detectLocalShadowing(&then_scope.base, ident_name, ident_token);
5291	payload_val_scope = .{	5297	payload_val_scope = .{
5292	.parent = &then_scope.base,	5298	.parent = &then_scope.base,
5293	.gen_zir = &then_scope,	5299	.gen_zir = &then_scope,
...	@@ -5345,6 +5351,7 @@ fn whileExpr(	...	@@ -5345,6 +5351,7 @@ fn whileExpr(
5345	const ident_name = try astgen.identAsString(error_token);	5351	const ident_name = try astgen.identAsString(error_token);
5346	if (mem.eql(u8, tree.tokenSlice(error_token), "_"))	5352	if (mem.eql(u8, tree.tokenSlice(error_token), "_"))
5347	break :s &else_scope.base;	5353	break :s &else_scope.base;
		5354	try astgen.detectLocalShadowing(&else_scope.base, ident_name, error_token);
5348	payload_val_scope = .{	5355	payload_val_scope = .{
5349	.parent = &else_scope.base,	5356	.parent = &else_scope.base,
5350	.gen_zir = &else_scope,	5357	.gen_zir = &else_scope,
...	@@ -5484,6 +5491,7 @@ fn forExpr(	...	@@ -5484,6 +5491,7 @@ fn forExpr(
5484	const name_str_index = try astgen.identAsString(ident);	5491	const name_str_index = try astgen.identAsString(ident);
5485	const tag: Zir.Inst.Tag = if (is_ptr) .elem_ptr else .elem_val;	5492	const tag: Zir.Inst.Tag = if (is_ptr) .elem_ptr else .elem_val;
5486	const payload_inst = try then_scope.addBin(tag, array_ptr, index);	5493	const payload_inst = try then_scope.addBin(tag, array_ptr, index);
		5494	try astgen.detectLocalShadowing(&then_scope.base, name_str_index, ident);
5487	payload_val_scope = .{	5495	payload_val_scope = .{
5488	.parent = &then_scope.base,	5496	.parent = &then_scope.base,
5489	.gen_zir = &then_scope,	5497	.gen_zir = &then_scope,
...	@@ -5507,6 +5515,7 @@ fn forExpr(	...	@@ -5507,6 +5515,7 @@ fn forExpr(
5507	return astgen.failTok(index_token, "discard of index capture; omit it instead", .{});	5515	return astgen.failTok(index_token, "discard of index capture; omit it instead", .{});
5508	}	5516	}
5509	const index_name = try astgen.identAsString(index_token);	5517	const index_name = try astgen.identAsString(index_token);
		5518	try astgen.detectLocalShadowing(payload_sub_scope, index_name, index_token);
5510	index_scope = .{	5519	index_scope = .{
5511	.parent = payload_sub_scope,	5520	.parent = payload_sub_scope,
5512	.gen_zir = &then_scope,	5521	.gen_zir = &then_scope,

src/Compilation.zig+59-18

 @@ -143,6 +143,7 @@ debug_compiler_runtime_libs: bool,
 emit_asm: ?EmitLoc,
 emit_llvm_ir: ?EmitLoc,
+emit_llvm_bc: ?EmitLoc,
 emit_analysis: ?EmitLoc,
 emit_docs: ?EmitLoc,
 @@ -586,6 +587,17 @@ pub const Directory = struct {
             return std.fs.path.join(allocator, paths);
         }
     }
+    pub fn joinZ(self: Directory, allocator: *Allocator, paths: []const []const u8) ![:0]u8 {
+        if (self.path) |p| {
+            // TODO clean way to do this with only 1 allocation
+            const part2 = try std.fs.path.join(allocator, paths);
+            defer allocator.free(part2);
+            return std.fs.path.joinZ(allocator, &[_][]const u8{ p, part2 });
+        } else {
+            return std.fs.path.joinZ(allocator, paths);
+        }
+    }
 };
 pub const EmitLoc = struct {
 @@ -623,6 +635,8 @@ pub const InitOptions = struct {
     emit_asm: ?EmitLoc = null,
     /// `null` means to not emit LLVM IR.
     emit_llvm_ir: ?EmitLoc = null,
+    /// `null` means to not emit LLVM module bitcode.
+    emit_llvm_bc: ?EmitLoc = null,
     /// `null` means to not emit semantic analysis JSON.
     emit_analysis: ?EmitLoc = null,
     /// `null` means to not emit docs.
 @@ -812,6 +826,9 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         const ofmt = options.object_format orelse options.target.getObjectFormat();
         const use_stage1 = options.use_stage1 orelse blk: {
+            // Even though we may have no Zig code to compile (depending on `options.root_pkg`),
+            // we may need to use stage1 for building compiler-rt and other dependencies.
             if (build_options.omit_stage2)
                 break :blk true;
             if (options.use_llvm) |use_llvm| {
 @@ -819,6 +836,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
                     break :blk false;
                 }
             }
             break :blk build_options.is_stage1;
         };
 @@ -835,6 +853,10 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             if (ofmt == .c)
                 break :blk false;
+            // If emitting to LLVM bitcode object format, must use LLVM backend.
+            if (options.emit_llvm_ir != null or options.emit_llvm_bc != null)
+                break :blk true;
             // The stage1 compiler depends on the stage1 C++ LLVM backend
             // to compile zig code.
             if (use_stage1)
 @@ -853,6 +875,9 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             if (options.machine_code_model != .default) {
                 return error.MachineCodeModelNotSupportedWithoutLlvm;
             }
+            if (options.emit_llvm_ir != null or options.emit_llvm_bc != null) {
+                return error.EmittingLlvmModuleRequiresUsingLlvmBackend;
+            }
         }
         const tsan = options.want_tsan orelse false;
 @@ -996,7 +1021,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             break :blk lm;
         } else default_link_mode;
-        const dll_export_fns = if (options.dll_export_fns) |explicit| explicit else is_dyn_lib;
+        const dll_export_fns = if (options.dll_export_fns) |explicit| explicit else is_dyn_lib or options.rdynamic;
         const libc_dirs = try detectLibCIncludeDirs(
             arena,
 @@ -1386,6 +1411,7 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
             .bin_file = bin_file,
             .emit_asm = options.emit_asm,
             .emit_llvm_ir = options.emit_llvm_ir,
+            .emit_llvm_bc = options.emit_llvm_bc,
             .emit_analysis = options.emit_analysis,
             .emit_docs = options.emit_docs,
             .work_queue = std.fifo.LinearFifo(Job, .Dynamic).init(gpa),
 @@ -1518,24 +1544,19 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
         }
         // The `use_stage1` condition is here only because stage2 cannot yet build compiler-rt.
-        // Once it is capable this condition should be removed.
+        // Once it is capable this condition should be removed. When removing this condition,
+        // also test the use case of `build-obj -fcompiler-rt` with the self-hosted compiler
+        // and make sure the compiler-rt symbols are emitted. Currently this is hooked up for
+        // stage1 but not stage2.
         if (comp.bin_file.options.use_stage1) {
             if (comp.bin_file.options.include_compiler_rt) {
                 if (is_exe_or_dyn_lib) {
                     try comp.work_queue.writeItem(.{ .compiler_rt_lib = {} });
-                } else {
+                } else if (options.output_mode != .Obj) {
+                    // If build-obj with -fcompiler-rt is requested, that is handled specially
+                    // elsewhere. In this case we are making a static library, so we ask
+                    // for a compiler-rt object to put in it.
                     try comp.work_queue.writeItem(.{ .compiler_rt_obj = {} });
-                    if (comp.bin_file.options.object_format != .elf and
-                        comp.bin_file.options.output_mode == .Obj)
-                    {
-                        // For ELF we can rely on using -r to link multiple objects together into one,
-                        // but to truly support `build-obj -fcompiler-rt` will require virtually
-                        // injecting `_ = @import("compiler_rt.zig")` into the root source file of
-                        // the compilation.
-                        fatal("Embedding compiler-rt into {s} objects is not yet implemented.", .{
-                            @tagName(comp.bin_file.options.object_format),
-                        });
-                    }
                 }
             }
             if (needs_c_symbols) {
 @@ -2733,7 +2754,10 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
         comp.bin_file.options.root_name
     else
         c_source_basename[0 .. c_source_basename.len - std.fs.path.extension(c_source_basename).len];
-    const o_basename = try std.fmt.allocPrint(arena, "{s}{s}", .{ o_basename_noext, comp.getTarget().oFileExt() });
+    const o_basename = try std.fmt.allocPrint(arena, "{s}{s}", .{
+        o_basename_noext,
+        comp.bin_file.options.object_format.fileExt(comp.bin_file.options.target.cpu.arch),
+    });
     const digest = if (!comp.disable_c_depfile and try man.hit()) man.final() else blk: {
         var argv = std.ArrayList([]const u8).init(comp.gpa);
 @@ -3028,7 +3052,7 @@ pub fn addCCArgs(
             if (!comp.bin_file.options.strip) {
                 try argv.append("-g");
                 switch (comp.bin_file.options.object_format) {
-                    .coff, .pe => try argv.append("-gcodeview"),
+                    .coff => try argv.append("-gcodeview"),
                     else => {},
                 }
             }
 @@ -3954,6 +3978,16 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
     const id_symlink_basename = "stage1.id";
     const libs_txt_basename = "libs.txt";
+    // The include_compiler_rt stored in the bin file options here means that we need
+    // compiler-rt symbols *somehow*. However, in the context of using the stage1 backend
+    // we need to tell stage1 to include compiler-rt only if stage1 is the place that
+    // needs to provide those symbols. Otherwise the stage2 infrastructure will take care
+    // of it in the linker, by putting compiler_rt.o into a static archive, or linking
+    // compiler_rt.a against an executable. In other words we only want to set this flag
+    // for stage1 if we are using build-obj.
+    const include_compiler_rt = comp.bin_file.options.output_mode == .Obj and
+        comp.bin_file.options.include_compiler_rt;
     // We are about to obtain this lock, so here we give other processes a chance first.
     comp.releaseStage1Lock();
 @@ -3975,6 +4009,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
     man.hash.add(target.os.getVersionRange());
     man.hash.add(comp.bin_file.options.dll_export_fns);
     man.hash.add(comp.bin_file.options.function_sections);
+    man.hash.add(include_compiler_rt);
     man.hash.add(comp.bin_file.options.is_test);
     man.hash.add(comp.bin_file.options.emit != null);
     man.hash.add(mod.emit_h != null);
 @@ -3983,6 +4018,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
     }
     man.hash.addOptionalEmitLoc(comp.emit_asm);
     man.hash.addOptionalEmitLoc(comp.emit_llvm_ir);
+    man.hash.addOptionalEmitLoc(comp.emit_llvm_bc);
     man.hash.addOptionalEmitLoc(comp.emit_analysis);
     man.hash.addOptionalEmitLoc(comp.emit_docs);
     man.hash.add(comp.test_evented_io);
 @@ -4088,13 +4124,14 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
     ) orelse return error.OutOfMemory;
     const emit_bin_path = if (comp.bin_file.options.emit != null) blk: {
-        const bin_basename = try std.zig.binNameAlloc(arena, .{
+        const obj_basename = try std.zig.binNameAlloc(arena, .{
             .root_name = comp.bin_file.options.root_name,
             .target = target,
             .output_mode = .Obj,
         });
-        break :blk try directory.join(arena, &[_][]const u8{bin_basename});
+        break :blk try directory.join(arena, &[_][]const u8{obj_basename});
     } else "";
     if (mod.emit_h != null) {
         log.warn("-femit-h is not available in the stage1 backend; no .h file will be produced", .{});
     }
 @@ -4102,6 +4139,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
     const emit_h_path = try stage1LocPath(arena, emit_h_loc, directory);
     const emit_asm_path = try stage1LocPath(arena, comp.emit_asm, directory);
     const emit_llvm_ir_path = try stage1LocPath(arena, comp.emit_llvm_ir, directory);
+    const emit_llvm_bc_path = try stage1LocPath(arena, comp.emit_llvm_bc, directory);
     const emit_analysis_path = try stage1LocPath(arena, comp.emit_analysis, directory);
     const emit_docs_path = try stage1LocPath(arena, comp.emit_docs, directory);
     const stage1_pkg = try createStage1Pkg(arena, "root", mod.root_pkg, null);
 @@ -4122,6 +4160,8 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
         .emit_asm_len = emit_asm_path.len,
         .emit_llvm_ir_ptr = emit_llvm_ir_path.ptr,
         .emit_llvm_ir_len = emit_llvm_ir_path.len,
+        .emit_bitcode_ptr = emit_llvm_bc_path.ptr,
+        .emit_bitcode_len = emit_llvm_bc_path.len,
         .emit_analysis_json_ptr = emit_analysis_path.ptr,
         .emit_analysis_json_len = emit_analysis_path.len,
         .emit_docs_ptr = emit_docs_path.ptr,
 @@ -4150,6 +4190,7 @@ fn updateStage1Module(comp: *Compilation, main_progress_node: *std.Progress.Node
         .valgrind_enabled = comp.bin_file.options.valgrind,
         .tsan_enabled = comp.bin_file.options.tsan,
         .function_sections = comp.bin_file.options.function_sections,
+        .include_compiler_rt = include_compiler_rt,
         .enable_stack_probing = comp.bin_file.options.stack_check,
         .red_zone = comp.bin_file.options.red_zone,
         .enable_time_report = comp.time_report,

src/codegen/llvm.zig+131-65

...	@@ -72,9 +72,9 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {	...	@@ -72,9 +72,9 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {
72	.renderscript32 => "renderscript32",	72	.renderscript32 => "renderscript32",
73	.renderscript64 => "renderscript64",	73	.renderscript64 => "renderscript64",
74	.ve => "ve",	74	.ve => "ve",
75	.spu_2 => return error.LLVMBackendDoesNotSupportSPUMarkII,	75	.spu_2 => return error.@"LLVM backend does not support SPU Mark II",
76	.spirv32 => return error.LLVMBackendDoesNotSupportSPIRV,	76	.spirv32 => return error.@"LLVM backend does not support SPIR-V",
77	.spirv64 => return error.LLVMBackendDoesNotSupportSPIRV,	77	.spirv64 => return error.@"LLVM backend does not support SPIR-V",
78	};	78	};
79		79
80	const llvm_os = switch (target.os.tag) {	80	const llvm_os = switch (target.os.tag) {
...	@@ -114,11 +114,13 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {	...	@@ -114,11 +114,13 @@ pub fn targetTriple(allocator: *Allocator, target: std.Target) ![:0]u8 {
114	.wasi => "wasi",	114	.wasi => "wasi",
115	.emscripten => "emscripten",	115	.emscripten => "emscripten",
116	.uefi => "windows",	116	.uefi => "windows",
117	.opencl => return error.LLVMBackendDoesNotSupportOpenCL,	117
118	.glsl450 => return error.LLVMBackendDoesNotSupportGLSL450,	118	.opencl,
119	.vulkan => return error.LLVMBackendDoesNotSupportVulkan,	119	.glsl450,
120	.plan9 => return error.LLVMBackendDoesNotSupportPlan9,	120	.vulkan,
121	.other => "unknown",	121	.plan9,
		122	.other,
		123	=> "unknown",
122	};	124	};
123		125
124	const llvm_abi = switch (target.abi) {	126	const llvm_abi = switch (target.abi) {
...	@@ -152,84 +154,105 @@ pub const Object = struct {	...	@@ -152,84 +154,105 @@ pub const Object = struct {
152	llvm_module: *const llvm.Module,	154	llvm_module: *const llvm.Module,
153	context: *const llvm.Context,	155	context: *const llvm.Context,
154	target_machine: *const llvm.TargetMachine,	156	target_machine: *const llvm.TargetMachine,
155	object_pathZ: [:0]const u8,
156
157	pub fn create(allocator: Allocator, sub_path: []const u8, options: link.Options) !Object {
158	_ = sub_path;
159	const self = try allocator.create(Object);
160	errdefer allocator.destroy(self);
161
162	const obj_basename = try std.zig.binNameAlloc(allocator, .{
163	.root_name = options.root_name,
164	.target = options.target,
165	.output_mode = .Obj,
166	});
167	defer allocator.free(obj_basename);
168		157
169	const o_directory = options.module.?.zig_cache_artifact_directory;	158	pub fn create(gpa: Allocator, options: link.Options) !Object {
170	const object_path = try o_directory.join(allocator, &[_][]const u8{obj_basename});	159	const obj = try gpa.create(Object);
171	defer allocator.free(object_path);	160	errdefer gpa.destroy(obj);
172		161	obj.* = try Object.init(gpa, options);
173	const object_pathZ = try allocator.dupeZ(u8, object_path);	162	return obj;
174	errdefer allocator.free(object_pathZ);	163	}
175		164
		165	pub fn init(gpa: *Allocator, options: link.Options) !Object {
176	const context = llvm.Context.create();	166	const context = llvm.Context.create();
177	errdefer context.dispose();	167	errdefer context.dispose();
178		168
179	initializeLLVMTargets();	169	initializeLLVMTargets();
180		170
181	const root_nameZ = try allocator.dupeZ(u8, options.root_name);	171	const root_nameZ = try gpa.dupeZ(u8, options.root_name);
182	defer allocator.free(root_nameZ);	172	defer gpa.free(root_nameZ);
183	const llvm_module = llvm.Module.createWithName(root_nameZ.ptr, context);	173	const llvm_module = llvm.Module.createWithName(root_nameZ.ptr, context);
184	errdefer llvm_module.dispose();	174	errdefer llvm_module.dispose();
185		175
186	const llvm_target_triple = try targetTriple(allocator, options.target);	176	const llvm_target_triple = try targetTriple(gpa, options.target);
187	defer allocator.free(llvm_target_triple);	177	defer gpa.free(llvm_target_triple);
188		178
189	var error_message: [*:0]const u8 = undefined;	179	var error_message: [*:0]const u8 = undefined;
190	var target: *const llvm.Target = undefined;	180	var target: *const llvm.Target = undefined;
191	if (llvm.Target.getFromTriple(llvm_target_triple.ptr, &target, &error_message).toBool()) {	181	if (llvm.Target.getFromTriple(llvm_target_triple.ptr, &target, &error_message).toBool()) {
192	defer llvm.disposeMessage(error_message);	182	defer llvm.disposeMessage(error_message);
193		183
194	const stderr = std.io.getStdErr().writer();	184	log.err("LLVM failed to parse '{s}': {s}", .{ llvm_target_triple, error_message });
195	try stderr.print(	185	return error.InvalidLlvmTriple;
196	\\Zig is expecting LLVM to understand this target: '{s}'
197	\\However LLVM responded with: "{s}"
198	\\
199	,
200	.{ llvm_target_triple, error_message },
201	);
202	return error.InvalidLLVMTriple;
203	}	186	}
204		187
205	const opt_level: llvm.CodeGenOptLevel = if (options.optimize_mode == .Debug) .None else .Aggressive;	188	const opt_level: llvm.CodeGenOptLevel = if (options.optimize_mode == .Debug)
		189	.None
		190	else
		191	.Aggressive;
		192
		193	const reloc_mode: llvm.RelocMode = if (options.pic)
		194	.PIC
		195	else if (options.link_mode == .Dynamic)
		196	llvm.RelocMode.DynamicNoPIC
		197	else
		198	.Static;
		199
		200	const code_model: llvm.CodeModel = switch (options.machine_code_model) {
		201	.default => .Default,
		202	.tiny => .Tiny,
		203	.small => .Small,
		204	.kernel => .Kernel,
		205	.medium => .Medium,
		206	.large => .Large,
		207	};
		208
		209	// TODO handle float ABI better- it should depend on the ABI portion of std.Target
		210	const float_abi: llvm.ABIType = .Default;
		211
		212	// TODO a way to override this as part of std.Target ABI?
		213	const abi_name: ?[*:0]const u8 = switch (options.target.cpu.arch) {
		214	.riscv32 => switch (options.target.os.tag) {
		215	.linux => "ilp32d",
		216	else => "ilp32",
		217	},
		218	.riscv64 => switch (options.target.os.tag) {
		219	.linux => "lp64d",
		220	else => "lp64",
		221	},
		222	else => null,
		223	};
		224
206	const target_machine = llvm.TargetMachine.create(	225	const target_machine = llvm.TargetMachine.create(
207	target,	226	target,
208	llvm_target_triple.ptr,	227	llvm_target_triple.ptr,
209	"",	228	if (options.target.cpu.model.llvm_name) \|s\| s.ptr else null,
210	"",	229	options.llvm_cpu_features,
211	opt_level,	230	opt_level,
212	.Static,	231	reloc_mode,
213	.Default,	232	code_model,
		233	options.function_sections,
		234	float_abi,
		235	abi_name,
214	);	236	);
215	errdefer target_machine.dispose();	237	errdefer target_machine.dispose();
216		238
217	self.* = .{	239	return Object{
218	.llvm_module = llvm_module,	240	.llvm_module = llvm_module,
219	.context = context,	241	.context = context,
220	.target_machine = target_machine,	242	.target_machine = target_machine,
221	.object_pathZ = object_pathZ,
222	};	243	};
223	return self;
224	}	244	}
225		245
226	pub fn deinit(self: Object, allocator: Allocator) void {	246	pub fn deinit(self: *Object) void {
227	self.target_machine.dispose();	247	self.target_machine.dispose();
228	self.llvm_module.dispose();	248	self.llvm_module.dispose();
229	self.context.dispose();	249	self.context.dispose();
		250	self.* = undefined;
		251	}
230		252
231	allocator.free(self.object_pathZ);	253	pub fn destroy(self: Object, gpa: Allocator) void {
232	allocator.destroy(self);	254	self.deinit();
		255	gpa.destroy(self);
233	}	256	}
234		257
235	fn initializeLLVMTargets() void {	258	fn initializeLLVMTargets() void {
...	@@ -240,38 +263,81 @@ pub const Object = struct {	...	@@ -240,38 +263,81 @@ pub const Object = struct {
240	llvm.initializeAllAsmParsers();	263	llvm.initializeAllAsmParsers();
241	}	264	}
242		265
		266	fn locPath(
		267	arena: *Allocator,
		268	opt_loc: ?Compilation.EmitLoc,
		269	cache_directory: Compilation.Directory,
		270	) !?[*:0]u8 {
		271	const loc = opt_loc orelse return null;
		272	const directory = loc.directory orelse cache_directory;
		273	const slice = try directory.joinZ(arena, &[_][]const u8{loc.basename});
		274	return slice.ptr;
		275	}
		276
243	pub fn flushModule(self: Object, comp: Compilation) !void {	277	pub fn flushModule(self: Object, comp: Compilation) !void {
244	if (comp.verbose_llvm_ir) {	278	if (comp.verbose_llvm_ir) {
245	const dump = self.llvm_module.printToString();	279	self.llvm_module.dump();
246	defer llvm.disposeMessage(dump);
247
248	const stderr = std.io.getStdErr().writer();
249	try stderr.writeAll(std.mem.spanZ(dump));
250	}	280	}
251		281
252	{	282	if (std.debug.runtime_safety) {
253	var error_message: [*:0]const u8 = undefined;	283	var error_message: [*:0]const u8 = undefined;
254	// verifyModule always allocs the error_message even if there is no error	284	// verifyModule always allocs the error_message even if there is no error
255	defer llvm.disposeMessage(error_message);	285	defer llvm.disposeMessage(error_message);
256		286
257	if (self.llvm_module.verify(.ReturnStatus, &error_message).toBool()) {	287	if (self.llvm_module.verify(.ReturnStatus, &error_message).toBool()) {
258	const stderr = std.io.getStdErr().writer();	288	std.debug.print("\n{s}\n", .{error_message});
259	try stderr.print("broken LLVM module found: {s}\nThis is a bug in the Zig compiler.", .{error_message});	289	@panic("LLVM module verification failed");
260	return error.BrokenLLVMModule;
261	}	290	}
262	}	291	}
263		292
		293	var arena_allocator = std.heap.ArenaAllocator.init(comp.gpa);
		294	defer arena_allocator.deinit();
		295	const arena = &arena_allocator.allocator;
		296
		297	const mod = comp.bin_file.options.module.?;
		298	const cache_dir = mod.zig_cache_artifact_directory;
		299
		300	const emit_bin_path: ?[*:0]const u8 = if (comp.bin_file.options.emit != null) blk: {
		301	const obj_basename = try std.zig.binNameAlloc(arena, .{
		302	.root_name = comp.bin_file.options.root_name,
		303	.target = comp.bin_file.options.target,
		304	.output_mode = .Obj,
		305	});
		306	if (cache_dir.joinZ(arena, &[_][]const u8{obj_basename})) \|p\| {
		307	break :blk p.ptr;
		308	} else \|err\| {
		309	return err;
		310	}
		311	} else null;
		312
		313	const emit_asm_path = try locPath(arena, comp.emit_asm, cache_dir);
		314	const emit_llvm_ir_path = try locPath(arena, comp.emit_llvm_ir, cache_dir);
		315	const emit_llvm_bc_path = try locPath(arena, comp.emit_llvm_bc, cache_dir);
		316
264	var error_message: [*:0]const u8 = undefined;	317	var error_message: [*:0]const u8 = undefined;
265	if (self.target_machine.emitToFile(	318	if (self.target_machine.emitToFile(
266	self.llvm_module,	319	self.llvm_module,
267	self.object_pathZ.ptr,
268	.ObjectFile,
269	&error_message,	320	&error_message,
270	).toBool()) {	321	comp.bin_file.options.optimize_mode == .Debug,
		322	comp.bin_file.options.optimize_mode == .ReleaseSmall,
		323	comp.time_report,
		324	comp.bin_file.options.tsan,
		325	comp.bin_file.options.lto,
		326	emit_asm_path,
		327	emit_bin_path,
		328	emit_llvm_ir_path,
		329	emit_llvm_bc_path,
		330	)) {
271	defer llvm.disposeMessage(error_message);	331	defer llvm.disposeMessage(error_message);
272		332
273	const stderr = std.io.getStdErr().writer();	333	const emit_asm_msg = emit_asm_path orelse "(none)";
274	try stderr.print("LLVM failed to emit file: {s}\n", .{error_message});	334	const emit_bin_msg = emit_bin_path orelse "(none)";
		335	const emit_llvm_ir_msg = emit_llvm_ir_path orelse "(none)";
		336	const emit_llvm_bc_msg = emit_llvm_bc_path orelse "(none)";
		337	log.err("LLVM failed to emit asm={s} bin={s} ir={s} bc={s}: {s}", .{
		338	emit_asm_msg, emit_bin_msg, emit_llvm_ir_msg, emit_llvm_bc_msg,
		339	error_message,
		340	});
275	return error.FailedToEmit;	341	return error.FailedToEmit;
276	}	342	}
277	}	343	}

src/codegen/llvm/bindings.zig+35-13

 @@ -123,6 +123,9 @@ pub const Module = opaque {
     pub const getNamedGlobal = LLVMGetNamedGlobal;
     extern fn LLVMGetNamedGlobal(M: *const Module, Name: [*:0]const u8) ?*const Value;
+    pub const dump = LLVMDumpModule;
+    extern fn LLVMDumpModule(M: *const Module) void;
 };
 pub const lookupIntrinsicID = LLVMLookupIntrinsicID;
 @@ -250,31 +253,41 @@ pub const BasicBlock = opaque {
 };
 pub const TargetMachine = opaque {
-    pub const create = LLVMCreateTargetMachine;
+    pub const create = ZigLLVMCreateTargetMachine;
-    extern fn LLVMCreateTargetMachine(
+    extern fn ZigLLVMCreateTargetMachine(
         T: *const Target,
         Triple: [*:0]const u8,
-        CPU: [*:0]const u8,
+        CPU: ?[*:0]const u8,
-        Features: [*:0]const u8,
+        Features: ?[*:0]const u8,
         Level: CodeGenOptLevel,
         Reloc: RelocMode,
-        CodeModel: CodeMode,
+        CodeModel: CodeModel,
+        function_sections: bool,
+        float_abi: ABIType,
+        abi_name: ?[*:0]const u8,
     ) *const TargetMachine;
     pub const dispose = LLVMDisposeTargetMachine;
     extern fn LLVMDisposeTargetMachine(T: *const TargetMachine) void;
-    pub const emitToFile = LLVMTargetMachineEmitToFile;
+    pub const emitToFile = ZigLLVMTargetMachineEmitToFile;
-    extern fn LLVMTargetMachineEmitToFile(
+    extern fn ZigLLVMTargetMachineEmitToFile(
-        *const TargetMachine,
+        T: *const TargetMachine,
         M: *const Module,
-        Filename: [*:0]const u8,
-        codegen: CodeGenFileType,
         ErrorMessage: *[*:0]const u8,
-    ) Bool;
+        is_debug: bool,
+        is_small: bool,
+        time_report: bool,
+        tsan: bool,
+        lto: bool,
+        asm_filename: ?[*:0]const u8,
+        bin_filename: ?[*:0]const u8,
+        llvm_ir_filename: ?[*:0]const u8,
+        bitcode_filename: ?[*:0]const u8,
+    ) bool;
 };
-pub const CodeMode = enum(c_int) {
+pub const CodeModel = enum(c_int) {
     Default,
     JITDefault,
     Tiny,
 @@ -295,7 +308,7 @@ pub const RelocMode = enum(c_int) {
     Default,
     Static,
     PIC,
-    DynamicNoPic,
+    DynamicNoPIC,
     ROPI,
     RWPI,
     ROPI_RWPI,
 @@ -306,6 +319,15 @@ pub const CodeGenFileType = enum(c_int) {
     ObjectFile,
 };
+pub const ABIType = enum(c_int) {
+    /// Target-specific (either soft or hard depending on triple, etc).
+    Default,
+    /// Soft float.
+    Soft,
+    // Hard float.
+    Hard,
+};
 pub const Target = opaque {
     pub const getFromTriple = LLVMGetTargetFromTriple;
     extern fn LLVMGetTargetFromTriple(Triple: [*:0]const u8, T: **const Target, ErrorMessage: *[*:0]const u8) Bool;

src/link.zig+10-6

 @@ -191,7 +191,7 @@ pub const File = struct {
         const use_stage1 = build_options.is_stage1 and options.use_stage1;
         if (use_stage1 or options.emit == null) {
             return switch (options.object_format) {
-                .coff, .pe => &(try Coff.createEmpty(allocator, options)).base,
+                .coff => &(try Coff.createEmpty(allocator, options)).base,
                 .elf => &(try Elf.createEmpty(allocator, options)).base,
                 .macho => &(try MachO.createEmpty(allocator, options)).base,
                 .wasm => &(try Wasm.createEmpty(allocator, options)).base,
 @@ -206,9 +206,10 @@ pub const File = struct {
         const use_lld = build_options.have_llvm and options.use_lld; // comptime known false when !have_llvm
         const sub_path = if (use_lld) blk: {
             if (options.module == null) {
-                // No point in opening a file, we would not write anything to it. Initialize with empty.
+                // No point in opening a file, we would not write anything to it.
+                // Initialize with empty.
                 return switch (options.object_format) {
-                    .coff, .pe => &(try Coff.createEmpty(allocator, options)).base,
+                    .coff => &(try Coff.createEmpty(allocator, options)).base,
                     .elf => &(try Elf.createEmpty(allocator, options)).base,
                     .macho => &(try MachO.createEmpty(allocator, options)).base,
                     .plan9 => &(try Plan9.createEmpty(allocator, options)).base,
 @@ -219,13 +220,16 @@ pub const File = struct {
                     .raw => return error.RawObjectFormatUnimplemented,
                 };
             }
-            // Open a temporary object file, not the final output file because we want to link with LLD.
+            // Open a temporary object file, not the final output file because we
-            break :blk try std.fmt.allocPrint(allocator, "{s}{s}", .{ emit.sub_path, options.target.oFileExt() });
+            // want to link with LLD.
+            break :blk try std.fmt.allocPrint(allocator, "{s}{s}", .{
+                emit.sub_path, options.object_format.fileExt(options.target.cpu.arch),
+            });
         } else emit.sub_path;
         errdefer if (use_lld) allocator.free(sub_path);
         const file: *File = switch (options.object_format) {
-            .coff, .pe => &(try Coff.openPath(allocator, sub_path, options)).base,
+            .coff => &(try Coff.openPath(allocator, sub_path, options)).base,
             .elf => &(try Elf.openPath(allocator, sub_path, options)).base,
             .macho => &(try MachO.openPath(allocator, sub_path, options)).base,
             .plan9 => &(try Plan9.openPath(allocator, sub_path, options)).base,

src/link/Coff.zig+13-12

src/link/Elf.zig+12-8

...	@@ -25,9 +25,9 @@ const target_util = @import("../target.zig");	...	@@ -25,9 +25,9 @@ const target_util = @import("../target.zig");
25	const glibc = @import("../glibc.zig");	25	const glibc = @import("../glibc.zig");
26	const musl = @import("../musl.zig");	26	const musl = @import("../musl.zig");
27	const Cache = @import("../Cache.zig");	27	const Cache = @import("../Cache.zig");
28	const llvm_backend = @import("../codegen/llvm.zig");
29	const Air = @import("../Air.zig");	28	const Air = @import("../Air.zig");
30	const Liveness = @import("../Liveness.zig");	29	const Liveness = @import("../Liveness.zig");
		30	const LlvmObject = @import("../codegen/llvm.zig").Object;
31		31
32	const default_entry_addr = 0x8000000;	32	const default_entry_addr = 0x8000000;
33		33
...	@@ -38,7 +38,7 @@ base: File,	...	@@ -38,7 +38,7 @@ base: File,
38	ptr_width: PtrWidth,	38	ptr_width: PtrWidth,
39		39
40	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.	40	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
41	llvm_object: ?*llvm_backend.Object = null,	41	llvm_object: ?*LlvmObject = null,
42		42
43	/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.	43	/// Stored in native-endian format, depending on target endianness needs to be bswapped on read/write.
44	/// Same order as in the file.	44	/// Same order as in the file.
...	@@ -235,7 +235,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio	...	@@ -235,7 +235,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
235	const self = try createEmpty(allocator, options);	235	const self = try createEmpty(allocator, options);
236	errdefer self.base.destroy();	236	errdefer self.base.destroy();
237		237
238	self.llvm_object = try llvm_backend.Object.create(allocator, sub_path, options);	238	self.llvm_object = try LlvmObject.create(allocator, options);
239	return self;	239	return self;
240	}	240	}
241		241
...	@@ -301,9 +301,9 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !Elf {	...	@@ -301,9 +301,9 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !Elf {
301	}	301	}
302		302
303	pub fn deinit(self: *Elf) void {	303	pub fn deinit(self: *Elf) void {
304	if (build_options.have_llvm)	304	if (build_options.have_llvm) {
305	if (self.llvm_object) \|ir_module\|	305	if (self.llvm_object) \|llvm_object\| llvm_object.destroy(self.base.allocator);
306	ir_module.deinit(self.base.allocator);	306	}
307		307
308	self.sections.deinit(self.base.allocator);	308	self.sections.deinit(self.base.allocator);
309	self.program_headers.deinit(self.base.allocator);	309	self.program_headers.deinit(self.base.allocator);
...	@@ -750,8 +750,8 @@ pub fn flushModule(self: Elf, comp: Compilation) !void {	...	@@ -750,8 +750,8 @@ pub fn flushModule(self: Elf, comp: Compilation) !void {
750	if (build_options.have_llvm)	750	if (build_options.have_llvm)
751	if (self.llvm_object) \|llvm_object\| return try llvm_object.flushModule(comp);	751	if (self.llvm_object) \|llvm_object\| return try llvm_object.flushModule(comp);
752		752
753	// TODO This linker code currently assumes there is only 1 compilation unit and it corresponds to the	753	// TODO This linker code currently assumes there is only 1 compilation unit and it
754	// Zig source code.	754	// corresponds to the Zig source code.
755	const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;	755	const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
756		756
757	const target_endian = self.base.options.target.cpu.arch.endian();	757	const target_endian = self.base.options.target.cpu.arch.endian();
...	@@ -1289,6 +1289,10 @@ fn linkWithLLD(self: Elf, comp: Compilation) !void {	...	@@ -1289,6 +1289,10 @@ fn linkWithLLD(self: Elf, comp: Compilation) !void {
1289	// TODO: remove when stage2 can build compiler_rt.zig	1289	// TODO: remove when stage2 can build compiler_rt.zig
1290	if (!build_options.is_stage1) break :blk null;	1290	if (!build_options.is_stage1) break :blk null;
1291		1291
		1292	// In the case of build-obj we include the compiler-rt symbols directly alongside
		1293	// the symbols of the root source file, in the same compilation unit.
		1294	if (is_obj) break :blk null;
		1295
1292	if (is_exe_or_dyn_lib) {	1296	if (is_exe_or_dyn_lib) {
1293	break :blk comp.compiler_rt_static_lib.?.full_object_path;	1297	break :blk comp.compiler_rt_static_lib.?.full_object_path;
1294	} else {	1298	} else {

src/link/MachO.zig+9-4

 @@ -29,21 +29,22 @@ const CodeSignature = @import("MachO/CodeSignature.zig");
 const Compilation = @import("../Compilation.zig");
 const DebugSymbols = @import("MachO/DebugSymbols.zig");
 const Dylib = @import("MachO/Dylib.zig");
+const File = link.File;
 const Object = @import("MachO/Object.zig");
 const Liveness = @import("../Liveness.zig");
+const LlvmObject = @import("../codegen/llvm.zig").Object;
 const LoadCommand = commands.LoadCommand;
 const Module = @import("../Module.zig");
-const File = link.File;
+const SegmentCommand = commands.SegmentCommand;
 pub const TextBlock = @import("MachO/TextBlock.zig");
 const Trie = @import("MachO/Trie.zig");
-const SegmentCommand = commands.SegmentCommand;
 pub const base_tag: File.Tag = File.Tag.macho;
 base: File,
 /// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
-llvm_object: ?*llvm_backend.Object = null,
+llvm_object: ?*LlvmObject = null,
 /// Debug symbols bundle (or dSym).
 d_sym: ?DebugSymbols = null,
 @@ -333,7 +334,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 llvm_backend.Object.create(allocator, sub_path, options);
+        self.llvm_object = try LlvmObject.create(allocator, options);
         return self;
     }
 @@ -3305,6 +3306,10 @@ fn writeSymbolTable(self: *MachO) !void {
 }
 pub fn deinit(self: *MachO) void {
+    if (build_options.have_llvm) {
+        if (self.llvm_object) |llvm_object| llvm_object.destroy(self.base.allocator);
+    }
     if (self.d_sym) |*ds| {
         ds.deinit(self.base.allocator);
     }

src/link/Wasm.zig+9-4

src/main.zig+40-22

 @@ -287,9 +287,9 @@ const usage_build_generic =
     \\                      .s    Target-specific assembly source code
     \\                      .S    Assembly with C preprocessor (requires LLVM extensions)
     \\                      .c    C source code (requires LLVM extensions)
-    \\                    .cpp    C++ source code (requires LLVM extensions)
+    \\        .cxx .cc .C .cpp    C++ source code (requires LLVM extensions)
-    \\                            Other C++ extensions: .C .cc .cxx
     \\                      .m    Objective-C source code (requires LLVM extensions)
+    \\                     .bc    LLVM IR Module (requires LLVM extensions)
     \\
     \\General Options:
     \\  -h, --help                Print this help and exit
 @@ -301,6 +301,8 @@ const usage_build_generic =
     \\  -fno-emit-asm             (default) Do not output .s (assembly code)
     \\  -femit-llvm-ir[=path]     Produce a .ll file with LLVM IR (requires LLVM extensions)
     \\  -fno-emit-llvm-ir         (default) Do not produce a .ll file with LLVM IR
+    \\  -femit-llvm-bc[=path]     Produce a LLVM module as a .bc file (requires LLVM extensions)
+    \\  -fno-emit-llvm-bc         (default) Do not produce a LLVM module as a .bc file
     \\  -femit-h[=path]           Generate a C header file (.h)
     \\  -fno-emit-h               (default) Do not generate a C header file (.h)
     \\  -femit-docs[=path]        Create a docs/ dir with html documentation
 @@ -359,15 +361,14 @@ const usage_build_generic =
     \\  --single-threaded         Code assumes it is only used single-threaded
     \\  -ofmt=[mode]              Override target object format
     \\    elf                     Executable and Linking Format
-    \\    c                       Compile to C source code
+    \\    c                       C source code
     \\    wasm                    WebAssembly
-    \\    pe                      Portable Executable (Windows)
     \\    coff                    Common Object File Format (Windows)
     \\    macho                   macOS relocatables
     \\    spirv                   Standard, Portable Intermediate Representation V (SPIR-V)
     \\    plan9                   Plan 9 from Bell Labs object format
-    \\    hex    (planned)        Intel IHEX
+    \\    hex  (planned feature)  Intel IHEX
-    \\    raw    (planned)        Dump machine code directly
+    \\    raw  (planned feature)  Dump machine code directly
     \\  -dirafter [dir]           Add directory to AFTER include search path
     \\  -isystem  [dir]           Add directory to SYSTEM include search path
     \\  -I[dir]                   Add directory to include search path
 @@ -384,8 +385,8 @@ const usage_build_generic =
     \\  --dynamic-linker [path]        Set the dynamic interpreter path (usually ld.so)
     \\  --sysroot [path]               Set the system root directory (usually /)
     \\  --version [ver]                Dynamic library semver
-    \\  -fsoname[=name]                (Linux) Override the default SONAME value
+    \\  -fsoname[=name]                Override the default SONAME value
-    \\  -fno-soname                    (Linux) Disable emitting a SONAME
+    \\  -fno-soname                    Disable emitting a SONAME
     \\  -fLLD                          Force using LLD as the linker
     \\  -fno-LLD                       Prevent using LLD as the linker
     \\  -fcompiler-rt                  Always include compiler-rt symbols in output
 @@ -552,6 +553,7 @@ fn buildOutputType(
     var emit_bin: EmitBin = .yes_default_path;
     var emit_asm: Emit = .no;
     var emit_llvm_ir: Emit = .no;
+    var emit_llvm_bc: Emit = .no;
     var emit_docs: Emit = .no;
     var emit_analysis: Emit = .no;
     var target_arch_os_abi: []const u8 = "native";
 @@ -1011,6 +1013,12 @@ fn buildOutputType(
                         emit_llvm_ir = .{ .yes = arg["-femit-llvm-ir=".len..] };
                     } else if (mem.eql(u8, arg, "-fno-emit-llvm-ir")) {
                         emit_llvm_ir = .no;
+                    } else if (mem.eql(u8, arg, "-femit-llvm-bc")) {
+                        emit_llvm_bc = .yes_default_path;
+                    } else if (mem.startsWith(u8, arg, "-femit-llvm-bc=")) {
+                        emit_llvm_bc = .{ .yes = arg["-femit-llvm-bc=".len..] };
+                    } else if (mem.eql(u8, arg, "-fno-emit-llvm-bc")) {
+                        emit_llvm_bc = .no;
                     } else if (mem.eql(u8, arg, "-femit-docs")) {
                         emit_docs = .yes_default_path;
                     } else if (mem.startsWith(u8, arg, "-femit-docs=")) {
 @@ -1720,8 +1728,6 @@ fn buildOutputType(
             break :blk .c;
         } else if (mem.eql(u8, ofmt, "coff")) {
             break :blk .coff;
-        } else if (mem.eql(u8, ofmt, "pe")) {
-            break :blk .pe;
         } else if (mem.eql(u8, ofmt, "macho")) {
             break :blk .macho;
         } else if (mem.eql(u8, ofmt, "wasm")) {
 @@ -1765,7 +1771,7 @@ fn buildOutputType(
     };
     const a_out_basename = switch (object_format) {
-        .pe, .coff => "a.exe",
+        .coff => "a.exe",
         else => "a.out",
     };
 @@ -1830,10 +1836,10 @@ fn buildOutputType(
     var emit_h_resolved = emit_h.resolve(default_h_basename) catch |err| {
         switch (emit_h) {
             .yes => {
-                fatal("unable to open directory from argument 'femit-h', '{s}': {s}", .{ emit_h.yes, @errorName(err) });
+                fatal("unable to open directory from argument '-femit-h', '{s}': {s}", .{ emit_h.yes, @errorName(err) });
             },
             .yes_default_path => {
-                fatal("unable to open directory from arguments 'name' or 'soname', '{s}': {s}", .{ default_h_basename, @errorName(err) });
+                fatal("unable to open directory from arguments '--name' or '-fsoname', '{s}': {s}", .{ default_h_basename, @errorName(err) });
             },
             .no => unreachable,
         }
 @@ -1844,10 +1850,10 @@ fn buildOutputType(
     var emit_asm_resolved = emit_asm.resolve(default_asm_basename) catch |err| {
         switch (emit_asm) {
             .yes => {
-                fatal("unable to open directory from argument 'femit-asm', '{s}': {s}", .{ emit_asm.yes, @errorName(err) });
+                fatal("unable to open directory from argument '-femit-asm', '{s}': {s}", .{ emit_asm.yes, @errorName(err) });
             },
             .yes_default_path => {
-                fatal("unable to open directory from arguments 'name' or 'soname', '{s}': {s}", .{ default_asm_basename, @errorName(err) });
+                fatal("unable to open directory from arguments '--name' or '-fsoname', '{s}': {s}", .{ default_asm_basename, @errorName(err) });
             },
             .no => unreachable,
         }
 @@ -1858,16 +1864,30 @@ fn buildOutputType(
     var emit_llvm_ir_resolved = emit_llvm_ir.resolve(default_llvm_ir_basename) catch |err| {
         switch (emit_llvm_ir) {
             .yes => {
-                fatal("unable to open directory from argument 'femit-llvm-ir', '{s}': {s}", .{ emit_llvm_ir.yes, @errorName(err) });
+                fatal("unable to open directory from argument '-femit-llvm-ir', '{s}': {s}", .{ emit_llvm_ir.yes, @errorName(err) });
             },
             .yes_default_path => {
-                fatal("unable to open directory from arguments 'name' or 'soname', '{s}': {s}", .{ default_llvm_ir_basename, @errorName(err) });
+                fatal("unable to open directory from arguments '--name' or '-fsoname', '{s}': {s}", .{ default_llvm_ir_basename, @errorName(err) });
             },
             .no => unreachable,
         }
     };
     defer emit_llvm_ir_resolved.deinit();
+    const default_llvm_bc_basename = try std.fmt.allocPrint(arena, "{s}.bc", .{root_name});
+    var emit_llvm_bc_resolved = emit_llvm_bc.resolve(default_llvm_bc_basename) catch |err| {
+        switch (emit_llvm_bc) {
+            .yes => {
+                fatal("unable to open directory from argument '-femit-llvm-bc', '{s}': {s}", .{ emit_llvm_bc.yes, @errorName(err) });
+            },
+            .yes_default_path => {
+                fatal("unable to open directory from arguments '--name' or '-fsoname', '{s}': {s}", .{ default_llvm_bc_basename, @errorName(err) });
+            },
+            .no => unreachable,
+        }
+    };
+    defer emit_llvm_bc_resolved.deinit();
     const default_analysis_basename = try std.fmt.allocPrint(arena, "{s}-analysis.json", .{root_name});
     var emit_analysis_resolved = emit_analysis.resolve(default_analysis_basename) catch |err| {
         switch (emit_analysis) {
 @@ -2003,6 +2023,7 @@ fn buildOutputType(
         .emit_h = emit_h_resolved.data,
         .emit_asm = emit_asm_resolved.data,
         .emit_llvm_ir = emit_llvm_ir_resolved.data,
+        .emit_llvm_bc = emit_llvm_bc_resolved.data,
         .emit_docs = emit_docs_resolved.data,
         .emit_analysis = emit_analysis_resolved.data,
         .link_mode = link_mode,
 @@ -2408,11 +2429,8 @@ fn updateModule(gpa: *Allocator, comp: *Compilation, hook: AfterUpdateHook) !voi
             // If a .pdb file is part of the expected output, we must also copy
             // it into place here.
-            const coff_or_pe = switch (comp.bin_file.options.object_format) {
+            const is_coff = comp.bin_file.options.object_format == .coff;
-                .coff, .pe => true,
+            const have_pdb = is_coff and !comp.bin_file.options.strip;
-                else => false,
-            };
-            const have_pdb = coff_or_pe and !comp.bin_file.options.strip;
             if (have_pdb) {
                 // Replace `.out` or `.exe` with `.pdb` on both the source and destination
                 const src_bin_ext = fs.path.extension(bin_sub_path);

src/stage1.zig+3-1

...	@@ -21,7 +21,6 @@ comptime {	...	@@ -21,7 +21,6 @@ comptime {
21	assert(build_options.is_stage1);	21	assert(build_options.is_stage1);
22	assert(build_options.have_llvm);	22	assert(build_options.have_llvm);
23	if (!builtin.is_test) {	23	if (!builtin.is_test) {
24	_ = @import("compiler_rt");
25	@export(main, .{ .name = "main" });	24	@export(main, .{ .name = "main" });
26	}	25	}
27	}	26	}
...	@@ -95,6 +94,8 @@ pub const Module = extern struct {	...	@@ -95,6 +94,8 @@ pub const Module = extern struct {
95	emit_asm_len: usize,	94	emit_asm_len: usize,
96	emit_llvm_ir_ptr: [*]const u8,	95	emit_llvm_ir_ptr: [*]const u8,
97	emit_llvm_ir_len: usize,	96	emit_llvm_ir_len: usize,
		97	emit_bitcode_ptr: [*]const u8,
		98	emit_bitcode_len: usize,
98	emit_analysis_json_ptr: [*]const u8,	99	emit_analysis_json_ptr: [*]const u8,
99	emit_analysis_json_len: usize,	100	emit_analysis_json_len: usize,
100	emit_docs_ptr: [*]const u8,	101	emit_docs_ptr: [*]const u8,
...	@@ -124,6 +125,7 @@ pub const Module = extern struct {	...	@@ -124,6 +125,7 @@ pub const Module = extern struct {
124	valgrind_enabled: bool,	125	valgrind_enabled: bool,
125	tsan_enabled: bool,	126	tsan_enabled: bool,
126	function_sections: bool,	127	function_sections: bool,
		128	include_compiler_rt: bool,
127	enable_stack_probing: bool,	129	enable_stack_probing: bool,
128	red_zone: bool,	130	red_zone: bool,
129	enable_time_report: bool,	131	enable_time_report: bool,

src/stage1/all_types.hpp+2

...	@@ -2090,6 +2090,7 @@ struct CodeGen {	...	@@ -2090,6 +2090,7 @@ struct CodeGen {
2090	Buf h_file_output_path;	2090	Buf h_file_output_path;
2091	Buf asm_file_output_path;	2091	Buf asm_file_output_path;
2092	Buf llvm_ir_file_output_path;	2092	Buf llvm_ir_file_output_path;
		2093	Buf bitcode_file_output_path;
2093	Buf analysis_json_output_path;	2094	Buf analysis_json_output_path;
2094	Buf docs_output_path;	2095	Buf docs_output_path;
2095		2096
...	@@ -2149,6 +2150,7 @@ struct CodeGen {	...	@@ -2149,6 +2150,7 @@ struct CodeGen {
2149	bool have_stack_probing;	2150	bool have_stack_probing;
2150	bool red_zone;	2151	bool red_zone;
2151	bool function_sections;	2152	bool function_sections;
		2153	bool include_compiler_rt;
2152	bool test_is_evented;	2154	bool test_is_evented;
2153	bool valgrind_enabled;	2155	bool valgrind_enabled;
2154	bool tsan_enabled;	2156	bool tsan_enabled;

src/stage1/codegen.cpp+27-6

 @@ -8506,19 +8506,22 @@ static void zig_llvm_emit_output(CodeGen *g) {
     const char *asm_filename = nullptr;
     const char *bin_filename = nullptr;
     const char *llvm_ir_filename = nullptr;
+    const char *bitcode_filename = nullptr;
     if (buf_len(&g->o_file_output_path) != 0) bin_filename = buf_ptr(&g->o_file_output_path);
     if (buf_len(&g->asm_file_output_path) != 0) asm_filename = buf_ptr(&g->asm_file_output_path);
     if (buf_len(&g->llvm_ir_file_output_path) != 0) llvm_ir_filename = buf_ptr(&g->llvm_ir_file_output_path);
+    if (buf_len(&g->bitcode_file_output_path) != 0) bitcode_filename = buf_ptr(&g->bitcode_file_output_path);
-    // Unfortunately, LLVM shits the bed when we ask for both binary and assembly. So we call the entire
+    // Unfortunately, LLVM shits the bed when we ask for both binary and assembly.
-    // pipeline multiple times if this is requested.
+    // So we call the entire pipeline multiple times if this is requested.
     if (asm_filename != nullptr && bin_filename != nullptr) {
         if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, &err_msg,
             g->build_mode == BuildModeDebug, is_small, g->enable_time_report, g->tsan_enabled,
-            g->have_lto, nullptr, bin_filename, llvm_ir_filename))
+            g->have_lto, nullptr, bin_filename, llvm_ir_filename, nullptr))
         {
-            fprintf(stderr, "LLVM failed to emit file: %s\n", err_msg);
+            fprintf(stderr, "LLVM failed to emit bin=%s, ir=%s: %s\n",
+                    bin_filename, llvm_ir_filename, err_msg);
             exit(1);
         }
         bin_filename = nullptr;
 @@ -8527,9 +8530,11 @@ static void zig_llvm_emit_output(CodeGen *g) {
     if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, &err_msg,
         g->build_mode == BuildModeDebug, is_small, g->enable_time_report, g->tsan_enabled,
-        g->have_lto, asm_filename, bin_filename, llvm_ir_filename))
+        g->have_lto, asm_filename, bin_filename, llvm_ir_filename, bitcode_filename))
     {
-        fprintf(stderr, "LLVM failed to emit file: %s\n", err_msg);
+        fprintf(stderr, "LLVM failed to emit asm=%s, bin=%s, ir=%s, bc=%s: %s\n",
+                asm_filename, bin_filename, llvm_ir_filename, bitcode_filename,
+                err_msg);
         exit(1);
     }
 @@ -9537,6 +9542,22 @@ static void gen_root_source(CodeGen *g) {
     g->panic_fn = panic_fn_val->data.x_ptr.data.fn.fn_entry;
     assert(g->panic_fn != nullptr);
+    if (g->include_compiler_rt) {
+        Buf *import_target_path;
+        Buf full_path = BUF_INIT;
+        ZigType *compiler_rt_import;
+        if ((err = analyze_import(g, std_import, buf_create_from_str("./special/compiler_rt.zig"),
+            &compiler_rt_import, &import_target_path, &full_path)))
+        {
+            if (err == ErrorFileNotFound) {
+                fprintf(stderr, "unable to find '%s'", buf_ptr(import_target_path));
+            } else {
+                fprintf(stderr, "unable to open '%s': %s\n", buf_ptr(&full_path), err_str(err));
+            }
+            exit(1);
+        }
+    }
     if (!g->error_during_imports) {
         semantic_analyze(g);
     }

src/stage1/stage1.cpp+2

...	@@ -73,6 +73,7 @@ void zig_stage1_build_object(struct ZigStage1 *stage1) {	...	@@ -73,6 +73,7 @@ void zig_stage1_build_object(struct ZigStage1 *stage1) {
73	buf_init_from_mem(&g->h_file_output_path, stage1->emit_h_ptr, stage1->emit_h_len);	73	buf_init_from_mem(&g->h_file_output_path, stage1->emit_h_ptr, stage1->emit_h_len);
74	buf_init_from_mem(&g->asm_file_output_path, stage1->emit_asm_ptr, stage1->emit_asm_len);	74	buf_init_from_mem(&g->asm_file_output_path, stage1->emit_asm_ptr, stage1->emit_asm_len);
75	buf_init_from_mem(&g->llvm_ir_file_output_path, stage1->emit_llvm_ir_ptr, stage1->emit_llvm_ir_len);	75	buf_init_from_mem(&g->llvm_ir_file_output_path, stage1->emit_llvm_ir_ptr, stage1->emit_llvm_ir_len);
		76	buf_init_from_mem(&g->bitcode_file_output_path, stage1->emit_bitcode_ptr, stage1->emit_bitcode_len);
76	buf_init_from_mem(&g->analysis_json_output_path, stage1->emit_analysis_json_ptr, stage1->emit_analysis_json_len);	77	buf_init_from_mem(&g->analysis_json_output_path, stage1->emit_analysis_json_ptr, stage1->emit_analysis_json_len);
77	buf_init_from_mem(&g->docs_output_path, stage1->emit_docs_ptr, stage1->emit_docs_len);	78	buf_init_from_mem(&g->docs_output_path, stage1->emit_docs_ptr, stage1->emit_docs_len);
78		79
...	@@ -100,6 +101,7 @@ void zig_stage1_build_object(struct ZigStage1 *stage1) {	...	@@ -100,6 +101,7 @@ void zig_stage1_build_object(struct ZigStage1 *stage1) {
100	g->link_libc = stage1->link_libc;	101	g->link_libc = stage1->link_libc;
101	g->link_libcpp = stage1->link_libcpp;	102	g->link_libcpp = stage1->link_libcpp;
102	g->function_sections = stage1->function_sections;	103	g->function_sections = stage1->function_sections;
		104	g->include_compiler_rt = stage1->include_compiler_rt;
103		105
104	g->subsystem = stage1->subsystem;	106	g->subsystem = stage1->subsystem;
105		107

src/stage1/stage1.h+4

...	@@ -157,6 +157,9 @@ struct ZigStage1 {	...	@@ -157,6 +157,9 @@ struct ZigStage1 {
157	const char *emit_llvm_ir_ptr;	157	const char *emit_llvm_ir_ptr;
158	size_t emit_llvm_ir_len;	158	size_t emit_llvm_ir_len;
159		159
		160	const char *emit_bitcode_ptr;
		161	size_t emit_bitcode_len;
		162
160	const char *emit_analysis_json_ptr;	163	const char *emit_analysis_json_ptr;
161	size_t emit_analysis_json_len;	164	size_t emit_analysis_json_len;
162		165
...	@@ -193,6 +196,7 @@ struct ZigStage1 {	...	@@ -193,6 +196,7 @@ struct ZigStage1 {
193	bool valgrind_enabled;	196	bool valgrind_enabled;
194	bool tsan_enabled;	197	bool tsan_enabled;
195	bool function_sections;	198	bool function_sections;
		199	bool include_compiler_rt;
196	bool enable_stack_probing;	200	bool enable_stack_probing;
197	bool red_zone;	201	bool red_zone;
198	bool enable_time_report;	202	bool enable_time_report;

src/stage1/zig0.cpp+5

src/translate_c.zig+257-15

...	@@ -2,6 +2,7 @@	...	@@ -2,6 +2,7 @@
2	//! and stage2.	2	//! and stage2.
3		3
4	const std = @import("std");	4	const std = @import("std");
		5	const testing = std.testing;
5	const assert = std.debug.assert;	6	const assert = std.debug.assert;
6	const clang = @import("clang.zig");	7	const clang = @import("clang.zig");
7	const ctok = std.c.tokenizer;	8	const ctok = std.c.tokenizer;
...	@@ -18,6 +19,7 @@ const CallingConvention = std.builtin.CallingConvention;	...	@@ -18,6 +19,7 @@ const CallingConvention = std.builtin.CallingConvention;
18	pub const ClangErrMsg = clang.Stage2ErrorMsg;	19	pub const ClangErrMsg = clang.Stage2ErrorMsg;
19		20
20	pub const Error = std.mem.Allocator.Error;	21	pub const Error = std.mem.Allocator.Error;
		22	const MacroProcessingError = Error \|\| error{UnexpectedMacroToken};
21	const TypeError = Error \|\| error{UnsupportedType};	23	const TypeError = Error \|\| error{UnsupportedType};
22	const TransError = TypeError \|\| error{UnsupportedTranslation};	24	const TransError = TypeError \|\| error{UnsupportedTranslation};
23		25
...	@@ -27,6 +29,10 @@ const AliasList = std.ArrayList(struct {	...	@@ -27,6 +29,10 @@ const AliasList = std.ArrayList(struct {
27	name: []const u8,	29	name: []const u8,
28	});	30	});
29		31
		32	// Maps macro parameter names to token position, for determining if different
		33	// identifiers refer to the same positional argument in different macros.
		34	const ArgsPositionMap = std.StringArrayHashMapUnmanaged(usize);
		35
30	const Scope = struct {	36	const Scope = struct {
31	id: Id,	37	id: Id,
32	parent: ?*Scope,	38	parent: ?*Scope,
...	@@ -322,6 +328,8 @@ pub const Context = struct {	...	@@ -322,6 +328,8 @@ pub const Context = struct {
322	/// up front in a pre-processing step.	328	/// up front in a pre-processing step.
323	global_names: std.StringArrayHashMapUnmanaged(void) = .{},	329	global_names: std.StringArrayHashMapUnmanaged(void) = .{},
324		330
		331	pattern_list: PatternList,
		332
325	fn getMangle(c: *Context) u32 {	333	fn getMangle(c: *Context) u32 {
326	c.mangle_count += 1;	334	c.mangle_count += 1;
327	return c.mangle_count;	335	return c.mangle_count;
...	@@ -375,6 +383,7 @@ pub fn translate(	...	@@ -375,6 +383,7 @@ pub fn translate(
375	.alias_list = AliasList.init(gpa),	383	.alias_list = AliasList.init(gpa),
376	.global_scope = try arena.allocator.create(Scope.Root),	384	.global_scope = try arena.allocator.create(Scope.Root),
377	.clang_context = ast_unit.getASTContext(),	385	.clang_context = ast_unit.getASTContext(),
		386	.pattern_list = try PatternList.init(gpa),
378	};	387	};
379	context.global_scope.* = Scope.Root.init(&context);	388	context.global_scope.* = Scope.Root.init(&context);
380	defer {	389	defer {
...	@@ -385,6 +394,7 @@ pub fn translate(	...	@@ -385,6 +394,7 @@ pub fn translate(
385	context.unnamed_typedefs.deinit(gpa);	394	context.unnamed_typedefs.deinit(gpa);
386	context.typedefs.deinit(gpa);	395	context.typedefs.deinit(gpa);
387	context.global_scope.deinit();	396	context.global_scope.deinit();
		397	context.pattern_list.deinit(gpa);
388	}	398	}
389		399
390	try context.global_scope.nodes.append(Tag.usingnamespace_builtins.init());	400	try context.global_scope.nodes.append(Tag.usingnamespace_builtins.init());
...	@@ -4829,6 +4839,220 @@ fn isZigPrimitiveType(name: []const u8) bool {	...	@@ -4829,6 +4839,220 @@ fn isZigPrimitiveType(name: []const u8) bool {
4829	return @import("AstGen.zig").simple_types.has(name);	4839	return @import("AstGen.zig").simple_types.has(name);
4830	}	4840	}
4831		4841
		4842	const PatternList = struct {
		4843	patterns: []Pattern,
		4844
		4845	/// Templates must be function-like macros
		4846	/// first element is macro source, second element is the name of the function
		4847	/// in std.lib.zig.c_translation.Macros which implements it
		4848	const templates = [_][2][]const u8{
		4849	[2][]const u8{ "f_SUFFIX(X) (X ## f)", "F_SUFFIX" },
		4850	[2][]const u8{ "F_SUFFIX(X) (X ## F)", "F_SUFFIX" },
		4851
		4852	[2][]const u8{ "u_SUFFIX(X) (X ## u)", "U_SUFFIX" },
		4853	[2][]const u8{ "U_SUFFIX(X) (X ## U)", "U_SUFFIX" },
		4854
		4855	[2][]const u8{ "l_SUFFIX(X) (X ## l)", "L_SUFFIX" },
		4856	[2][]const u8{ "L_SUFFIX(X) (X ## L)", "L_SUFFIX" },
		4857
		4858	[2][]const u8{ "ul_SUFFIX(X) (X ## ul)", "UL_SUFFIX" },
		4859	[2][]const u8{ "uL_SUFFIX(X) (X ## uL)", "UL_SUFFIX" },
		4860	[2][]const u8{ "Ul_SUFFIX(X) (X ## Ul)", "UL_SUFFIX" },
		4861	[2][]const u8{ "UL_SUFFIX(X) (X ## UL)", "UL_SUFFIX" },
		4862
		4863	[2][]const u8{ "ll_SUFFIX(X) (X ## ll)", "LL_SUFFIX" },
		4864	[2][]const u8{ "LL_SUFFIX(X) (X ## LL)", "LL_SUFFIX" },
		4865
		4866	[2][]const u8{ "ull_SUFFIX(X) (X ## ull)", "ULL_SUFFIX" },
		4867	[2][]const u8{ "uLL_SUFFIX(X) (X ## uLL)", "ULL_SUFFIX" },
		4868	[2][]const u8{ "Ull_SUFFIX(X) (X ## Ull)", "ULL_SUFFIX" },
		4869	[2][]const u8{ "ULL_SUFFIX(X) (X ## ULL)", "ULL_SUFFIX" },
		4870
		4871	[2][]const u8{ "CAST_OR_CALL(X, Y) (X)(Y)", "CAST_OR_CALL" },
		4872
		4873	[2][]const u8{
		4874	\\wl_container_of(ptr, sample, member) \
		4875	\\(__typeof__(sample))((char *)(ptr) - \
		4876	\\ offsetof(__typeof__(*sample), member))
		4877	,
		4878	"WL_CONTAINER_OF",
		4879	},
		4880	};
		4881
		4882	/// Assumes that `ms` represents a tokenized function-like macro.
		4883	fn buildArgsHash(allocator: mem.Allocator, ms: MacroSlicer, hash: ArgsPositionMap) MacroProcessingError!void {
		4884	assert(ms.tokens.len > 2);
		4885	assert(ms.tokens[0].id == .Identifier);
		4886	assert(ms.tokens[1].id == .LParen);
		4887
		4888	var i: usize = 2;
		4889	while (true) : (i += 1) {
		4890	const token = ms.tokens[i];
		4891	switch (token.id) {
		4892	.RParen => break,
		4893	.Comma => continue,
		4894	.Identifier => {
		4895	const identifier = ms.slice(token);
		4896	try hash.put(allocator, identifier, i);
		4897	},
		4898	else => return error.UnexpectedMacroToken,
		4899	}
		4900	}
		4901	}
		4902
		4903	const Pattern = struct {
		4904	tokens: []const CToken,
		4905	source: []const u8,
		4906	impl: []const u8,
		4907	args_hash: ArgsPositionMap,
		4908
		4909	fn init(self: Pattern, allocator: mem.Allocator, template: [2][]const u8) Error!void {
		4910	const source = template[0];
		4911	const impl = template[1];
		4912
		4913	var tok_list = std.ArrayList(CToken).init(allocator);
		4914	defer tok_list.deinit();
		4915	try tokenizeMacro(source, &tok_list);
		4916	const tokens = try allocator.dupe(CToken, tok_list.items);
		4917
		4918	self.* = .{
		4919	.tokens = tokens,
		4920	.source = source,
		4921	.impl = impl,
		4922	.args_hash = .{},
		4923	};
		4924	const ms = MacroSlicer{ .source = source, .tokens = tokens };
		4925	buildArgsHash(allocator, ms, &self.args_hash) catch \|err\| switch (err) {
		4926	error.UnexpectedMacroToken => unreachable,
		4927	else => \|e\| return e,
		4928	};
		4929	}
		4930
		4931	fn deinit(self: Pattern, allocator: mem.Allocator) void {
		4932	self.args_hash.deinit(allocator);
		4933	allocator.free(self.tokens);
		4934	}
		4935
		4936	/// This function assumes that `ms` has already been validated to contain a function-like
		4937	/// macro, and that the parsed template macro in `self` also contains a function-like
		4938	/// macro. Please review this logic carefully if changing that assumption. Two
		4939	/// function-like macros are considered equivalent if and only if they contain the same
		4940	/// list of tokens, modulo parameter names.
		4941	fn isEquivalent(self: Pattern, ms: MacroSlicer, args_hash: ArgsPositionMap) bool {
		4942	if (self.tokens.len != ms.tokens.len) return false;
		4943	if (args_hash.count() != self.args_hash.count()) return false;
		4944
		4945	var i: usize = 2;
		4946	while (self.tokens[i].id != .RParen) : (i += 1) {}
		4947
		4948	const pattern_slicer = MacroSlicer{ .source = self.source, .tokens = self.tokens };
		4949	while (i < self.tokens.len) : (i += 1) {
		4950	const pattern_token = self.tokens[i];
		4951	const macro_token = ms.tokens[i];
		4952	if (meta.activeTag(pattern_token.id) != meta.activeTag(macro_token.id)) return false;
		4953
		4954	const pattern_bytes = pattern_slicer.slice(pattern_token);
		4955	const macro_bytes = ms.slice(macro_token);
		4956	switch (pattern_token.id) {
		4957	.Identifier => {
		4958	const pattern_arg_index = self.args_hash.get(pattern_bytes);
		4959	const macro_arg_index = args_hash.get(macro_bytes);
		4960
		4961	if (pattern_arg_index == null and macro_arg_index == null) {
		4962	if (!mem.eql(u8, pattern_bytes, macro_bytes)) return false;
		4963	} else if (pattern_arg_index != null and macro_arg_index != null) {
		4964	if (pattern_arg_index.? != macro_arg_index.?) return false;
		4965	} else {
		4966	return false;
		4967	}
		4968	},
		4969	.MacroString, .StringLiteral, .CharLiteral, .IntegerLiteral, .FloatLiteral => {
		4970	if (!mem.eql(u8, pattern_bytes, macro_bytes)) return false;
		4971	},
		4972	else => {
		4973	// other tags correspond to keywords and operators that do not contain a "payload"
		4974	// that can vary
		4975	},
		4976	}
		4977	}
		4978	return true;
		4979	}
		4980	};
		4981
		4982	fn init(allocator: *mem.Allocator) Error!PatternList {
		4983	const patterns = try allocator.alloc(Pattern, templates.len);
		4984	for (templates) \|template, i\| {
		4985	try patterns[i].init(allocator, template);
		4986	}
		4987	return PatternList{ .patterns = patterns };
		4988	}
		4989
		4990	fn deinit(self: PatternList, allocator: mem.Allocator) void {
		4991	for (self.patterns) \|*pattern\| pattern.deinit(allocator);
		4992	allocator.free(self.patterns);
		4993	}
		4994
		4995	fn match(self: PatternList, allocator: *mem.Allocator, ms: MacroSlicer) Error!?Pattern {
		4996	var args_hash: ArgsPositionMap = .{};
		4997	defer args_hash.deinit(allocator);
		4998
		4999	buildArgsHash(allocator, ms, &args_hash) catch \|err\| switch (err) {
		5000	error.UnexpectedMacroToken => return null,
		5001	else => \|e\| return e,
		5002	};
		5003
		5004	for (self.patterns) \|pattern\| if (pattern.isEquivalent(ms, args_hash)) return pattern;
		5005	return null;
		5006	}
		5007	};
		5008
		5009	const MacroSlicer = struct {
		5010	source: []const u8,
		5011	tokens: []const CToken,
		5012	fn slice(self: MacroSlicer, token: CToken) []const u8 {
		5013	return self.source[token.start..token.end];
		5014	}
		5015	};
		5016
		5017	// Testing here instead of test/translate_c.zig allows us to also test that the
		5018	// mapped function exists in `std.zig.c_translation.Macros`
		5019	test "Macro matching" {
		5020	const helper = struct {
		5021	const MacroFunctions = @import("std").zig.c_translation.Macros;
		5022	fn checkMacro(allocator: *mem.Allocator, pattern_list: PatternList, source: []const u8, comptime expected_match: ?[]const u8) !void {
		5023	var tok_list = std.ArrayList(CToken).init(allocator);
		5024	defer tok_list.deinit();
		5025	try tokenizeMacro(source, &tok_list);
		5026	const macro_slicer = MacroSlicer{ .source = source, .tokens = tok_list.items };
		5027	const matched = try pattern_list.match(allocator, macro_slicer);
		5028	if (expected_match) \|expected\| {
		5029	try testing.expectEqualStrings(expected, matched.?.impl);
		5030	try testing.expect(@hasDecl(MacroFunctions, expected));
		5031	} else {
		5032	try testing.expectEqual(@as(@TypeOf(matched), null), matched);
		5033	}
		5034	}
		5035	};
		5036	const allocator = std.testing.allocator;
		5037	var pattern_list = try PatternList.init(allocator);
		5038	defer pattern_list.deinit(allocator);
		5039
		5040	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## F)", "F_SUFFIX");
		5041	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## U)", "U_SUFFIX");
		5042	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## L)", "L_SUFFIX");
		5043	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## LL)", "LL_SUFFIX");
		5044	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## UL)", "UL_SUFFIX");
		5045	try helper.checkMacro(allocator, pattern_list, "BAR(Z) (Z ## ULL)", "ULL_SUFFIX");
		5046	try helper.checkMacro(allocator, pattern_list,
		5047	\\container_of(a, b, c) \
		5048	\\(__typeof__(b))((char *)(a) - \
		5049	\\ offsetof(__typeof__(*b), c))
		5050	, "WL_CONTAINER_OF");
		5051
		5052	try helper.checkMacro(allocator, pattern_list, "NO_MATCH(X, Y) (X + Y)", null);
		5053	try helper.checkMacro(allocator, pattern_list, "CAST_OR_CALL(X, Y) (X)(Y)", "CAST_OR_CALL");
		5054	}
		5055
4832	const MacroCtx = struct {	5056	const MacroCtx = struct {
4833	source: []const u8,	5057	source: []const u8,
4834	list: []const CToken,	5058	list: []const CToken,
...	@@ -4855,8 +5079,30 @@ const MacroCtx = struct {	...	@@ -4855,8 +5079,30 @@ const MacroCtx = struct {
4855	fn fail(self: MacroCtx, c: Context, comptime fmt: []const u8, args: anytype) !void {	5079	fn fail(self: MacroCtx, c: Context, comptime fmt: []const u8, args: anytype) !void {
4856	return failDecl(c, self.loc, self.name, fmt, args);	5080	return failDecl(c, self.loc, self.name, fmt, args);
4857	}	5081	}
		5082
		5083	fn makeSlicer(self: *const MacroCtx) MacroSlicer {
		5084	return MacroSlicer{ .source = self.source, .tokens = self.list };
		5085	}
4858	};	5086	};
4859		5087
		5088	fn tokenizeMacro(source: []const u8, tok_list: *std.ArrayList(CToken)) Error!void {
		5089	var tokenizer = std.c.Tokenizer{
		5090	.buffer = source,
		5091	};
		5092	while (true) {
		5093	const tok = tokenizer.next();
		5094	switch (tok.id) {
		5095	.Nl, .Eof => {
		5096	try tok_list.append(tok);
		5097	break;
		5098	},
		5099	.LineComment, .MultiLineComment => continue,
		5100	else => {},
		5101	}
		5102	try tok_list.append(tok);
		5103	}
		5104	}
		5105
4860	fn transPreprocessorEntities(c: Context, unit: clang.ASTUnit) Error!void {	5106	fn transPreprocessorEntities(c: Context, unit: clang.ASTUnit) Error!void {
4861	// TODO if we see #undef, delete it from the table	5107	// TODO if we see #undef, delete it from the table
4862	var it = unit.getLocalPreprocessingEntities_begin();	5108	var it = unit.getLocalPreprocessingEntities_begin();
...	@@ -4888,21 +5134,7 @@ fn transPreprocessorEntities(c: Context, unit: clang.ASTUnit) Error!void {	...	@@ -4888,21 +5134,7 @@ fn transPreprocessorEntities(c: Context, unit: clang.ASTUnit) Error!void {
4888	const slice_len = @ptrToInt(end_c) - @ptrToInt(begin_c);	5134	const slice_len = @ptrToInt(end_c) - @ptrToInt(begin_c);
4889	const slice = begin_c[0..slice_len];	5135	const slice = begin_c[0..slice_len];
4890		5136
4891	var tokenizer = std.c.Tokenizer{	5137	try tokenizeMacro(slice, &tok_list);
4892	.buffer = slice,
4893	};
4894	while (true) {
4895	const tok = tokenizer.next();
4896	switch (tok.id) {
4897	.Nl, .Eof => {
4898	try tok_list.append(tok);
4899	break;
4900	},
4901	.LineComment, .MultiLineComment => continue,
4902	else => {},
4903	}
4904	try tok_list.append(tok);
4905	}
4906		5138
4907	var macro_ctx = MacroCtx{	5139	var macro_ctx = MacroCtx{
4908	.source = slice,	5140	.source = slice,
...	@@ -4960,6 +5192,16 @@ fn transMacroDefine(c: Context, m: MacroCtx) ParseError!void {	...	@@ -4960,6 +5192,16 @@ fn transMacroDefine(c: Context, m: MacroCtx) ParseError!void {
4960	}	5192	}
4961		5193
4962	fn transMacroFnDefine(c: Context, m: MacroCtx) ParseError!void {	5194	fn transMacroFnDefine(c: Context, m: MacroCtx) ParseError!void {
		5195	const macro_slicer = m.makeSlicer();
		5196	if (try c.pattern_list.match(c.gpa, macro_slicer)) \|pattern\| {
		5197	const decl = try Tag.pub_var_simple.create(c.arena, .{
		5198	.name = m.name,
		5199	.init = try Tag.helpers_macro.create(c.arena, pattern.impl),
		5200	});
		5201	try c.global_scope.macro_table.put(m.name, decl);
		5202	return;
		5203	}
		5204
4963	var block_scope = try Scope.Block.init(c, &c.global_scope.base, false);	5205	var block_scope = try Scope.Block.init(c, &c.global_scope.base, false);
4964	defer block_scope.deinit();	5206	defer block_scope.deinit();
4965	const scope = &block_scope.base;	5207	const scope = &block_scope.base;

src/translate_c/ast.zig+14

 @@ -193,6 +193,8 @@ pub const Node = extern union {
         helpers_flexible_array_type,
         /// @import("std").zig.c_translation.shuffleVectorIndex(lhs, rhs)
         helpers_shuffle_vector_index,
+        /// @import("std").zig.c_translation.Macro.<operand>
+        helpers_macro,
         /// @import("std").meta.Vector(lhs, rhs)
         std_meta_vector,
         /// @import("std").mem.zeroes(operand)
 @@ -339,6 +341,7 @@ pub const Node = extern union {
                 .identifier,
                 .warning,
                 .type,
+                .helpers_macro,
                 => Payload.Value,
                 .discard => Payload.Discard,
                 .@"if" => Payload.If,
 @@ -1112,6 +1115,16 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
                 .data = undefined,
             });
         },
+        .helpers_macro => {
+            const payload = node.castTag(.helpers_macro).?.data;
+            const chain = [_][]const u8{
+                "zig",
+                "c_translation",
+                "Macros",
+                payload,
+            };
+            return renderStdImport(c, &chain);
+        },
         .string_slice => {
             const payload = node.castTag(.string_slice).?.data;
 @@ -2310,6 +2323,7 @@ fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex {
         .bit_or_assign,
         .bit_xor_assign,
         .assign,
+        .helpers_macro,
         => {
             // these should never appear in places where grouping might be needed.
             unreachable;

src/zig_llvm.cpp+17-2

 @@ -229,12 +229,14 @@ struct TimeTracerRAII {
 bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
         char **error_message, bool is_debug,
         bool is_small, bool time_report, bool tsan, bool lto,
-        const char *asm_filename, const char *bin_filename, const char *llvm_ir_filename)
+        const char *asm_filename, const char *bin_filename,
+        const char *llvm_ir_filename, const char *bitcode_filename)
 {
     TimePassesIsEnabled = time_report;
     raw_fd_ostream *dest_asm_ptr = nullptr;
     raw_fd_ostream *dest_bin_ptr = nullptr;
+    raw_fd_ostream *dest_bitcode_ptr = nullptr;
     if (asm_filename) {
         std::error_code EC;
 @@ -252,9 +254,19 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
             return true;
         }
     }
+    if (bitcode_filename) {
+        std::error_code EC;
+        dest_bitcode_ptr = new(std::nothrow) raw_fd_ostream(bitcode_filename, EC, sys::fs::F_None);
+        if (EC) {
+            *error_message = strdup((const char *)StringRef(EC.message()).bytes_begin());
+            return true;
+        }
+    }
     std::unique_ptr<raw_fd_ostream> dest_asm(dest_asm_ptr),
-                                    dest_bin(dest_bin_ptr);
+                                    dest_bin(dest_bin_ptr),
+                                    dest_bitcode(dest_bitcode_ptr);
     auto PID = sys::Process::getProcessId();
     std::string ProcName = "zig-";
 @@ -389,6 +401,9 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
     if (dest_bin && lto) {
         WriteBitcodeToFile(module, *dest_bin);
     }
+    if (dest_bitcode) {
+        WriteBitcodeToFile(module, *dest_bitcode);
+    }
     if (time_report) {
         TimerGroup::printAll(errs());

src/zig_llvm.h+2-1

...	@@ -49,7 +49,8 @@ ZIG_EXTERN_C char *ZigLLVMGetNativeFeatures(void);	...	@@ -49,7 +49,8 @@ ZIG_EXTERN_C char *ZigLLVMGetNativeFeatures(void);
49	ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,	49	ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
50	char **error_message, bool is_debug,	50	char **error_message, bool is_debug,
51	bool is_small, bool time_report, bool tsan, bool lto,	51	bool is_small, bool time_report, bool tsan, bool lto,
52	const char asm_filename, const char bin_filename, const char *llvm_ir_filename);	52	const char asm_filename, const char bin_filename,
		53	const char llvm_ir_filename, const char bitcode_filename);
53		54
54		55
55	enum ZigLLVMABIType {	56	enum ZigLLVMABIType {

test/cases.zig+70

...	@@ -1065,6 +1065,76 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -1065,6 +1065,76 @@ pub fn addCases(ctx: *TestContext) !void {
1065	":5:19: error: redeclaration of local constant 'c'",	1065	":5:19: error: redeclaration of local constant 'c'",
1066	":4:19: note: previous declaration here",	1066	":4:19: note: previous declaration here",
1067	});	1067	});
		1068	case.addError(
		1069	\\pub fn main() void {
		1070	\\ var i = 0;
		1071	\\ for (n) \|_, i\| {
		1072	\\ }
		1073	\\}
		1074	, &[_][]const u8{
		1075	":3:17: error: redeclaration of local variable 'i'",
		1076	":2:9: note: previous declaration here",
		1077	});
		1078	case.addError(
		1079	\\pub fn main() void {
		1080	\\ var i = 0;
		1081	\\ for (n) \|i\| {
		1082	\\ }
		1083	\\}
		1084	, &[_][]const u8{
		1085	":3:14: error: redeclaration of local variable 'i'",
		1086	":2:9: note: previous declaration here",
		1087	});
		1088	case.addError(
		1089	\\pub fn main() void {
		1090	\\ var i = 0;
		1091	\\ while (n) \|i\| {
		1092	\\ }
		1093	\\}
		1094	, &[_][]const u8{
		1095	":3:16: error: redeclaration of local variable 'i'",
		1096	":2:9: note: previous declaration here",
		1097	});
		1098	case.addError(
		1099	\\pub fn main() void {
		1100	\\ var i = 0;
		1101	\\ while (n) \|bruh\| {
		1102	\\ _ = bruh;
		1103	\\ } else \|i\| {
		1104	\\
		1105	\\ }
		1106	\\}
		1107	, &[_][]const u8{
		1108	":5:13: error: redeclaration of local variable 'i'",
		1109	":2:9: note: previous declaration here",
		1110	});
		1111	case.addError(
		1112	\\pub fn main() void {
		1113	\\ var i = 0;
		1114	\\ if (true) \|i\| {}
		1115	\\}
		1116	, &[_][]const u8{
		1117	":3:16: error: redeclaration of local variable 'i'",
		1118	":2:9: note: previous declaration here",
		1119	});
		1120	case.addError(
		1121	\\pub fn main() void {
		1122	\\ var i = 0;
		1123	\\ if (true) \|i\| {} else \|e\| {}
		1124	\\}
		1125	, &[_][]const u8{
		1126	":3:16: error: redeclaration of local variable 'i'",
		1127	":2:9: note: previous declaration here",
		1128	});
		1129	case.addError(
		1130	\\pub fn main() void {
		1131	\\ var i = 0;
		1132	\\ if (true) \|_\| {} else \|i\| {}
		1133	\\}
		1134	, &[_][]const u8{
		1135	":3:28: error: redeclaration of local variable 'i'",
		1136	":2:9: note: previous declaration here",
		1137	});
1068	}	1138	}
1069		1139
1070	{	1140	{

test/translate_c.zig+6

...	@@ -3624,4 +3624,10 @@ pub fn addCases(cases: *tests.TranslateCContext) void {	...	@@ -3624,4 +3624,10 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
3624	,	3624	,
3625	\\pub export var @"_": c_int = 42;	3625	\\pub export var @"_": c_int = 42;
3626	});	3626	});
		3627
		3628	cases.add("Macro matching",
		3629	\\#define FOO(X) (X ## U)
		3630	, &[_][]const u8{
		3631	\\pub const FOO = @import("std").zig.c_translation.Macros.U_SUFFIX;
		3632	});
3627	}	3633	}

author	Jakub Konka <kubkon@jakubkonka.com> 2021-07-23 17:06:19+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2021-07-23 17:06:19+02:00
log	5533f77054acad376f2fce0d529569a7449e9949
tree	eba6945383fefa59a8858f7eec8beee3cfca7731
parent	1beda818e1c10bde98b35759b3c131a864be58d9
parent	e5b476209a1215a03164890d331e2013f20882a6

...	@@ -17,9 +17,9 @@ const link = @import("../link.zig");	...	@@ -17,9 +17,9 @@ const link = @import("../link.zig");
17	const build_options = @import("build_options");	17	const build_options = @import("build_options");
18	const Cache = @import("../Cache.zig");	18	const Cache = @import("../Cache.zig");
19	const mingw = @import("../mingw.zig");	19	const mingw = @import("../mingw.zig");
20	const llvm_backend = @import("../codegen/llvm.zig");
21	const Air = @import("../Air.zig");	20	const Air = @import("../Air.zig");
22	const Liveness = @import("../Liveness.zig");	21	const Liveness = @import("../Liveness.zig");
		22	const LlvmObject = @import("../codegen/llvm.zig").Object;
23		23
24	const allocation_padding = 4 / 3;	24	const allocation_padding = 4 / 3;
25	const minimum_text_block_size = 64 * allocation_padding;	25	const minimum_text_block_size = 64 * allocation_padding;
...	@@ -37,7 +37,7 @@ pub const base_tag: link.File.Tag = .coff;	...	@@ -37,7 +37,7 @@ pub const base_tag: link.File.Tag = .coff;
37	const msdos_stub = @embedFile("msdos-stub.bin");	37	const msdos_stub = @embedFile("msdos-stub.bin");
38		38
39	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.	39	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
40	llvm_object: ?*llvm_backend.Object = null,	40	llvm_object: ?*LlvmObject = null,
41		41
42	base: link.File,	42	base: link.File,
43	ptr_width: PtrWidth,	43	ptr_width: PtrWidth,
...	@@ -132,7 +132,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio	...	@@ -132,7 +132,7 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
132	const self = try createEmpty(allocator, options);	132	const self = try createEmpty(allocator, options);
133	errdefer self.base.destroy();	133	errdefer self.base.destroy();
134		134
135	self.llvm_object = try llvm_backend.Object.create(allocator, sub_path, options);	135	self.llvm_object = try LlvmObject.create(allocator, options);
136	return self;	136	return self;
137	}	137	}
138		138
...	@@ -657,10 +657,7 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {	...	@@ -657,10 +657,7 @@ fn writeOffsetTableEntry(self: *Coff, index: usize) !void {
657	}	657	}
658		658
659	pub fn updateFunc(self: Coff, module: Module, func: *Module.Fn, air: Air, liveness: Liveness) !void {	659	pub fn updateFunc(self: Coff, module: Module, func: *Module.Fn, air: Air, liveness: Liveness) !void {
660	if (build_options.skip_non_native and	660	if (build_options.skip_non_native and builtin.object_format != .coff) {
661	builtin.object_format != .coff and
662	builtin.object_format != .pe)
663	{
664	@panic("Attempted to compile for object format that was disabled by build configuration");	661	@panic("Attempted to compile for object format that was disabled by build configuration");
665	}	662	}
666	if (build_options.have_llvm) {	663	if (build_options.have_llvm) {
...	@@ -697,7 +694,7 @@ pub fn updateFunc(self: Coff, module: Module, func: *Module.Fn, air: Air, live	...	@@ -697,7 +694,7 @@ pub fn updateFunc(self: Coff, module: Module, func: *Module.Fn, air: Air, live
697	}	694	}
698		695
699	pub fn updateDecl(self: Coff, module: Module, decl: *Module.Decl) !void {	696	pub fn updateDecl(self: Coff, module: Module, decl: *Module.Decl) !void {
700	if (build_options.skip_non_native and builtin.object_format != .coff and builtin.object_format != .pe) {	697	if (build_options.skip_non_native and builtin.object_format != .coff) {
701	@panic("Attempted to compile for object format that was disabled by build configuration");	698	@panic("Attempted to compile for object format that was disabled by build configuration");
702	}	699	}
703	if (build_options.have_llvm) {	700	if (build_options.have_llvm) {
...	@@ -823,8 +820,11 @@ pub fn flushModule(self: Coff, comp: Compilation) !void {	...	@@ -823,8 +820,11 @@ pub fn flushModule(self: Coff, comp: Compilation) !void {
823	const tracy = trace(@src());	820	const tracy = trace(@src());
824	defer tracy.end();	821	defer tracy.end();
825		822
826	if (build_options.have_llvm)	823	if (build_options.have_llvm) {
827	if (self.llvm_object) \|llvm_object\| return try llvm_object.flushModule(comp);	824	if (self.llvm_object) \|llvm_object\| {
		825	return try llvm_object.flushModule(comp);
		826	}
		827	}
828		828
829	if (self.text_section_size_dirty) {	829	if (self.text_section_size_dirty) {
830	// Write the new raw size in the .text header	830	// Write the new raw size in the .text header
...	@@ -1398,8 +1398,9 @@ pub fn updateDeclLineNumber(self: Coff, module: Module, decl: *Module.Decl) !v	...	@@ -1398,8 +1398,9 @@ pub fn updateDeclLineNumber(self: Coff, module: Module, decl: *Module.Decl) !v
1398	}	1398	}
1399		1399
1400	pub fn deinit(self: *Coff) void {	1400	pub fn deinit(self: *Coff) void {
1401	if (build_options.have_llvm)	1401	if (build_options.have_llvm) {
1402	if (self.llvm_object) \|ir_module\| ir_module.deinit(self.base.allocator);	1402	if (self.llvm_object) \|llvm_object\| llvm_object.destroy(self.base.allocator);
		1403	}
1403		1404
1404	self.text_block_free_list.deinit(self.base.allocator);	1405	self.text_block_free_list.deinit(self.base.allocator);
1405	self.offset_table.deinit(self.base.allocator);	1406	self.offset_table.deinit(self.base.allocator);

...	@@ -19,7 +19,7 @@ const build_options = @import("build_options");	...	@@ -19,7 +19,7 @@ const build_options = @import("build_options");
19	const wasi_libc = @import("../wasi_libc.zig");	19	const wasi_libc = @import("../wasi_libc.zig");
20	const Cache = @import("../Cache.zig");	20	const Cache = @import("../Cache.zig");
21	const TypedValue = @import("../TypedValue.zig");	21	const TypedValue = @import("../TypedValue.zig");
22	const llvm_backend = @import("../codegen/llvm.zig");	22	const LlvmObject = @import("../codegen/llvm.zig").Object;
23	const Air = @import("../Air.zig");	23	const Air = @import("../Air.zig");
24	const Liveness = @import("../Liveness.zig");	24	const Liveness = @import("../Liveness.zig");
25		25
...	@@ -27,7 +27,7 @@ pub const base_tag = link.File.Tag.wasm;	...	@@ -27,7 +27,7 @@ pub const base_tag = link.File.Tag.wasm;
27		27
28	base: link.File,	28	base: link.File,
29	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.	29	/// If this is not null, an object file is created by LLVM and linked with LLD afterwards.
30	llvm_object: ?*llvm_backend.Object = null,	30	llvm_object: ?*LlvmObject = null,
31	/// List of all function Decls to be written to the output file. The index of	31	/// List of all function Decls to be written to the output file. The index of
32	/// each Decl in this list at the time of writing the binary is used as the	32	/// each Decl in this list at the time of writing the binary is used as the
33	/// function index. In the event where ext_funcs' size is not 0, the index of	33	/// function index. In the event where ext_funcs' size is not 0, the index of
...	@@ -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 llvm_backend.Object.create(allocator, sub_path, options);	124	self.llvm_object = try LlvmObject.create(allocator, options);
125	return self;	125	return self;
126	}	126	}
127		127
...	@@ -153,6 +153,9 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !Wasm {	...	@@ -153,6 +153,9 @@ pub fn createEmpty(gpa: Allocator, options: link.Options) !Wasm {
153	}	153	}
154		154
155	pub fn deinit(self: *Wasm) void {	155	pub fn deinit(self: *Wasm) void {
		156	if (build_options.have_llvm) {
		157	if (self.llvm_object) \|llvm_object\| llvm_object.destroy(self.base.allocator);
		158	}
156	for (self.symbols.items) \|decl\| {	159	for (self.symbols.items) \|decl\| {
157	decl.fn_link.wasm.functype.deinit(self.base.allocator);	160	decl.fn_link.wasm.functype.deinit(self.base.allocator);
158	decl.fn_link.wasm.code.deinit(self.base.allocator);	161	decl.fn_link.wasm.code.deinit(self.base.allocator);
...	@@ -642,7 +645,9 @@ fn linkWithLLD(self: Wasm, comp: Compilation) !void {	...	@@ -642,7 +645,9 @@ fn linkWithLLD(self: Wasm, comp: Compilation) !void {
642	break :blk full_obj_path;	645	break :blk full_obj_path;
643	} else null;	646	} else null;
644		647
645	const compiler_rt_path: ?[]const u8 = if (self.base.options.include_compiler_rt)	648	const is_obj = self.base.options.output_mode == .Obj;
		649
		650	const compiler_rt_path: ?[]const u8 = if (self.base.options.include_compiler_rt and !is_obj)
646	comp.compiler_rt_static_lib.?.full_object_path	651	comp.compiler_rt_static_lib.?.full_object_path
647	else	652	else
648	null;	653	null;

...	@@ -39,6 +39,7 @@ static int print_full_usage(const char arg0, FILE file, int return_code) {	...	@@ -39,6 +39,7 @@ static int print_full_usage(const char arg0, FILE file, int return_code) {
39	" --color [auto\|off\|on] enable or disable colored error messages\n"	39	" --color [auto\|off\|on] enable or disable colored error messages\n"
40	" --name [name] override output name\n"	40	" --name [name] override output name\n"
41	" -femit-bin=[path] Output machine code\n"	41	" -femit-bin=[path] Output machine code\n"
		42	" -fcompiler-rt Always include compiler-rt symbols in output\n"
42	" --pkg-begin [name] [path] make pkg available to import and push current pkg\n"	43	" --pkg-begin [name] [path] make pkg available to import and push current pkg\n"
43	" --pkg-end pop current pkg\n"	44	" --pkg-end pop current pkg\n"
44	" -ODebug build with optimizations off and safety on\n"	45	" -ODebug build with optimizations off and safety on\n"
...	@@ -266,6 +267,7 @@ int main(int argc, char **argv) {	...	@@ -266,6 +267,7 @@ int main(int argc, char **argv) {
266	const char *mcpu = nullptr;	267	const char *mcpu = nullptr;
267	bool single_threaded = false;	268	bool single_threaded = false;
268	bool is_test_build = false;	269	bool is_test_build = false;
		270	bool include_compiler_rt = false;
269		271
270	for (int i = 1; i < argc; i += 1) {	272	for (int i = 1; i < argc; i += 1) {
271	char *arg = argv[i];	273	char *arg = argv[i];
...	@@ -334,6 +336,8 @@ int main(int argc, char **argv) {	...	@@ -334,6 +336,8 @@ int main(int argc, char **argv) {
334	mcpu = arg + strlen("-mcpu=");	336	mcpu = arg + strlen("-mcpu=");
335	} else if (str_starts_with(arg, "-femit-bin=")) {	337	} else if (str_starts_with(arg, "-femit-bin=")) {
336	emit_bin_path = arg + strlen("-femit-bin=");	338	emit_bin_path = arg + strlen("-femit-bin=");
		339	} else if (strcmp(arg, "-fcompiler-rt") == 0) {
		340	include_compiler_rt = true;
337	} else if (i + 1 >= argc) {	341	} else if (i + 1 >= argc) {
338	fprintf(stderr, "Expected another argument after %s\n", arg);	342	fprintf(stderr, "Expected another argument after %s\n", arg);
339	return print_error_usage(arg0);	343	return print_error_usage(arg0);
...	@@ -468,6 +472,7 @@ int main(int argc, char **argv) {	...	@@ -468,6 +472,7 @@ int main(int argc, char **argv) {
468	stage1->subsystem = subsystem;	472	stage1->subsystem = subsystem;
469	stage1->pic = true;	473	stage1->pic = true;
470	stage1->is_single_threaded = single_threaded;	474	stage1->is_single_threaded = single_threaded;
		475	stage1->include_compiler_rt = include_compiler_rt;
471		476
472	zig_stage1_build_object(stage1);	477	zig_stage1_build_object(stage1);
473		478

Merge remote-tracking branch 'origin/master' into zld-incremental-2