delete enough aro to make it compile

8 files changed, 20 insertions, 1270 deletions

diff --git a/lib/compiler/aro/aro.zig b/lib/compiler/aro/aro.zig
index f53e127ac8..82c67e5513 100644
--- a/lib/compiler/aro/aro.zig
+++ b/lib/compiler/aro/aro.zig
@@ -37,6 +37,5 @@ test {
     _ = @import("aro/Preprocessor.zig");
     _ = @import("aro/target.zig");
     _ = @import("aro/Tokenizer.zig");
-    _ = @import("aro/toolchains/Linux.zig");
     _ = @import("aro/Value.zig");
 }
diff --git a/lib/compiler/aro/aro/Driver.zig b/lib/compiler/aro/aro/Driver.zig
index f595c80457..c468958aa5 100644
--- a/lib/compiler/aro/aro/Driver.zig
+++ b/lib/compiler/aro/aro/Driver.zig
@@ -99,7 +99,6 @@ raw_target_triple: ?[]const u8 = null,
 use_assembly_backend: bool = false,
 
 // linker options
-use_linker: ?[]const u8 = null,
 linker_path: ?[]const u8 = null,
 nodefaultlibs: bool = false,
 nolibc: bool = false,
@@ -572,10 +571,6 @@ pub fn parseArgs(
                 d.comp.langopts.preserve_comments = true;
                 d.comp.langopts.preserve_comments_in_macros = true;
                 comment_arg = arg;
-            } else if (option(arg, "-fuse-ld=")) |linker_name| {
-                d.use_linker = linker_name;
-            } else if (mem.eql(u8, arg, "-fuse-ld=")) {
-                d.use_linker = null;
             } else if (option(arg, "--ld-path=")) |linker_path| {
                 d.linker_path = linker_path;
             } else if (mem.eql(u8, arg, "-r")) {
@@ -1150,29 +1145,20 @@ fn exitWithCleanup(d: *Driver, code: u8) noreturn {
 /// Parses the various -fpic/-fPIC/-fpie/-fPIE arguments.
 /// Then, smooshes them together with platform defaults, to decide whether
 /// this compile should be using PIC mode or not.
-/// Returns a tuple of ( backend.CodeGenOptions.PicLevel, IsPIE).
 pub fn getPICMode(d: *Driver, lastpic: []const u8) Compilation.Error!struct { backend.CodeGenOptions.PicLevel, bool } {
     const eqlIgnoreCase = std.ascii.eqlIgnoreCase;
 
     const target = d.comp.target;
-    const linker = d.use_linker orelse @import("system_defaults").linker;
-    const is_bfd_linker = eqlIgnoreCase(linker, "bfd");
 
     const is_pie_default = switch (target_util.isPIEDefault(target)) {
         .yes => true,
         .no => false,
-        .depends_on_linker => if (is_bfd_linker)
-            target.cpu.arch == .x86_64 // CrossWindows
-        else
-            false, //MSVC
+        .depends_on_linker => false,
     };
     const is_pic_default = switch (target_util.isPICdefault(target)) {
         .yes => true,
         .no => false,
-        .depends_on_linker => if (is_bfd_linker)
-            target.cpu.arch == .x86_64
-        else
-            (target.cpu.arch == .x86_64 or target.cpu.arch == .aarch64),
+        .depends_on_linker => false,
     };
 
     var pie: bool = is_pie_default;
@@ -1239,7 +1225,7 @@ pub fn getPICMode(d: *Driver, lastpic: []const u8) Compilation.Error!struct { ba
     const forced = switch (target_util.isPICDefaultForced(target)) {
         .yes => true,
         .no => false,
-        .depends_on_linker => if (is_bfd_linker) target.cpu.arch == .x86_64 else target.cpu.arch == .aarch64 or target.cpu.arch == .x86_64,
+        .depends_on_linker => false,
     };
     if (!forced) {
         // -fpic/-fPIC, -fpie/-fPIE
diff --git a/lib/compiler/aro/aro/Driver/GCCDetector.zig b/lib/compiler/aro/aro/Driver/GCCDetector.zig
deleted file mode 100644
index b1f187bbdc..0000000000
--- a/lib/compiler/aro/aro/Driver/GCCDetector.zig
+++ /dev/null
@@ -1,632 +0,0 @@
-const std = @import("std");
-
-const system_defaults = @import("system_defaults");
-
-const GCCVersion = @import("GCCVersion.zig");
-const Multilib = @import("Multilib.zig");
-const target_util = @import("../target.zig");
-const Toolchain = @import("../Toolchain.zig");
-
-const GCCDetector = @This();
-
-is_valid: bool = false,
-install_path: []const u8 = "",
-parent_lib_path: []const u8 = "",
-version: GCCVersion = .{},
-gcc_triple: []const u8 = "",
-selected: Multilib = .{},
-biarch_sibling: ?Multilib = null,
-
-pub fn deinit(self: *GCCDetector) void {
-    if (!self.is_valid) return;
-}
-
-pub fn appendToolPath(self: *const GCCDetector, tc: *Toolchain) !void {
-    if (!self.is_valid) return;
-    return tc.addPathFromComponents(&.{
-        self.parent_lib_path,
-        "..",
-        self.gcc_triple,
-        "bin",
-    }, .program);
-}
-
-fn addDefaultGCCPrefixes(prefixes: *std.ArrayListUnmanaged([]const u8), tc: *const Toolchain) !void {
-    const sysroot = tc.getSysroot();
-    const target = tc.getTarget();
-    if (sysroot.len == 0 and target.os.tag == .linux and tc.filesystem.exists("/opt/rh")) {
-        prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-12/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-11/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/gcc-toolset-10/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-12/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-11/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-10/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-9/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-8/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-7/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-6/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-4/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-3/root/usr");
-        prefixes.appendAssumeCapacity("/opt/rh/devtoolset-2/root/usr");
-    }
-    if (sysroot.len == 0) {
-        prefixes.appendAssumeCapacity("/usr");
-    } else {
-        var usr_path = try tc.driver.comp.arena.alloc(u8, 4 + sysroot.len);
-        @memcpy(usr_path[0..4], "/usr");
-        @memcpy(usr_path[4..], sysroot);
-        prefixes.appendAssumeCapacity(usr_path);
-    }
-}
-
-fn collectLibDirsAndTriples(
-    tc: *Toolchain,
-    lib_dirs: *std.ArrayListUnmanaged([]const u8),
-    triple_aliases: *std.ArrayListUnmanaged([]const u8),
-    biarch_libdirs: *std.ArrayListUnmanaged([]const u8),
-    biarch_triple_aliases: *std.ArrayListUnmanaged([]const u8),
-) !void {
-    const AArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const AArch64Triples: [4][]const u8 = .{ "aarch64-none-linux-gnu", "aarch64-linux-gnu", "aarch64-redhat-linux", "aarch64-suse-linux" };
-    const AArch64beLibDirs: [1][]const u8 = .{"/lib"};
-    const AArch64beTriples: [2][]const u8 = .{ "aarch64_be-none-linux-gnu", "aarch64_be-linux-gnu" };
-
-    const ARMLibDirs: [1][]const u8 = .{"/lib"};
-    const ARMTriples: [1][]const u8 = .{"arm-linux-gnueabi"};
-    const ARMHFTriples: [4][]const u8 = .{ "arm-linux-gnueabihf", "armv7hl-redhat-linux-gnueabi", "armv6hl-suse-linux-gnueabi", "armv7hl-suse-linux-gnueabi" };
-
-    const ARMebLibDirs: [1][]const u8 = .{"/lib"};
-    const ARMebTriples: [1][]const u8 = .{"armeb-linux-gnueabi"};
-    const ARMebHFTriples: [2][]const u8 = .{ "armeb-linux-gnueabihf", "armebv7hl-redhat-linux-gnueabi" };
-
-    const AVRLibDirs: [1][]const u8 = .{"/lib"};
-    const AVRTriples: [1][]const u8 = .{"avr"};
-
-    const CSKYLibDirs: [1][]const u8 = .{"/lib"};
-    const CSKYTriples: [3][]const u8 = .{ "csky-linux-gnuabiv2", "csky-linux-uclibcabiv2", "csky-elf-noneabiv2" };
-
-    const X86_64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const X86_64Triples: [11][]const u8 = .{
-        "x86_64-linux-gnu",       "x86_64-unknown-linux-gnu",
-        "x86_64-pc-linux-gnu",    "x86_64-redhat-linux6E",
-        "x86_64-redhat-linux",    "x86_64-suse-linux",
-        "x86_64-manbo-linux-gnu", "x86_64-linux-gnu",
-        "x86_64-slackware-linux", "x86_64-unknown-linux",
-        "x86_64-amazon-linux",
-    };
-    const X32Triples: [2][]const u8 = .{ "x86_64-linux-gnux32", "x86_64-pc-linux-gnux32" };
-    const X32LibDirs: [2][]const u8 = .{ "/libx32", "/lib" };
-    const X86LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
-    const X86Triples: [9][]const u8 = .{
-        "i586-linux-gnu",      "i686-linux-gnu",        "i686-pc-linux-gnu",
-        "i386-redhat-linux6E", "i686-redhat-linux",     "i386-redhat-linux",
-        "i586-suse-linux",     "i686-montavista-linux", "i686-gnu",
-    };
-
-    const LoongArch64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const LoongArch64Triples: [2][]const u8 = .{ "loongarch64-linux-gnu", "loongarch64-unknown-linux-gnu" };
-
-    const M68kLibDirs: [1][]const u8 = .{"/lib"};
-    const M68kTriples: [3][]const u8 = .{ "m68k-linux-gnu", "m68k-unknown-linux-gnu", "m68k-suse-linux" };
-
-    const MIPSLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
-    const MIPSTriples: [5][]const u8 = .{
-        "mips-linux-gnu",        "mips-mti-linux",
-        "mips-mti-linux-gnu",    "mips-img-linux-gnu",
-        "mipsisa32r6-linux-gnu",
-    };
-    const MIPSELLibDirs: [2][]const u8 = .{ "/libo32", "/lib" };
-    const MIPSELTriples: [3][]const u8 = .{ "mipsel-linux-gnu", "mips-img-linux-gnu", "mipsisa32r6el-linux-gnu" };
-
-    const MIPS64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const MIPS64Triples: [6][]const u8 = .{
-        "mips64-linux-gnu",      "mips-mti-linux-gnu",
-        "mips-img-linux-gnu",    "mips64-linux-gnuabi64",
-        "mipsisa64r6-linux-gnu", "mipsisa64r6-linux-gnuabi64",
-    };
-    const MIPS64ELLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const MIPS64ELTriples: [6][]const u8 = .{
-        "mips64el-linux-gnu",      "mips-mti-linux-gnu",
-        "mips-img-linux-gnu",      "mips64el-linux-gnuabi64",
-        "mipsisa64r6el-linux-gnu", "mipsisa64r6el-linux-gnuabi64",
-    };
-
-    const MIPSN32LibDirs: [1][]const u8 = .{"/lib32"};
-    const MIPSN32Triples: [2][]const u8 = .{ "mips64-linux-gnuabin32", "mipsisa64r6-linux-gnuabin32" };
-    const MIPSN32ELLibDirs: [1][]const u8 = .{"/lib32"};
-    const MIPSN32ELTriples: [2][]const u8 = .{ "mips64el-linux-gnuabin32", "mipsisa64r6el-linux-gnuabin32" };
-
-    const MSP430LibDirs: [1][]const u8 = .{"/lib"};
-    const MSP430Triples: [1][]const u8 = .{"msp430-elf"};
-
-    const PPCLibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
-    const PPCTriples: [5][]const u8 = .{
-        "powerpc-linux-gnu",    "powerpc-unknown-linux-gnu",   "powerpc-linux-gnuspe",
-        // On 32-bit PowerPC systems running SUSE Linux, gcc is configured as a
-        // 64-bit compiler which defaults to "-m32", hence "powerpc64-suse-linux".
-        "powerpc64-suse-linux", "powerpc-montavista-linuxspe",
-    };
-    const PPCLELibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
-    const PPCLETriples: [3][]const u8 = .{ "powerpcle-linux-gnu", "powerpcle-unknown-linux-gnu", "powerpcle-linux-musl" };
-
-    const PPC64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const PPC64Triples: [4][]const u8 = .{
-        "powerpc64-linux-gnu",  "powerpc64-unknown-linux-gnu",
-        "powerpc64-suse-linux", "ppc64-redhat-linux",
-    };
-    const PPC64LELibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const PPC64LETriples: [5][]const u8 = .{
-        "powerpc64le-linux-gnu",      "powerpc64le-unknown-linux-gnu",
-        "powerpc64le-none-linux-gnu", "powerpc64le-suse-linux",
-        "ppc64le-redhat-linux",
-    };
-
-    const RISCV32LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
-    const RISCV32Triples: [3][]const u8 = .{ "riscv32-unknown-linux-gnu", "riscv32-linux-gnu", "riscv32-unknown-elf" };
-    const RISCV64LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const RISCV64Triples: [3][]const u8 = .{
-        "riscv64-unknown-linux-gnu",
-        "riscv64-linux-gnu",
-        "riscv64-unknown-elf",
-    };
-
-    const SPARCv8LibDirs: [2][]const u8 = .{ "/lib32", "/lib" };
-    const SPARCv8Triples: [2][]const u8 = .{ "sparc-linux-gnu", "sparcv8-linux-gnu" };
-    const SPARCv9LibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const SPARCv9Triples: [2][]const u8 = .{ "sparc64-linux-gnu", "sparcv9-linux-gnu" };
-
-    const SystemZLibDirs: [2][]const u8 = .{ "/lib64", "/lib" };
-    const SystemZTriples: [5][]const u8 = .{
-        "s390x-linux-gnu",  "s390x-unknown-linux-gnu", "s390x-ibm-linux-gnu",
-        "s390x-suse-linux", "s390x-redhat-linux",
-    };
-    const target = tc.getTarget();
-    if (target.os.tag == .solaris) {
-        // TODO
-        return;
-    }
-    if (target.abi.isAndroid()) {
-        const AArch64AndroidTriples: [1][]const u8 = .{"aarch64-linux-android"};
-        const ARMAndroidTriples: [1][]const u8 = .{"arm-linux-androideabi"};
-        const MIPSELAndroidTriples: [1][]const u8 = .{"mipsel-linux-android"};
-        const MIPS64ELAndroidTriples: [1][]const u8 = .{"mips64el-linux-android"};
-        const X86AndroidTriples: [1][]const u8 = .{"i686-linux-android"};
-        const X86_64AndroidTriples: [1][]const u8 = .{"x86_64-linux-android"};
-
-        switch (target.cpu.arch) {
-            .aarch64 => {
-                lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&AArch64AndroidTriples);
-            },
-            .arm,
-            .thumb,
-            => {
-                lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&ARMAndroidTriples);
-            },
-            .mipsel => {
-                lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
-                biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
-            },
-            .mips64el => {
-                lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&MIPS64ELAndroidTriples);
-                biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELAndroidTriples);
-            },
-            .x86_64 => {
-                lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
-                biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
-            },
-            .x86 => {
-                lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&X86AndroidTriples);
-                biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64AndroidTriples);
-            },
-            else => {},
-        }
-        return;
-    }
-    switch (target.cpu.arch) {
-        .aarch64 => {
-            lib_dirs.appendSliceAssumeCapacity(&AArch64LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&AArch64LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64Triples);
-        },
-        .aarch64_be => {
-            lib_dirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&AArch64beLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&AArch64beTriples);
-        },
-        .arm, .thumb => {
-            lib_dirs.appendSliceAssumeCapacity(&ARMLibDirs);
-            if (target.abi == .gnueabihf) {
-                triple_aliases.appendSliceAssumeCapacity(&ARMHFTriples);
-            } else {
-                triple_aliases.appendSliceAssumeCapacity(&ARMTriples);
-            }
-        },
-        .armeb, .thumbeb => {
-            lib_dirs.appendSliceAssumeCapacity(&ARMebLibDirs);
-            if (target.abi == .gnueabihf) {
-                triple_aliases.appendSliceAssumeCapacity(&ARMebHFTriples);
-            } else {
-                triple_aliases.appendSliceAssumeCapacity(&ARMebTriples);
-            }
-        },
-        .avr => {
-            lib_dirs.appendSliceAssumeCapacity(&AVRLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&AVRTriples);
-        },
-        .csky => {
-            lib_dirs.appendSliceAssumeCapacity(&CSKYLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&CSKYTriples);
-        },
-        .x86_64 => {
-            if (target.abi == .gnux32 or target.abi == .muslx32) {
-                lib_dirs.appendSliceAssumeCapacity(&X32LibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&X32Triples);
-                biarch_libdirs.appendSliceAssumeCapacity(&X86_64LibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
-            } else {
-                lib_dirs.appendSliceAssumeCapacity(&X86_64LibDirs);
-                triple_aliases.appendSliceAssumeCapacity(&X86_64Triples);
-                biarch_libdirs.appendSliceAssumeCapacity(&X32LibDirs);
-                biarch_triple_aliases.appendSliceAssumeCapacity(&X32Triples);
-            }
-            biarch_libdirs.appendSliceAssumeCapacity(&X86LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&X86Triples);
-        },
-        .x86 => {
-            lib_dirs.appendSliceAssumeCapacity(&X86LibDirs);
-        },
-        .loongarch64 => {
-            lib_dirs.appendSliceAssumeCapacity(&LoongArch64LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&LoongArch64Triples);
-        },
-        .m68k => {
-            lib_dirs.appendSliceAssumeCapacity(&M68kLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&M68kTriples);
-        },
-        .mips => {
-            lib_dirs.appendSliceAssumeCapacity(&MIPSLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
-        },
-        .mipsel => {
-            lib_dirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
-            triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
-        },
-        .mips64 => {
-            lib_dirs.appendSliceAssumeCapacity(&MIPS64LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&MIPS64Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32Triples);
-        },
-        .mips64el => {
-            lib_dirs.appendSliceAssumeCapacity(&MIPS64ELLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&MIPS64ELTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSELLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSELTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&MIPSN32ELLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSN32ELTriples);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&MIPSTriples);
-        },
-        .msp430 => {
-            lib_dirs.appendSliceAssumeCapacity(&MSP430LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&MSP430Triples);
-        },
-        .powerpc => {
-            lib_dirs.appendSliceAssumeCapacity(&PPCLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&PPC64LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
-        },
-        .powerpcle => {
-            lib_dirs.appendSliceAssumeCapacity(&PPCLELibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
-        },
-        .powerpc64 => {
-            lib_dirs.appendSliceAssumeCapacity(&PPC64LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&PPC64Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&PPCLibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&PPCTriples);
-        },
-        .powerpc64le => {
-            lib_dirs.appendSliceAssumeCapacity(&PPC64LELibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&PPC64LETriples);
-            biarch_libdirs.appendSliceAssumeCapacity(&PPCLELibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&PPCLETriples);
-        },
-        .riscv32 => {
-            lib_dirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
-        },
-        .riscv64 => {
-            lib_dirs.appendSliceAssumeCapacity(&RISCV64LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&RISCV64Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&RISCV32LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&RISCV32Triples);
-        },
-        .sparc => {
-            lib_dirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
-        },
-        .sparc64 => {
-            lib_dirs.appendSliceAssumeCapacity(&SPARCv9LibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&SPARCv9Triples);
-            biarch_libdirs.appendSliceAssumeCapacity(&SPARCv8LibDirs);
-            biarch_triple_aliases.appendSliceAssumeCapacity(&SPARCv8Triples);
-        },
-        .s390x => {
-            lib_dirs.appendSliceAssumeCapacity(&SystemZLibDirs);
-            triple_aliases.appendSliceAssumeCapacity(&SystemZTriples);
-        },
-        else => {},
-    }
-}
-
-pub fn discover(self: *GCCDetector, tc: *Toolchain) !void {
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    var fib = std.heap.FixedBufferAllocator.init(&path_buf);
-
-    const target = tc.getTarget();
-    const biarch_variant_target = if (target.ptrBitWidth() == 32)
-        target_util.get64BitArchVariant(target)
-    else
-        target_util.get32BitArchVariant(target);
-
-    var candidate_lib_dirs_buffer: [16][]const u8 = undefined;
-    var candidate_lib_dirs = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_lib_dirs_buffer);
-
-    var candidate_triple_aliases_buffer: [16][]const u8 = undefined;
-    var candidate_triple_aliases = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_triple_aliases_buffer);
-
-    var candidate_biarch_lib_dirs_buffer: [16][]const u8 = undefined;
-    var candidate_biarch_lib_dirs = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_biarch_lib_dirs_buffer);
-
-    var candidate_biarch_triple_aliases_buffer: [16][]const u8 = undefined;
-    var candidate_biarch_triple_aliases = std.ArrayListUnmanaged([]const u8).initBuffer(&candidate_biarch_triple_aliases_buffer);
-
-    try collectLibDirsAndTriples(
-        tc,
-        &candidate_lib_dirs,
-        &candidate_triple_aliases,
-        &candidate_biarch_lib_dirs,
-        &candidate_biarch_triple_aliases,
-    );
-
-    var target_buf: [64]u8 = undefined;
-    const triple_str = target_util.toLLVMTriple(target, &target_buf);
-    candidate_triple_aliases.appendAssumeCapacity(triple_str);
-
-    // Also include the multiarch variant if it's different.
-    var biarch_buf: [64]u8 = undefined;
-    if (biarch_variant_target) |biarch_target| {
-        const biarch_triple_str = target_util.toLLVMTriple(biarch_target, &biarch_buf);
-        if (!std.mem.eql(u8, biarch_triple_str, triple_str)) {
-            candidate_triple_aliases.appendAssumeCapacity(biarch_triple_str);
-        }
-    }
-
-    var prefixes_buf: [16][]const u8 = undefined;
-    var prefixes = std.ArrayListUnmanaged([]const u8).initBuffer(&prefixes_buf);
-    const gcc_toolchain_dir = gccToolchainDir(tc);
-    if (gcc_toolchain_dir.len != 0) {
-        const adjusted = if (gcc_toolchain_dir[gcc_toolchain_dir.len - 1] == '/')
-            gcc_toolchain_dir[0 .. gcc_toolchain_dir.len - 1]
-        else
-            gcc_toolchain_dir;
-        prefixes.appendAssumeCapacity(adjusted);
-    } else {
-        const sysroot = tc.getSysroot();
-        if (sysroot.len > 0) {
-            prefixes.appendAssumeCapacity(sysroot);
-            try addDefaultGCCPrefixes(&prefixes, tc);
-        }
-
-        if (sysroot.len == 0) {
-            try addDefaultGCCPrefixes(&prefixes, tc);
-        }
-        // TODO: Special-case handling for Gentoo
-    }
-
-    const v0 = GCCVersion.parse("0.0.0");
-    for (prefixes.items) |prefix| {
-        if (!tc.filesystem.exists(prefix)) continue;
-
-        for (candidate_lib_dirs.items) |suffix| {
-            defer fib.reset();
-            const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
-            if (!tc.filesystem.exists(lib_dir)) continue;
-
-            const gcc_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc" });
-            const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });
-
-            try self.scanLibDirForGCCTriple(tc, target, lib_dir, triple_str, false, gcc_dir_exists, gcc_cross_dir_exists);
-            for (candidate_triple_aliases.items) |candidate| {
-                try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, false, gcc_dir_exists, gcc_cross_dir_exists);
-            }
-        }
-        for (candidate_biarch_lib_dirs.items) |suffix| {
-            const lib_dir = std.fs.path.join(fib.allocator(), &.{ prefix, suffix }) catch continue;
-            if (!tc.filesystem.exists(lib_dir)) continue;
-
-            const gcc_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc" });
-            const gcc_cross_dir_exists = tc.filesystem.joinedExists(&.{ lib_dir, "/gcc-cross" });
-            for (candidate_biarch_triple_aliases.items) |candidate| {
-                try self.scanLibDirForGCCTriple(tc, target, lib_dir, candidate, true, gcc_dir_exists, gcc_cross_dir_exists);
-            }
-        }
-        if (self.version.order(v0) == .gt) break;
-    }
-}
-
-fn findBiarchMultilibs(
-    tc: *const Toolchain,
-    result: *Multilib.Detected,
-    target: std.Target,
-    path: [2][]const u8,
-    needs_biarch_suffix: bool,
-) !bool {
-    const suff64 = if (target.os.tag == .solaris) switch (target.cpu.arch) {
-        .x86, .x86_64 => "/amd64",
-        .sparc => "/sparcv9",
-        else => "/64",
-    } else "/64";
-
-    const alt_64 = Multilib.init(suff64, suff64, &.{ "-m32", "+m64", "-mx32" });
-    const alt_32 = Multilib.init("/32", "/32", &.{ "+m32", "-m64", "-mx32" });
-    const alt_x32 = Multilib.init("/x32", "/x32", &.{ "-m32", "-m64", "+mx32" });
-
-    const multilib_filter = Multilib.Filter{
-        .base = path,
-        .file = "crtbegin.o",
-    };
-
-    const Want = enum {
-        want32,
-        want64,
-        wantx32,
-    };
-    const is_x32 = target.abi == .gnux32 or target.abi == .muslx32;
-    const target_ptr_width = target.ptrBitWidth();
-    const want: Want = if (target_ptr_width == 32 and multilib_filter.exists(alt_32, tc.filesystem))
-        .want64
-    else if (target_ptr_width == 64 and is_x32 and multilib_filter.exists(alt_x32, tc.filesystem))
-        .want64
-    else if (target_ptr_width == 64 and !is_x32 and multilib_filter.exists(alt_64, tc.filesystem))
-        .want32
-    else if (target_ptr_width == 32)
-        if (needs_biarch_suffix) .want64 else .want32
-    else if (is_x32)
-        if (needs_biarch_suffix) .want64 else .wantx32
-    else if (needs_biarch_suffix) .want32 else .want64;
-
-    const default = switch (want) {
-        .want32 => Multilib.init("", "", &.{ "+m32", "-m64", "-mx32" }),
-        .want64 => Multilib.init("", "", &.{ "-m32", "+m64", "-mx32" }),
-        .wantx32 => Multilib.init("", "", &.{ "-m32", "-m64", "+mx32" }),
-    };
-    result.multilibs.appendSliceAssumeCapacity(&.{
-        default,
-        alt_64,
-        alt_32,
-        alt_x32,
-    });
-    result.filter(multilib_filter, tc.filesystem);
-    var flags: Multilib.Flags = .{};
-    flags.appendAssumeCapacity(if (target_ptr_width == 64 and !is_x32) "+m64" else "-m64");
-    flags.appendAssumeCapacity(if (target_ptr_width == 32) "+m32" else "-m32");
-    flags.appendAssumeCapacity(if (target_ptr_width == 64 and is_x32) "+mx32" else "-mx32");
-
-    return result.select(flags);
-}
-
-fn scanGCCForMultilibs(
-    self: *GCCDetector,
-    tc: *const Toolchain,
-    target: std.Target,
-    path: [2][]const u8,
-    needs_biarch_suffix: bool,
-) !bool {
-    var detected: Multilib.Detected = .{};
-    if (target.cpu.arch == .csky) {
-        // TODO
-    } else if (target.cpu.arch.isMIPS()) {
-        // TODO
-    } else if (target.cpu.arch.isRISCV()) {
-        // TODO
-    } else if (target.cpu.arch == .msp430) {
-        // TODO
-    } else if (target.cpu.arch == .avr) {
-        // No multilibs
-    } else if (!try findBiarchMultilibs(tc, &detected, target, path, needs_biarch_suffix)) {
-        return false;
-    }
-    self.selected = detected.selected;
-    self.biarch_sibling = detected.biarch_sibling;
-    return true;
-}
-
-fn scanLibDirForGCCTriple(
-    self: *GCCDetector,
-    tc: *const Toolchain,
-    target: std.Target,
-    lib_dir: []const u8,
-    candidate_triple: []const u8,
-    needs_biarch_suffix: bool,
-    gcc_dir_exists: bool,
-    gcc_cross_dir_exists: bool,
-) !void {
-    var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    var fib = std.heap.FixedBufferAllocator.init(&path_buf);
-    const arena = tc.driver.comp.arena;
-    for (0..2) |i| {
-        if (i == 0 and !gcc_dir_exists) continue;
-        if (i == 1 and !gcc_cross_dir_exists) continue;
-        defer fib.reset();
-
-        const base: []const u8 = if (i == 0) "gcc" else "gcc-cross";
-        var lib_suffix_buf: [64]u8 = undefined;
-        var suffix_buf_fib = std.heap.FixedBufferAllocator.init(&lib_suffix_buf);
-        const lib_suffix = std.fs.path.join(suffix_buf_fib.allocator(), &.{ base, candidate_triple }) catch continue;
-
-        const dir_name = std.fs.path.join(fib.allocator(), &.{ lib_dir, lib_suffix }) catch continue;
-        var parent_dir = tc.filesystem.openDir(dir_name) catch continue;
-        defer parent_dir.close();
-
-        var it = parent_dir.iterate();
-        while (it.next() catch continue) |entry| {
-            if (entry.kind != .directory) continue;
-
-            const version_text = entry.name;
-            const candidate_version = GCCVersion.parse(version_text);
-            if (candidate_version.major != -1) {
-                // TODO: cache path so we're not repeatedly scanning
-            }
-            if (candidate_version.isLessThan(4, 1, 1, "")) continue;
-            switch (candidate_version.order(self.version)) {
-                .lt, .eq => continue,
-                .gt => {},
-            }
-
-            if (!try self.scanGCCForMultilibs(tc, target, .{ dir_name, version_text }, needs_biarch_suffix)) continue;
-
-            self.version = candidate_version;
-            self.gcc_triple = try arena.dupe(u8, candidate_triple);
-            self.install_path = try std.fs.path.join(arena, &.{ lib_dir, lib_suffix, version_text });
-            self.parent_lib_path = try std.fs.path.join(arena, &.{ self.install_path, "..", "..", ".." });
-            self.is_valid = true;
-        }
-    }
-}
-
-fn gccToolchainDir(tc: *const Toolchain) []const u8 {
-    const sysroot = tc.getSysroot();
-    if (sysroot.len != 0) return "";
-    return system_defaults.gcc_install_prefix;
-}
diff --git a/lib/compiler/aro/aro/Toolchain.zig b/lib/compiler/aro/aro/Toolchain.zig
index 812ccda88b..d8b4820f66 100644
--- a/lib/compiler/aro/aro/Toolchain.zig
+++ b/lib/compiler/aro/aro/Toolchain.zig
@@ -8,7 +8,6 @@ const Driver = @import("Driver.zig");
 const Filesystem = @import("Driver/Filesystem.zig").Filesystem;
 const Multilib = @import("Driver/Multilib.zig");
 const target_util = @import("target.zig");
-const Linux = @import("toolchains/Linux.zig");
 
 pub const PathList = std.ArrayListUnmanaged([]const u8);
 
@@ -37,15 +36,7 @@ pub const UnwindLibKind = enum {
 
 const Inner = union(enum) {
     uninitialized,
-    linux: Linux,
     unknown: void,
-
-    fn deinit(self: *Inner, allocator: mem.Allocator) void {
-        switch (self.*) {
-            .linux => |*linux| linux.deinit(allocator),
-            .uninitialized, .unknown => {},
-        }
-    }
 };
 
 const Toolchain = @This();
@@ -81,32 +72,15 @@ fn getDefaultLinker(tc: *const Toolchain) []const u8 {
 /// Call this after driver has finished parsing command line arguments to find the toolchain
 pub fn discover(tc: *Toolchain) !void {
     if (tc.inner != .uninitialized) return;
-
-    const target = tc.getTarget();
-    tc.inner = switch (target.os.tag) {
-        .linux,
-        => if (target.cpu.arch == .hexagon)
-            .{ .unknown = {} } // TODO
-        else if (target.cpu.arch.isMIPS())
-            .{ .unknown = {} } // TODO
-        else if (target.cpu.arch.isPowerPC())
-            .{ .unknown = {} } // TODO
-        else if (target.cpu.arch == .ve)
-            .{ .unknown = {} } // TODO
-        else
-            .{ .linux = .{} },
-        else => .{ .unknown = {} }, // TODO
-    };
+    tc.inner = .unknown;
     return switch (tc.inner) {
         .uninitialized => unreachable,
-        .linux => |*linux| linux.discover(tc),
         .unknown => {},
     };
 }
 
 pub fn deinit(tc: *Toolchain) void {
     const gpa = tc.driver.comp.gpa;
-    tc.inner.deinit(gpa);
 
     tc.library_paths.deinit(gpa);
     tc.file_paths.deinit(gpa);
@@ -501,7 +475,6 @@ pub fn addRuntimeLibs(tc: *const Toolchain, argv: *std.array_list.Managed([]cons
 pub fn defineSystemIncludes(tc: *Toolchain) !void {
     return switch (tc.inner) {
         .uninitialized => unreachable,
-        .linux => |*linux| linux.defineSystemIncludes(tc),
         .unknown => {
             if (tc.driver.nostdinc) return;
 
diff --git a/lib/compiler/aro/aro/toolchains/Linux.zig b/lib/compiler/aro/aro/toolchains/Linux.zig
deleted file mode 100644
index 64f7d9eb5e..0000000000
--- a/lib/compiler/aro/aro/toolchains/Linux.zig
+++ /dev/null
@@ -1,519 +0,0 @@
-const std = @import("std");
-const mem = std.mem;
-
-const system_defaults = @import("system_defaults");
-
-const Compilation = @import("../Compilation.zig");
-const Driver = @import("../Driver.zig");
-const Distro = @import("../Driver/Distro.zig");
-const GCCDetector = @import("../Driver/GCCDetector.zig");
-const target_util = @import("../target.zig");
-const Toolchain = @import("../Toolchain.zig");
-
-const Linux = @This();
-
-distro: Distro.Tag = .unknown,
-extra_opts: std.ArrayListUnmanaged([]const u8) = .empty,
-gcc_detector: GCCDetector = .{},
-
-pub fn discover(self: *Linux, tc: *Toolchain) !void {
-    self.distro = Distro.detect(tc.getTarget(), tc.filesystem);
-    try self.gcc_detector.discover(tc);
-    tc.selected_multilib = self.gcc_detector.selected;
-
-    try self.gcc_detector.appendToolPath(tc);
-    try self.buildExtraOpts(tc);
-    try self.findPaths(tc);
-}
-
-fn buildExtraOpts(self: *Linux, tc: *const Toolchain) !void {
-    const gpa = tc.driver.comp.gpa;
-    const target = tc.getTarget();
-    const is_android = target.abi.isAndroid();
-    if (self.distro.isAlpine() or is_android) {
-        try self.extra_opts.ensureUnusedCapacity(gpa, 2);
-        self.extra_opts.appendAssumeCapacity("-z");
-        self.extra_opts.appendAssumeCapacity("now");
-    }
-
-    if (self.distro.isOpenSUSE() or self.distro.isUbuntu() or self.distro.isAlpine() or is_android) {
-        try self.extra_opts.ensureUnusedCapacity(gpa, 2);
-        self.extra_opts.appendAssumeCapacity("-z");
-        self.extra_opts.appendAssumeCapacity("relro");
-    }
-
-    if ((target.cpu.arch.isArm() and !target.cpu.arch.isThumb()) or target.cpu.arch.isAARCH64() or is_android) {
-        try self.extra_opts.ensureUnusedCapacity(gpa, 2);
-        self.extra_opts.appendAssumeCapacity("-z");
-        self.extra_opts.appendAssumeCapacity("max-page-size=4096");
-    }
-
-    if (target.cpu.arch == .arm or target.cpu.arch == .thumb) {
-        try self.extra_opts.append(gpa, "-X");
-    }
-
-    if (!target.cpu.arch.isMIPS() and target.cpu.arch != .hexagon) {
-        const hash_style = if (is_android) .both else self.distro.getHashStyle();
-        try self.extra_opts.append(gpa, switch (hash_style) {
-            inline else => |tag| "--hash-style=" ++ @tagName(tag),
-        });
-    }
-
-    if (system_defaults.enable_linker_build_id) {
-        try self.extra_opts.append(gpa, "--build-id");
-    }
-}
-
-fn addMultiLibPaths(self: *Linux, tc: *Toolchain, sysroot: []const u8, os_lib_dir: []const u8) !void {
-    if (!self.gcc_detector.is_valid) return;
-    const gcc_triple = self.gcc_detector.gcc_triple;
-    const lib_path = self.gcc_detector.parent_lib_path;
-
-    // Add lib/gcc/$triple/$version, with an optional /multilib suffix.
-    try tc.addPathIfExists(&.{ self.gcc_detector.install_path, tc.selected_multilib.gcc_suffix }, .file);
-
-    // Add lib/gcc/$triple/$libdir
-    // For GCC built with --enable-version-specific-runtime-libs.
-    try tc.addPathIfExists(&.{ self.gcc_detector.install_path, "..", os_lib_dir }, .file);
-
-    try tc.addPathIfExists(&.{ lib_path, "..", gcc_triple, "lib", "..", os_lib_dir, tc.selected_multilib.os_suffix }, .file);
-
-    // If the GCC installation we found is inside of the sysroot, we want to
-    // prefer libraries installed in the parent prefix of the GCC installation.
-    // It is important to *not* use these paths when the GCC installation is
-    // outside of the system root as that can pick up unintended libraries.
-    // This usually happens when there is an external cross compiler on the
-    // host system, and a more minimal sysroot available that is the target of
-    // the cross. Note that GCC does include some of these directories in some
-    // configurations but this seems somewhere between questionable and simply
-    // a bug.
-    if (mem.startsWith(u8, lib_path, sysroot)) {
-        try tc.addPathIfExists(&.{ lib_path, "..", os_lib_dir }, .file);
-    }
-}
-
-fn addMultiArchPaths(self: *Linux, tc: *Toolchain) !void {
-    if (!self.gcc_detector.is_valid) return;
-    const lib_path = self.gcc_detector.parent_lib_path;
-    const gcc_triple = self.gcc_detector.gcc_triple;
-    const multilib = self.gcc_detector.selected;
-    try tc.addPathIfExists(&.{ lib_path, "..", gcc_triple, "lib", multilib.os_suffix }, .file);
-}
-
-/// TODO: Very incomplete
-fn findPaths(self: *Linux, tc: *Toolchain) !void {
-    const target = tc.getTarget();
-    const sysroot = tc.getSysroot();
-
-    var output: [64]u8 = undefined;
-
-    const os_lib_dir = getOSLibDir(target);
-    const multiarch_triple = getMultiarchTriple(target) orelse target_util.toLLVMTriple(target, &output);
-
-    try self.addMultiLibPaths(tc, sysroot, os_lib_dir);
-
-    try tc.addPathIfExists(&.{ sysroot, "/lib", multiarch_triple }, .file);
-    try tc.addPathIfExists(&.{ sysroot, "/lib", "..", os_lib_dir }, .file);
-
-    if (target.abi.isAndroid()) {
-        // TODO
-    }
-    try tc.addPathIfExists(&.{ sysroot, "/usr", "lib", multiarch_triple }, .file);
-    try tc.addPathIfExists(&.{ sysroot, "/usr", "lib", "..", os_lib_dir }, .file);
-
-    try self.addMultiArchPaths(tc);
-
-    try tc.addPathIfExists(&.{ sysroot, "/lib" }, .file);
-    try tc.addPathIfExists(&.{ sysroot, "/usr", "lib" }, .file);
-}
-
-pub fn deinit(self: *Linux, allocator: std.mem.Allocator) void {
-    self.extra_opts.deinit(allocator);
-}
-
-fn isPIEDefault(self: *const Linux) bool {
-    _ = self;
-    return false;
-}
-
-fn getPIE(self: *const Linux, d: *const Driver) bool {
-    if (d.shared or d.static or d.relocatable or d.static_pie) {
-        return false;
-    }
-    return d.pie orelse self.isPIEDefault();
-}
-
-fn getStaticPIE(self: *const Linux, d: *Driver) !bool {
-    _ = self;
-    if (d.static_pie and d.pie != null) {
-        try d.err("cannot specify 'nopie' along with 'static-pie'", .{});
-    }
-    return d.static_pie;
-}
-
-fn getStatic(self: *const Linux, d: *const Driver) bool {
-    _ = self;
-    return d.static and !d.static_pie;
-}
-
-pub fn getDefaultLinker(self: *const Linux, target: std.Target) []const u8 {
-    _ = self;
-    if (target.abi.isAndroid()) {
-        return "ld.lld";
-    }
-    return "ld";
-}
-
-pub fn buildLinkerArgs(self: *const Linux, tc: *const Toolchain, argv: *std.array_list.Managed([]const u8)) Compilation.Error!void {
-    const d = tc.driver;
-    const target = tc.getTarget();
-
-    const is_pie = self.getPIE(d);
-    const is_static_pie = try self.getStaticPIE(d);
-    const is_static = self.getStatic(d);
-    const is_android = target.abi.isAndroid();
-    const is_ve = target.cpu.arch == .ve;
-    const has_crt_begin_end_files = target.abi != .none; // TODO: clang checks for MIPS vendor
-
-    if (is_pie) {
-        try argv.append("-pie");
-    }
-    if (is_static_pie) {
-        try argv.appendSlice(&.{ "-static", "-pie", "--no-dynamic-linker", "-z", "text" });
-    }
-
-    if (d.rdynamic) {
-        try argv.append("-export-dynamic");
-    }
-
-    if (d.strip) {
-        try argv.append("-s");
-    }
-
-    try argv.appendSlice(self.extra_opts.items);
-    try argv.append("--eh-frame-hdr");
-
-    // Todo: Driver should parse `-EL`/`-EB` for arm to set endianness for arm targets
-    if (target_util.ldEmulationOption(d.comp.target, null)) |emulation| {
-        try argv.appendSlice(&.{ "-m", emulation });
-    } else {
-        try d.err("Unknown target triple", .{});
-        return;
-    }
-    if (d.comp.target.cpu.arch.isRISCV()) {
-        try argv.append("-X");
-    }
-    if (d.shared) {
-        try argv.append("-shared");
-    }
-    if (is_static) {
-        try argv.append("-static");
-    } else {
-        if (d.rdynamic) {
-            try argv.append("-export-dynamic");
-        }
-        if (!d.shared and !is_static_pie and !d.relocatable) {
-            const dynamic_linker = d.comp.target.standardDynamicLinkerPath();
-            // todo: check for --dyld-prefix
-            if (dynamic_linker.get()) |path| {
-                try argv.appendSlice(&.{ "-dynamic-linker", try d.comp.arena.dupe(u8, path) });
-            } else {
-                try d.err("Could not find dynamic linker path", .{});
-            }
-        }
-    }
-
-    try argv.appendSlice(&.{ "-o", d.output_name orelse "a.out" });
-
-    if (!d.nostdlib and !d.nostartfiles and !d.relocatable) {
-        if (!is_android) {
-            if (!d.shared) {
-                const crt1 = if (is_pie)
-                    "Scrt1.o"
-                else if (is_static_pie)
-                    "rcrt1.o"
-                else
-                    "crt1.o";
-                try argv.append(try tc.getFilePath(crt1));
-            }
-            try argv.append(try tc.getFilePath("crti.o"));
-        }
-        if (is_ve) {
-            try argv.appendSlice(&.{ "-z", "max-page-size=0x4000000" });
-        }
-
-        if (has_crt_begin_end_files) {
-            var path: []const u8 = "";
-            if (tc.getRuntimeLibKind() == .compiler_rt and !is_android) {
-                const crt_begin = try tc.getCompilerRt("crtbegin", .object);
-                if (tc.filesystem.exists(crt_begin)) {
-                    path = crt_begin;
-                }
-            }
-            if (path.len == 0) {
-                const crt_begin = if (tc.driver.shared)
-                    if (is_android) "crtbegin_so.o" else "crtbeginS.o"
-                else if (is_static)
-                    if (is_android) "crtbegin_static.o" else "crtbeginT.o"
-                else if (is_pie or is_static_pie)
-                    if (is_android) "crtbegin_dynamic.o" else "crtbeginS.o"
-                else if (is_android) "crtbegin_dynamic.o" else "crtbegin.o";
-                path = try tc.getFilePath(crt_begin);
-            }
-            try argv.append(path);
-        }
-    }
-
-    // TODO add -L opts
-    // TODO add -u opts
-
-    try tc.addFilePathLibArgs(argv);
-
-    // TODO handle LTO
-
-    try argv.appendSlice(d.link_objects.items);
-
-    if (!d.nostdlib and !d.relocatable) {
-        if (!d.nodefaultlibs) {
-            if (is_static or is_static_pie) {
-                try argv.append("--start-group");
-            }
-            try tc.addRuntimeLibs(argv);
-
-            // TODO: add pthread if needed
-            if (!d.nolibc) {
-                try argv.append("-lc");
-            }
-            if (is_static or is_static_pie) {
-                try argv.append("--end-group");
-            } else {
-                try tc.addRuntimeLibs(argv);
-            }
-        }
-        if (!d.nostartfiles) {
-            if (has_crt_begin_end_files) {
-                var path: []const u8 = "";
-                if (tc.getRuntimeLibKind() == .compiler_rt and !is_android) {
-                    const crt_end = try tc.getCompilerRt("crtend", .object);
-                    if (tc.filesystem.exists(crt_end)) {
-                        path = crt_end;
-                    }
-                }
-                if (path.len == 0) {
-                    const crt_end = if (d.shared)
-                        if (is_android) "crtend_so.o" else "crtendS.o"
-                    else if (is_pie or is_static_pie)
-                        if (is_android) "crtend_android.o" else "crtendS.o"
-                    else if (is_android) "crtend_android.o" else "crtend.o";
-                    path = try tc.getFilePath(crt_end);
-                }
-                try argv.append(path);
-            }
-            if (!is_android) {
-                try argv.append(try tc.getFilePath("crtn.o"));
-            }
-        }
-    }
-
-    // TODO add -T args
-}
-
-fn getMultiarchTriple(target: std.Target) ?[]const u8 {
-    const is_android = target.abi.isAndroid();
-    const is_mips_r6 = std.Target.mips.featureSetHas(target.cpu.features, .mips32r6);
-    return switch (target.cpu.arch) {
-        .arm, .thumb => if (is_android) "arm-linux-androideabi" else if (target.abi == .gnueabihf) "arm-linux-gnueabihf" else "arm-linux-gnueabi",
-        .armeb, .thumbeb => if (target.abi == .gnueabihf) "armeb-linux-gnueabihf" else "armeb-linux-gnueabi",
-        .aarch64 => if (is_android) "aarch64-linux-android" else "aarch64-linux-gnu",
-        .aarch64_be => "aarch64_be-linux-gnu",
-        .x86 => if (is_android) "i686-linux-android" else "i386-linux-gnu",
-        .x86_64 => if (is_android) "x86_64-linux-android" else if (target.abi == .gnux32) "x86_64-linux-gnux32" else "x86_64-linux-gnu",
-        .m68k => "m68k-linux-gnu",
-        .mips => if (is_mips_r6) "mipsisa32r6-linux-gnu" else "mips-linux-gnu",
-        .mipsel => if (is_android) "mipsel-linux-android" else if (is_mips_r6) "mipsisa32r6el-linux-gnu" else "mipsel-linux-gnu",
-        .powerpcle => "powerpcle-linux-gnu",
-        .powerpc64 => "powerpc64-linux-gnu",
-        .powerpc64le => "powerpc64le-linux-gnu",
-        .riscv64 => "riscv64-linux-gnu",
-        .sparc => "sparc-linux-gnu",
-        .sparc64 => "sparc64-linux-gnu",
-        .s390x => "s390x-linux-gnu",
-
-        // TODO: expand this
-        else => null,
-    };
-}
-
-fn getOSLibDir(target: std.Target) []const u8 {
-    switch (target.cpu.arch) {
-        .x86,
-        .powerpc,
-        .powerpcle,
-        .sparc,
-        => return "lib32",
-        else => {},
-    }
-    if (target.cpu.arch == .x86_64 and (target.abi == .gnux32 or target.abi == .muslx32)) {
-        return "libx32";
-    }
-    if (target.cpu.arch == .riscv32) {
-        return "lib32";
-    }
-    if (target.ptrBitWidth() == 32) {
-        return "lib";
-    }
-    return "lib64";
-}
-
-pub fn defineSystemIncludes(self: *const Linux, tc: *const Toolchain) !void {
-    if (tc.driver.nostdinc) return;
-
-    const comp = tc.driver.comp;
-    const target = tc.getTarget();
-
-    // musl prefers /usr/include before builtin includes, so musl targets will add builtins
-    // at the end of this function (unless disabled with nostdlibinc)
-    if (!tc.driver.nobuiltininc and (!target.abi.isMusl() or tc.driver.nostdlibinc)) {
-        try comp.addBuiltinIncludeDir(tc.driver.aro_name, tc.driver.resource_dir);
-    }
-
-    if (tc.driver.nostdlibinc) return;
-
-    const sysroot = tc.getSysroot();
-    const local_include = try std.fs.path.join(comp.gpa, &.{ sysroot, "/usr/local/include" });
-    defer comp.gpa.free(local_include);
-    try comp.addSystemIncludeDir(local_include);
-
-    if (self.gcc_detector.is_valid) {
-        const gcc_include_path = try std.fs.path.join(comp.gpa, &.{ self.gcc_detector.parent_lib_path, "..", self.gcc_detector.gcc_triple, "include" });
-        defer comp.gpa.free(gcc_include_path);
-        try comp.addSystemIncludeDir(gcc_include_path);
-    }
-
-    if (getMultiarchTriple(target)) |triple| {
-        const joined = try std.fs.path.join(comp.gpa, &.{ sysroot, "/usr/include", triple });
-        defer comp.gpa.free(joined);
-        if (tc.filesystem.exists(joined)) {
-            try comp.addSystemIncludeDir(joined);
-        }
-    }
-
-    if (target.os.tag == .rtems) return;
-
-    try comp.addSystemIncludeDir("/include");
-    try comp.addSystemIncludeDir("/usr/include");
-
-    std.debug.assert(!tc.driver.nostdlibinc);
-    if (!tc.driver.nobuiltininc and target.abi.isMusl()) {
-        try comp.addBuiltinIncludeDir(tc.driver.aro_name, tc.driver.resource_dir);
-    }
-}
-
-test Linux {
-    if (@import("builtin").os.tag == .windows) return error.SkipZigTest;
-
-    var arena_instance = std.heap.ArenaAllocator.init(std.testing.allocator);
-    defer arena_instance.deinit();
-    const arena = arena_instance.allocator();
-
-    var comp = Compilation.init(std.testing.allocator, arena, undefined, std.fs.cwd());
-    defer comp.deinit();
-    comp.environment = .{
-        .path = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
-    };
-    defer comp.environment = .{};
-
-    const raw_triple = "x86_64-linux-gnu";
-    const target_query = try std.Target.Query.parse(.{ .arch_os_abi = raw_triple });
-    comp.target = try std.zig.system.resolveTargetQuery(target_query);
-    comp.langopts.setEmulatedCompiler(.gcc);
-
-    var driver: Driver = .{ .comp = &comp, .diagnostics = undefined };
-    defer driver.deinit();
-    driver.raw_target_triple = raw_triple;
-
-    const link_obj = try driver.comp.gpa.dupe(u8, "/tmp/foo.o");
-    try driver.link_objects.append(driver.comp.gpa, link_obj);
-    driver.temp_file_count += 1;
-
-    var toolchain: Toolchain = .{ .driver = &driver, .filesystem = .{ .fake = &.{
-        .{ .path = "/tmp" },
-        .{ .path = "/usr" },
-        .{ .path = "/usr/lib64" },
-        .{ .path = "/usr/bin" },
-        .{ .path = "/usr/bin/ld", .executable = true },
-        .{ .path = "/lib" },
-        .{ .path = "/lib/x86_64-linux-gnu" },
-        .{ .path = "/lib/x86_64-linux-gnu/crt1.o" },
-        .{ .path = "/lib/x86_64-linux-gnu/crti.o" },
-        .{ .path = "/lib/x86_64-linux-gnu/crtn.o" },
-        .{ .path = "/lib64" },
-        .{ .path = "/usr/lib" },
-        .{ .path = "/usr/lib/gcc" },
-        .{ .path = "/usr/lib/gcc/x86_64-linux-gnu" },
-        .{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9" },
-        .{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9/crtbegin.o" },
-        .{ .path = "/usr/lib/gcc/x86_64-linux-gnu/9/crtend.o" },
-        .{ .path = "/usr/lib/x86_64-linux-gnu" },
-        .{ .path = "/etc/lsb-release", .contents = 
-        \\DISTRIB_ID=Ubuntu
-        \\DISTRIB_RELEASE=20.04
-        \\DISTRIB_CODENAME=focal
-        \\DISTRIB_DESCRIPTION="Ubuntu 20.04.6 LTS"
-        \\
-        },
-    } } };
-    defer toolchain.deinit();
-
-    try toolchain.discover();
-
-    var argv = std.array_list.Managed([]const u8).init(driver.comp.gpa);
-    defer argv.deinit();
-
-    var linker_path_buf: [std.fs.max_path_bytes]u8 = undefined;
-    const linker_path = try toolchain.getLinkerPath(&linker_path_buf);
-    try argv.append(linker_path);
-
-    try toolchain.buildLinkerArgs(&argv);
-
-    const expected = [_][]const u8{
-        "/usr/bin/ld",
-        "-z",
-        "relro",
-        "--hash-style=gnu",
-        "--eh-frame-hdr",
-        "-m",
-        "elf_x86_64",
-        "-dynamic-linker",
-        "/lib64/ld-linux-x86-64.so.2",
-        "-o",
-        "a.out",
-        "/lib/x86_64-linux-gnu/crt1.o",
-        "/lib/x86_64-linux-gnu/crti.o",
-        "/usr/lib/gcc/x86_64-linux-gnu/9/crtbegin.o",
-        "-L/usr/lib/gcc/x86_64-linux-gnu/9",
-        "-L/usr/lib/gcc/x86_64-linux-gnu/9/../../../../lib64",
-        "-L/lib/x86_64-linux-gnu",
-        "-L/lib/../lib64",
-        "-L/usr/lib/x86_64-linux-gnu",
-        "-L/usr/lib/../lib64",
-        "-L/lib",
-        "-L/usr/lib",
-        link_obj,
-        "-lgcc",
-        "--as-needed",
-        "-lgcc_s",
-        "--no-as-needed",
-        "-lc",
-        "-lgcc",
-        "--as-needed",
-        "-lgcc_s",
-        "--no-as-needed",
-        "/usr/lib/gcc/x86_64-linux-gnu/9/crtend.o",
-        "/lib/x86_64-linux-gnu/crtn.o",
-    };
-    try std.testing.expectEqual(expected.len, argv.items.len);
-    for (expected, argv.items) |expected_item, actual_item| {
-        try std.testing.expectEqualStrings(expected_item, actual_item);
-    }
-}
diff --git a/lib/compiler/translate-c/PatternList.zig b/lib/compiler/translate-c/PatternList.zig
index 6d8ee4ed9c..28cfb7dfac 100644
--- a/lib/compiler/translate-c/PatternList.zig
+++ b/lib/compiler/translate-c/PatternList.zig
@@ -10,7 +10,7 @@ const Translator = @import("Translator.zig");
 const Error = Translator.Error;
 pub const MacroProcessingError = Error || error{UnexpectedMacroToken};
 
-const Impl = std.meta.DeclEnum(@import("helpers"));
+const Impl = std.meta.DeclEnum(std.zig.c_translation.helpers);
 const Template = struct { []const u8, Impl };
 
 /// Templates must be function-like macros
diff --git a/lib/compiler/translate-c/Translator.zig b/lib/compiler/translate-c/Translator.zig
index 202ca5b3ca..f5dea2f430 100644
--- a/lib/compiler/translate-c/Translator.zig
+++ b/lib/compiler/translate-c/Translator.zig
@@ -169,7 +169,6 @@ pub const Options = struct {
     comp: *aro.Compilation,
     pp: *const aro.Preprocessor,
     tree: *const aro.Tree,
-    module_libs: bool,
 };
 
 pub fn translate(options: Options) ![]u8 {
@@ -217,32 +216,23 @@ pub fn translate(options: Options) ![]u8 {
 
     try translator.global_scope.processContainerMemberFns();
 
-    var buf: std.ArrayList(u8) = .init(gpa);
-    defer buf.deinit();
+    var aw: std.Io.Writer.Allocating = .init(gpa);
+    defer aw.deinit();
 
-    if (options.module_libs) {
-        try buf.appendSlice(
-            \\pub const __builtin = @import("c_builtins");
-            \\pub const __helpers = @import("helpers");
-            \\
-            \\
-        );
-    } else {
-        try buf.appendSlice(
-            \\pub const __builtin = @import("c_builtins.zig");
-            \\pub const __helpers = @import("helpers.zig");
-            \\
-            \\
-        );
-    }
+    try aw.writer.writeAll(
+        \\pub const __builtin = @import("std").zig.c_translation.builtins;
+        \\pub const __helpers = @import("std").zig.c_translation.helpers;
+        \\
+        \\
+    );
 
     var zig_ast = try ast.render(gpa, translator.global_scope.nodes.items);
     defer {
         gpa.free(zig_ast.source);
         zig_ast.deinit(gpa);
     }
-    try zig_ast.renderToArrayList(&buf, .{});
-    return buf.toOwnedSlice();
+    try zig_ast.render(gpa, &aw.writer, .{});
+    return aw.toOwnedSlice();
 }
 
 fn prepopulateGlobalNameTable(t: *Translator) !void {
@@ -3905,7 +3895,7 @@ fn createBinOpNode(
     return ZigNode.initPayload(&payload.base);
 }
 
-pub fn createHelperCallNode(t: *Translator, name: std.meta.DeclEnum(@import("helpers")), args_opt: ?[]const ZigNode) !ZigNode {
+pub fn createHelperCallNode(t: *Translator, name: std.meta.DeclEnum(std.zig.c_translation.helpers), args_opt: ?[]const ZigNode) !ZigNode {
     if (args_opt) |args| {
         return ZigTag.helper_call.create(t.arena, .{
             .name = @tagName(name),
diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig
index b384809666..f9aeeae393 100644
--- a/lib/compiler/translate-c/main.zig
+++ b/lib/compiler/translate-c/main.zig
@@ -89,8 +89,6 @@ pub const usage =
 fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
     const gpa = d.comp.gpa;
 
-    var module_libs = false;
-
     const aro_args = args: {
         var i: usize = 0;
         for (args) |arg| {
@@ -108,10 +106,6 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
                 try stdout.interface.writeAll("0.0.0-dev\n");
                 try stdout.interface.flush();
                 return;
-            } else if (mem.eql(u8, arg, "-fmodule-libs")) {
-                module_libs = true;
-            } else if (mem.eql(u8, arg, "-fno-module-libs")) {
-                module_libs = false;
             } else {
                 i += 1;
             }
@@ -174,7 +168,6 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
         .comp = d.comp,
         .pp = &pp,
         .tree = &c_tree,
-        .module_libs = module_libs,
     });
     defer gpa.free(rendered_zig);
 
@@ -201,51 +194,11 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: [][:0]u8) !void {
     out_writer.interface.writeAll(rendered_zig) catch
         return d.fatal("failed to write result to '{s}': {s}", .{ out_file_path, aro.Driver.errorDescription(out_writer.err.?) });
 
-    if (!module_libs) {
-        const dest_path = if (d.output_name) |path| std.fs.path.dirname(path) else null;
-        installLibs(d, dest_path) catch |err|
-            return d.fatal("failed to install library files: {s}", .{aro.Driver.errorDescription(err)});
-    }
-
     if (fast_exit) process.exit(0);
 }
 
-fn installLibs(d: *aro.Driver, dest_path: ?[]const u8) !void {
-    const gpa = d.comp.gpa;
-    const cwd = std.fs.cwd();
-
-    const self_exe_path = try std.fs.selfExePathAlloc(gpa);
-    defer gpa.free(self_exe_path);
-
-    var cur_dir: []const u8 = self_exe_path;
-    while (std.fs.path.dirname(cur_dir)) |dirname| : (cur_dir = dirname) {
-        var base_dir = cwd.openDir(dirname, .{}) catch continue;
-        defer base_dir.close();
-
-        var lib_dir = base_dir.openDir("lib", .{}) catch continue;
-        defer lib_dir.close();
-
-        lib_dir.access("c_builtins.zig", .{}) catch continue;
-
-        {
-            const install_path = try std.fs.path.join(gpa, &.{ dest_path orelse "", "c_builtins.zig" });
-            defer gpa.free(install_path);
-            try lib_dir.copyFile("c_builtins.zig", cwd, install_path, .{});
-        }
-        {
-            const install_path = try std.fs.path.join(gpa, &.{ dest_path orelse "", "helpers.zig" });
-            defer gpa.free(install_path);
-            try lib_dir.copyFile("helpers.zig", cwd, install_path, .{});
-        }
-        return;
-    }
-    return error.FileNotFound;
-}
-
-comptime {
-    if (@import("builtin").is_test) {
-        _ = Translator;
-        _ = @import("helpers.zig");
-        _ = @import("PatternList.zig");
-    }
+test {
+    _ = Translator;
+    _ = @import("helpers.zig");
+    _ = @import("PatternList.zig");
 }