cmake: add ZIG_STATIC_CXX

mikdusan · mikdusan · commit f349be9564d5 · 2022-12-24T21:22:02.000-05:00
This controls whether or not system c++ libraries are statically linked.
Note this does not effect whether or not zig-bundled libcxx is used.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -92,6 +92,7 @@ set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries
 set(ZIG_STATIC_LLVM off CACHE BOOL "Prefer linking against static LLVM libraries")
 set(ZIG_STATIC_ZLIB off CACHE BOOL "Prefer linking against static zlib")
 set(ZIG_STATIC_ZSTD off CACHE BOOL "Prefer linking against static zstd")
+set(ZIG_STATIC_CXX off CACHE BOOL "Prefer linking against static standard c++ library")
 set(ZIG_USE_CCACHE off CACHE BOOL "Use ccache")
 
 if(ZIG_USE_CCACHE)
@@ -107,6 +108,7 @@ if(ZIG_STATIC)
     set(ZIG_STATIC_LLVM ON)
     set(ZIG_STATIC_ZLIB ON)
     set(ZIG_STATIC_ZSTD ON)
+    set(ZIG_STATIC_CXX ON)
 endif()
 
 if (ZIG_SHARED_LLVM AND ZIG_STATIC_LLVM)
diff --git a/build.zig b/build.zig
@@ -552,32 +552,56 @@ fn addCmakeCfgOptionsToExe(
     if (use_zig_libcxx) {
         exe.linkLibCpp();
     } else {
-        const need_cpp_includes = true;
-        const lib_suffix = switch (cfg.llvm_linkage) {
-            .static => exe.target.staticLibSuffix()[1..],
-            .dynamic => exe.target.dynamicLibSuffix()[1..],
-        };
-
         // System -lc++ must be used because in this code path we are attempting to link
-        // against system-provided LLVM, Clang, LLD.
-        if (exe.target.getOsTag() == .linux) {
-            // First we try to link against gcc libstdc++. If that doesn't work, we fall
-            // back to -lc++ and cross our fingers.
-            addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), "", need_cpp_includes) catch |err| switch (err) {
-                error.RequiredLibraryNotFound => {
+        // against system-provided or system-dependent LLVM, Clang, LLD.
+        try exe.bundle.append(.{ .name = "libcxx", .allow = false });
+        if (cfg.zig_static_cxx) {
+            const lib_suffix = exe.target.staticLibSuffix()[1..];
+            const need_cpp_includes = true;
+            switch (exe.target.getOsTag()) {
+                .linux => {
+                    // First we try to link against gcc libstdc++. If that doesn't work, we fall
+                    // back to -lc++ and cross our fingers.
+                    addCxxKnownPath(b, cfg, exe, b.fmt("libstdc++.{s}", .{lib_suffix}), "", need_cpp_includes) catch |err| switch (err) {
+                        error.RequiredLibraryNotFound => {
+                            exe.linkSystemLibrary("c++");
+                        },
+                        else => |e| return e,
+                    };
+                    exe.linkSystemLibrary("unwind");
+                },
+                .ios, .macos, .watchos, .tvos => {
+                    exe.linkSystemLibrary("c++");
+                },
+                .freebsd => {
+                    try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{lib_suffix}), null, need_cpp_includes);
+                    try addCxxKnownPath(b, cfg, exe, b.fmt("libgcc_eh.{s}", .{lib_suffix}), null, need_cpp_includes);
+                    @panic("WIP: mike");
+                },
+                .openbsd => {
+                    try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{lib_suffix}), null, need_cpp_includes);
+                    try addCxxKnownPath(b, cfg, exe, b.fmt("libc++abi.{s}", .{lib_suffix}), null, need_cpp_includes);
+                    @panic("WIP: mike");
+                },
+                .netbsd => {
+                    @panic("WIP: mike");
+                },
+                .dragonfly => {
+                    @panic("WIP: mike");
+                },
+                else => {
+                    @panic("WIP: mike");
+                },
+            }
+        } else {
+            switch (exe.target.getOsTag()) {
+                .ios, .macos, .watchos, .tvos, .freebsd, .openbsd => {
                     exe.linkSystemLibrary("c++");
                 },
-                else => |e| return e,
-            };
-            exe.linkSystemLibrary("unwind");
-        } else if (exe.target.isFreeBSD()) {
-            try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{lib_suffix}), null, need_cpp_includes);
-            exe.linkSystemLibrary("pthread");
-        } else if (exe.target.getOsTag() == .openbsd) {
-            try addCxxKnownPath(b, cfg, exe, b.fmt("libc++.{s}", .{lib_suffix}), null, need_cpp_includes);
-            try addCxxKnownPath(b, cfg, exe, b.fmt("libc++abi.{s}", .{lib_suffix}), null, need_cpp_includes);
-        } else if (exe.target.isDarwin()) {
-            exe.linkSystemLibrary("c++");
+                else => {
+                    exe.linkSystemLibrary("stdc++");
+                },
+            }
         }
     }
 
@@ -675,6 +699,7 @@ const CMakeConfig = struct {
     llvm_include_dir: []const u8,
     llvm_libraries: []const u8,
     dia_guids_lib: []const u8,
+    zig_static_cxx: bool,
 };
 
 const max_config_h_bytes = 1 * 1024 * 1024;
@@ -740,6 +765,7 @@ fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
         .llvm_include_dir = undefined,
         .llvm_libraries = undefined,
         .dia_guids_lib = undefined,
+        .zig_static_cxx = false,
     };
 
     const mappings = [_]struct { prefix: []const u8, field: []const u8 }{
@@ -792,6 +818,7 @@ fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
             .field = "llvm_lib_dir",
         },
         // .prefix = ZIG_LLVM_LINK_MODE parsed manually below
+        // .prefix = ZIG_STATIC_CXX parsed manually below
     };
 
     var lines_it = mem.tokenize(u8, config_h_text, "\r\n");
@@ -809,6 +836,8 @@ fn parseConfigH(b: *Builder, config_h_text: []const u8) ?CMakeConfig {
             _ = it.next().?; // skip the stuff before the quote
             const quoted = it.next().?; // the stuff inside the quote
             ctx.llvm_linkage = if (mem.eql(u8, quoted, "shared")) .dynamic else .static;
+        } else if (mem.startsWith(u8, line, "#define ZIG_STATIC_CXX ")) {
+            ctx.zig_static_cxx = true;
         }
     }
     return ctx;
diff --git a/lib/std/build/LibExeObjStep.zig b/lib/std/build/LibExeObjStep.zig
@@ -117,6 +117,8 @@ install_step: ?*InstallArtifactStep,
 /// Base address for an executable image.
 image_base: ?u64 = null,
 
+bundle: ArrayList(BundleOption),
+
 libc_file: ?FileSource = null,
 
 valgrind_support: ?bool = null,
@@ -290,6 +292,11 @@ pub const EmitOption = union(enum) {
     }
 };
 
+pub const BundleOption = struct {
+    name: []const u8,
+    allow: bool,
+};
+
 pub fn createSharedLibrary(builder: *Builder, name: []const u8, root_src: ?FileSource, kind: SharedLibKind) *LibExeObjStep {
     return initExtraArgs(builder, name, root_src, .lib, .dynamic, switch (kind) {
         .versioned => |ver| ver,
@@ -375,6 +382,7 @@ fn initExtraArgs(
         .override_dest_dir = null,
         .installed_path = null,
         .install_step = null,
+        .bundle = ArrayList(BundleOption).init(builder.allocator),
 
         .output_path_source = GeneratedFile{ .step = &self.step },
         .output_lib_path_source = GeneratedFile{ .step = &self.step },
@@ -1242,6 +1250,16 @@ fn make(step: *Step) !void {
         try zig_args.append(builder.fmt("0x{x}", .{image_base}));
     }
 
+    for (self.bundle.items) |option| {
+        if (option.allow) {
+            try zig_args.append("--bundle");
+            try zig_args.append(option.name);
+        } else {
+            try zig_args.append("--no-bundle");
+            try zig_args.append(option.name);
+        }
+    }
+
     if (self.filter) |filter| {
         try zig_args.append("--test-filter");
         try zig_args.append(filter);
diff --git a/src/Compilation.zig b/src/Compilation.zig
@@ -120,6 +120,7 @@ local_cache_directory: Directory,
 global_cache_directory: Directory,
 libc_include_dir_list: []const []const u8,
 thread_pool: *ThreadPool,
+allow_bundle: AllowBundle,
 
 /// Populated when we build the libc++ static library. A Job to build this is placed in the queue
 /// and resolved before calling linker.flush().
@@ -307,6 +308,31 @@ pub const CObject = struct {
     }
 };
 
+/// This structure determines if a bundled library vs. system library is used.
+/// It does not have effect whether or not the library is actually enabled.
+pub const AllowBundle = struct {
+    libc: bool = true,
+    libcxx: bool = true,
+
+    /// Return null on success.
+    /// Otherwise return invalid name.
+    pub fn parse(self: *AllowBundle, csv: []const u8, allow: bool) ?[]const u8 {
+        var it = mem.split(u8, csv, ",");
+        while (it.next()) |name| {
+            if (name.len == 0) {
+                continue;
+            } else if (mem.eql(u8, name, "libc")) {
+                self.libc = allow;
+            } else if (mem.eql(u8, name, "libcxx")) {
+                self.libcxx = allow;
+            } else {
+                return name;
+            }
+        }
+        return null;
+    }
+};
+
 pub const MiscTask = enum {
     write_builtin_zig,
     glibc_crt_file,
@@ -914,6 +940,7 @@ pub const InitOptions = struct {
     link_libc: bool = false,
     link_libcpp: bool = false,
     link_libunwind: bool = false,
+    allow_bundle: AllowBundle = .{},
     want_pic: ?bool = null,
     /// This means that if the output mode is an executable it will be a
     /// Position Independent Executable. If the output mode is not an
@@ -1913,6 +1940,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
             .libc_include_dir_list = libc_dirs.libc_include_dir_list,
             .sanitize_c = sanitize_c,
             .thread_pool = options.thread_pool,
+            .allow_bundle = options.allow_bundle,
             .clang_passthrough_mode = options.clang_passthrough_mode,
             .clang_preprocessor_mode = options.clang_preprocessor_mode,
             .verbose_cc = options.verbose_cc,
@@ -2049,7 +2077,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         if (comp.wantBuildLibUnwindFromSource()) {
             try comp.work_queue.writeItem(.{ .libunwind = {} });
         }
-        if (build_options.have_llvm and is_exe_or_dyn_lib and comp.bin_file.options.link_libcpp) {
+        if (comp.allow_bundle.libcxx and build_options.have_llvm and is_exe_or_dyn_lib and comp.bin_file.options.link_libcpp) {
             try comp.work_queue.writeItem(.libcxx);
             try comp.work_queue.writeItem(.libcxxabi);
         }
@@ -4945,7 +4973,8 @@ fn wantBuildLibCFromSource(comp: Compilation) bool {
     };
     return comp.bin_file.options.link_libc and is_exe_or_dyn_lib and
         comp.bin_file.options.libc_installation == null and
-        comp.bin_file.options.target.ofmt != .c;
+        comp.bin_file.options.target.ofmt != .c and
+        comp.allow_bundle.libc;
 }
 
 fn wantBuildGLibCFromSource(comp: Compilation) bool {
diff --git a/src/link/MachO/zld.zig b/src/link/MachO/zld.zig
@@ -3734,7 +3734,7 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
         }
 
         // libc++ dep
-        if (options.link_libcpp) {
+        if (options.link_libcpp and comp.allow_bundle.libcxx) {
             try positionals.append(comp.libcxxabi_static_lib.?.full_object_path);
             try positionals.append(comp.libcxx_static_lib.?.full_object_path);
         }
@@ -3930,16 +3930,19 @@ pub fn linkWithZld(macho_file: *MachO, comp: *Compilation, prog_node: *std.Progr
                 try argv.append(lib.full_object_path);
             }
 
-            if (options.link_libcpp) {
-                try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
-                try argv.append(comp.libcxx_static_lib.?.full_object_path);
-            }
-
             try argv.append("-o");
             try argv.append(full_out_path);
 
+            if (options.link_libcpp) {
+                if (comp.allow_bundle.libcxx) {
+                    try argv.append(comp.libcxxabi_static_lib.?.full_object_path);
+                    try argv.append(comp.libcxx_static_lib.?.full_object_path);
+                } else {
+                    try argv.append("-lc++");
+                }
+            }
+
             try argv.append("-lSystem");
-            try argv.append("-lc");
 
             for (options.system_libs.keys()) |l_name| {
                 const info = options.system_libs.get(l_name).?;
diff --git a/src/main.zig b/src/main.zig
@@ -500,6 +500,8 @@ const usage_build_generic =
     \\  --subsystem [subsystem]        (Windows) /SUBSYSTEM:<subsystem> to the linker
     \\  --stack [size]                 Override default stack size
     \\  --image-base [addr]            Set base address for executable image
+    \\  --bundle=[names]               Allow bundling of one or more { libc,libcxx }
+    \\  --no-bundle=[names]            Disallow bundling of one or more { libc,libcxx }
     \\  -weak-l[lib]                   (Darwin) link against system library and mark it and all referenced symbols as weak
     \\    -weak_library [lib]
     \\  -framework [name]              (Darwin) link against framework
@@ -695,6 +697,7 @@ fn buildOutputType(
     var link_libc = false;
     var link_libcpp = false;
     var link_libunwind = false;
+    var allow_bundle: Compilation.AllowBundle = .{};
     var want_native_include_dirs = false;
     var enable_cache: ?bool = null;
     var want_pic: ?bool = null;
@@ -999,6 +1002,22 @@ fn buildOutputType(
                         };
                     } else if (mem.eql(u8, arg, "--compress-debug-sections")) {
                         linker_compress_debug_sections = link.CompressDebugSections.zlib;
+                    } else if (mem.eql(u8, arg, "--bundle")) {
+                        if (allow_bundle.parse(args_iter.nextOrFatal(), true)) |name| {
+                            fatal("expected --bundle [csv] with one or more values of {{ c,c++ }}, found '{s}'", .{name});
+                        }
+                    } else if (mem.eql(u8, arg, "--no-bundle")) {
+                        if (allow_bundle.parse(args_iter.nextOrFatal(), false)) |name| {
+                            fatal("expected --no-bundle [csv] with one or more values of {{ c,c++ }}, found '{s}'", .{name});
+                        }
+                    } else if (mem.startsWith(u8, arg, "--bundle=")) {
+                        if (allow_bundle.parse(arg["--bundle=".len..], true)) |name| {
+                            fatal("expected --bundle=[csv] with one or more values of {{ c,c++ }}, found '{s}'", .{name});
+                        }
+                    } else if (mem.startsWith(u8, arg, "--no-bundle=")) {
+                        if (allow_bundle.parse(arg["--no-bundle=".len..], false)) |name| {
+                            fatal("expected --no-bundle=[csv] with one or more values of {{ c,c++ }}, found '{s}'", .{name});
+                        }
                     } else if (mem.eql(u8, arg, "-pagezero_size")) {
                         const next_arg = args_iter.nextOrFatal();
                         pagezero_size = std.fmt.parseUnsigned(u64, eatIntPrefix(next_arg, 16), 16) catch |err| {
@@ -2321,8 +2340,10 @@ fn buildOutputType(
             }
             if (target_util.is_libcpp_lib_name(target_info.target, lib_name)) {
                 link_libcpp = true;
-                system_libs.orderedRemoveAt(i);
-                continue;
+                if (allow_bundle.libcxx) {
+                    system_libs.orderedRemoveAt(i);
+                    continue;
+                }
             }
             switch (target_util.classifyCompilerRtLibName(target_info.target, lib_name)) {
                 .none => {},
@@ -2955,6 +2976,7 @@ fn buildOutputType(
         .link_libc = link_libc,
         .link_libcpp = link_libcpp,
         .link_libunwind = link_libunwind,
+        .allow_bundle = allow_bundle,
         .want_pic = want_pic,
         .want_pie = want_pie,
         .want_lto = want_lto,
diff --git a/stage1/config.h.in b/stage1/config.h.in
@@ -29,4 +29,6 @@
 #define ZIG_LLVM_LIB_PATH "@LLVM_LIBDIRS@"
 #define ZIG_LLVM_LINK_MODE "@LLVM_LINK_MODE@"
 
+#cmakedefine ZIG_STATIC_CXX
+
 #endif
