std.zig.target: Update musl path helpers to support alternative ABIs.

This is needed for muslx32 and muslabin32 support.

lib/std/zig/LibCDirs.zig

@@ -167,21 +167,16 @@ pub fn detectFromBuilding(
     }
 
     const generic_name = libCGenericName(target);
-    // Some architectures are handled by the same set of headers.
+    // Some architecture families are handled by the same set of headers.
     const arch_name = if (target.abi.isMusl())
         std.zig.target.muslArchNameHeaders(target.cpu.arch)
-    else if (target.cpu.arch.isThumb())
-        // ARM headers are valid for Thumb too.
-        switch (target.cpu.arch) {
-            .thumb => "arm",
-            .thumbeb => "armeb",
-            else => unreachable,
-        }
     else
         @tagName(target.cpu.arch);
     const os_name = @tagName(target.os.tag);
-    // Musl's headers are ABI-agnostic and so they all have the "musl" ABI name.
-    const abi_name = if (target.abi.isMusl()) "musl" else @tagName(target.abi);
+    const abi_name = if (target.abi.isMusl())
+        std.zig.target.muslAbiNameHeaders(target.abi)
+    else
+        @tagName(target.abi);
     const arch_include_dir = try std.fmt.allocPrint(
         arena,
         "{s}" ++ s ++ "libc" ++ s ++ "include" ++ s ++ "{s}-{s}-{s}",

lib/std/zig/target.zig

@@ -97,31 +97,41 @@ pub fn canBuildLibC(target: std.Target) bool {
     return false;
 }
 
-pub fn muslArchNameHeaders(arch: std.Target.Cpu.Arch) [:0]const u8 {
-    return switch (arch) {
-        .x86 => return "x86",
-        else => muslArchName(arch),
+pub fn muslArchName(arch: std.Target.Cpu.Arch, abi: std.Target.Abi) [:0]const u8 {
+    return switch (abi) {
+        .muslx32 => "x32",
+        else => switch (arch) {
+            .arm, .armeb, .thumb, .thumbeb => "arm",
+            .aarch64, .aarch64_be => "aarch64",
+            .loongarch64 => "loongarch64",
+            .m68k => "m68k",
+            .mips, .mipsel => "mips",
+            .mips64el, .mips64 => "mips64",
+            .powerpc => "powerpc",
+            .powerpc64, .powerpc64le => "powerpc64",
+            .riscv32 => "riscv32",
+            .riscv64 => "riscv64",
+            .s390x => "s390x",
+            .wasm32, .wasm64 => "wasm",
+            .x86 => "i386",
+            .x86_64 => "x86_64",
+            else => unreachable,
+        },
     };
 }
 
-pub fn muslArchName(arch: std.Target.Cpu.Arch) [:0]const u8 {
-    switch (arch) {
-        .aarch64, .aarch64_be => return "aarch64",
-        .arm, .armeb, .thumb, .thumbeb => return "arm",
-        .x86 => return "i386",
-        .loongarch64 => return "loongarch64",
-        .m68k => return "m68k",
-        .mips, .mipsel => return "mips",
-        .mips64el, .mips64 => return "mips64",
-        .powerpc => return "powerpc",
-        .powerpc64, .powerpc64le => return "powerpc64",
-        .riscv32 => return "riscv32",
-        .riscv64 => return "riscv64",
-        .s390x => return "s390x",
-        .wasm32, .wasm64 => return "wasm",
-        .x86_64 => return "x86_64",
-        else => unreachable,
-    }
+pub fn muslArchNameHeaders(arch: std.Target.Cpu.Arch) [:0]const u8 {
+    return switch (arch) {
+        .x86 => "x86",
+        else => muslArchName(arch, .musl),
+    };
+}
+
+pub fn muslAbiNameHeaders(abi: std.Target.Abi) [:0]const u8 {
+    return switch (abi) {
+        .muslx32 => "muslx32",
+        else => "musl",
+    };
 }
 
 pub fn isLibCLibName(target: std.Target, name: []const u8) bool {

src/musl.zig

@@ -4,7 +4,6 @@ const mem = std.mem;
 const path = std.fs.path;
 const assert = std.debug.assert;
 const Module = @import("Package/Module.zig");
-const archName = std.zig.target.muslArchName;
 
 const Compilation = @import("Compilation.zig");
 const build_options = @import("build_options");
@@ -113,7 +112,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
             // When there is a src/<arch>/foo.* then it should substitute for src/foo.*
             // Even a .s file can substitute for a .c file.
             const target = comp.getTarget();
-            const arch_name = archName(target.cpu.arch);
+            const arch_name = std.zig.target.muslArchName(target.cpu.arch, target.abi);
             var source_table = std.StringArrayHashMap(Ext).init(comp.gpa);
             defer source_table.deinit();
 
@@ -162,7 +161,7 @@ pub fn buildCrtFile(comp: *Compilation, in_crt_file: CrtFile, prog_node: std.Pro
 
                 var is_arch_specific = false;
                 // Architecture-specific implementations are under a <arch>/ folder.
-                if (isMuslArchName(dirbasename)) {
+                if (isArchName(dirbasename)) {
                     if (!mem.eql(u8, dirbasename, arch_name))
                         continue; // Not the architecture we're compiling for.
                     is_arch_specific = true;
@@ -327,7 +326,7 @@ pub fn needsCrt0(output_mode: std.builtin.OutputMode, link_mode: std.builtin.Lin
     };
 }
 
-fn isMuslArchName(name: []const u8) bool {
+fn isArchName(name: []const u8) bool {
     const musl_arch_names = [_][]const u8{
         "aarch64",
         "arm",
@@ -401,10 +400,12 @@ fn addCcArgs(
     want_O3: bool,
 ) error{OutOfMemory}!void {
     const target = comp.getTarget();
-    const arch_name = archName(target.cpu.arch);
+    const arch_name = std.zig.target.muslArchName(target.cpu.arch, target.abi);
     const os_name = @tagName(target.os.tag);
-    const triple = try std.fmt.allocPrint(arena, "{s}-{s}-musl", .{
-        std.zig.target.muslArchNameHeaders(target.cpu.arch), os_name,
+    const triple = try std.fmt.allocPrint(arena, "{s}-{s}-{s}", .{
+        std.zig.target.muslArchNameHeaders(target.cpu.arch),
+        os_name,
+        std.zig.target.muslAbiNameHeaders(target.abi),
     });
     const o_arg = if (want_O3) "-O3" else "-Os";
 
@@ -460,7 +461,7 @@ fn addCcArgs(
 fn start_asm_path(comp: *Compilation, arena: Allocator, basename: []const u8) ![]const u8 {
     const target = comp.getTarget();
     return comp.zig_lib_directory.join(arena, &[_][]const u8{
-        "libc", "musl", "crt", archName(target.cpu.arch), basename,
+        "libc", "musl", "crt", std.zig.target.muslArchName(target.cpu.arch, target.abi), basename,
     });
 }