| author |  Alex Rønne Petersen <alex@alexrp.com> 2026-08-23 19:40:34+02:00 |
| committer | Alex Rønne Petersen <alex@alexrp.com> 2026-08-23 20:05:28+02:00 |
| log | c606ad4ce342fc8c69f94810b6d30b3d0fcc266f |
| tree | 5663b0ed384c2fd231bce6c7802b93b6b56d8803 |
| parent | dbc54ce67cd0e313cbf8687152302c9b31529e34 |
| signature |  Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM |
std.zig.llvm.Builder: add tripleForTarget(), init target_triple from it
Users can now just pass a std.Target to Builder.init() rather than having to
construct a target triple string themselves. This makes sense to do since we've
already added std.Target knowledge to std.zig.llvm.Builder in the form of
DataLayout anyway.
closes https://codeberg.org/ziglang/zig/issues/361593 files changed, 296 insertions(+), 298 deletions(-)
lib- std
- zig
- llvm
- src
- Compilation.zig
- codegen
lib/std/zig/llvm/Builder.zig+295-3
| ... | @@ -84,9 +84,300 @@ pub const Options = struct { | ... | @@ -84,9 +84,300 @@ pub const Options = struct { |
| 84 | strip: bool = true, | 84 | strip: bool = true, |
| 85 | name: []const u8 = &.{}, | 85 | name: []const u8 = &.{}, |
| 86 | target: *const std.Target = &builtin.target, | 86 | target: *const std.Target = &builtin.target, |
| 87 | triple: []const u8 = &.{}, | ||
| 88 | }; | 87 | }; |
| 89 | 88 | ||
| 89 | fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.Family, mappings: anytype) ?[]const u8 { | ||
| 90 | inline for (mappings) |mapping| { | ||
| 91 | if (target.cpu.has(family, mapping[0])) return mapping[1]; | ||
| 92 | } | ||
| 93 | |||
| 94 | return null; | ||
| 95 | } | ||
| 96 | |||
| 97 | pub fn tripleForTarget(allocator: Allocator, target: *const std.Target) ![]const u8 { | ||
| 98 | var llvm_triple = std.array_list.Managed(u8).init(allocator); | ||
| 99 | defer llvm_triple.deinit(); | ||
| 100 | |||
| 101 | const llvm_arch = switch (target.cpu.arch) { | ||
| 102 | .arm => "arm", | ||
| 103 | .armeb => "armeb", | ||
| 104 | .aarch64 => if (target.abi == .ilp32) "aarch64_32" else "aarch64", | ||
| 105 | .aarch64_be => "aarch64_be", | ||
| 106 | .arc => "arc", | ||
| 107 | .avr => "avr", | ||
| 108 | .bpfel => "bpfel", | ||
| 109 | .bpfeb => "bpfeb", | ||
| 110 | .csky => "csky", | ||
| 111 | .hexagon => "hexagon", | ||
| 112 | .loongarch32 => "loongarch32", | ||
| 113 | .loongarch64 => "loongarch64", | ||
| 114 | .m68k => "m68k", | ||
| 115 | // MIPS sub-architectures are a bit irregular, so we handle them manually here. | ||
| 116 | .mips => if (target.cpu.has(.mips, .mips32r6)) "mipsisa32r6" else "mips", | ||
| 117 | .mipsel => if (target.cpu.has(.mips, .mips32r6)) "mipsisa32r6el" else "mipsel", | ||
| 118 | .mips64 => if (target.cpu.has(.mips, .mips64r6)) "mipsisa64r6" else "mips64", | ||
| 119 | .mips64el => if (target.cpu.has(.mips, .mips64r6)) "mipsisa64r6el" else "mips64el", | ||
| 120 | .msp430 => "msp430", | ||
| 121 | .powerpc => "powerpc", | ||
| 122 | .powerpcle => "powerpcle", | ||
| 123 | .powerpc64 => "powerpc64", | ||
| 124 | .powerpc64le => "powerpc64le", | ||
| 125 | .amdgcn => "amdgcn", | ||
| 126 | .riscv32 => "riscv32", | ||
| 127 | .riscv32be => "riscv32be", | ||
| 128 | .riscv64 => "riscv64", | ||
| 129 | .riscv64be => "riscv64be", | ||
| 130 | .sparc => "sparc", | ||
| 131 | .sparc64 => "sparc64", | ||
| 132 | .s390x => "s390x", | ||
| 133 | .thumb => "thumb", | ||
| 134 | .thumbeb => "thumbeb", | ||
| 135 | .x86 => "i386", | ||
| 136 | .x86_64 => "x86_64", | ||
| 137 | .xcore => "xcore", | ||
| 138 | .xtensa => "xtensa", | ||
| 139 | .nvptx => "nvptx", | ||
| 140 | .nvptx64 => "nvptx64", | ||
| 141 | .spirv32 => switch (target.os.tag) { | ||
| 142 | .vulkan, .opengl => "spirv", | ||
| 143 | else => "spirv32", | ||
| 144 | }, | ||
| 145 | .spirv64 => "spirv64", | ||
| 146 | .lanai => "lanai", | ||
| 147 | .wasm32 => "wasm32", | ||
| 148 | .wasm64 => "wasm64", | ||
| 149 | .ve => "ve", | ||
| 150 | |||
| 151 | .alpha, | ||
| 152 | .arceb, | ||
| 153 | .ez80, | ||
| 154 | .hppa, | ||
| 155 | .hppa64, | ||
| 156 | .kalimba, | ||
| 157 | .kvx, | ||
| 158 | .m88k, | ||
| 159 | .microblaze, | ||
| 160 | .microblazeel, | ||
| 161 | .or1k, | ||
| 162 | .propeller, | ||
| 163 | .sh, | ||
| 164 | .sheb, | ||
| 165 | .x86_16, | ||
| 166 | .xtensaeb, | ||
| 167 | => unreachable, // Gated by hasLlvmSupport(). | ||
| 168 | }; | ||
| 169 | |||
| 170 | try llvm_triple.appendSlice(llvm_arch); | ||
| 171 | |||
| 172 | const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) { | ||
| 173 | .arm, .armeb, .thumb, .thumbeb => subArchName(target, .arm, .{ | ||
| 174 | .{ .v4t, "v4t" }, | ||
| 175 | .{ .v5t, "v5t" }, | ||
| 176 | .{ .v5te, "v5te" }, | ||
| 177 | .{ .v5tej, "v5tej" }, | ||
| 178 | .{ .v6, "v6" }, | ||
| 179 | .{ .v6k, "v6k" }, | ||
| 180 | .{ .v6kz, "v6kz" }, | ||
| 181 | .{ .v6m, "v6m" }, | ||
| 182 | .{ .v6t2, "v6t2" }, | ||
| 183 | .{ .v7a, "v7a" }, | ||
| 184 | .{ .v7em, "v7em" }, | ||
| 185 | .{ .v7m, "v7m" }, | ||
| 186 | .{ .v7r, "v7r" }, | ||
| 187 | .{ .v7ve, "v7ve" }, | ||
| 188 | .{ .v8a, "v8a" }, | ||
| 189 | .{ .v8_1a, "v8.1a" }, | ||
| 190 | .{ .v8_2a, "v8.2a" }, | ||
| 191 | .{ .v8_3a, "v8.3a" }, | ||
| 192 | .{ .v8_4a, "v8.4a" }, | ||
| 193 | .{ .v8_5a, "v8.5a" }, | ||
| 194 | .{ .v8_6a, "v8.6a" }, | ||
| 195 | .{ .v8_7a, "v8.7a" }, | ||
| 196 | .{ .v8_8a, "v8.8a" }, | ||
| 197 | .{ .v8_9a, "v8.9a" }, | ||
| 198 | .{ .v8m, "v8m.base" }, | ||
| 199 | .{ .v8m_main, "v8m.main" }, | ||
| 200 | .{ .v8_1m_main, "v8.1m.main" }, | ||
| 201 | .{ .v8r, "v8r" }, | ||
| 202 | .{ .v9a, "v9a" }, | ||
| 203 | .{ .v9_1a, "v9.1a" }, | ||
| 204 | .{ .v9_2a, "v9.2a" }, | ||
| 205 | .{ .v9_3a, "v9.3a" }, | ||
| 206 | .{ .v9_4a, "v9.4a" }, | ||
| 207 | .{ .v9_5a, "v9.5a" }, | ||
| 208 | .{ .v9_6a, "v9.6a" }, | ||
| 209 | .{ .v9_7a, "v9.7a" }, | ||
| 210 | }), | ||
| 211 | .powerpc => subArchName(target, .powerpc, .{ | ||
| 212 | .{ .spe, "spe" }, | ||
| 213 | }), | ||
| 214 | .spirv32, .spirv64 => subArchName(target, .spirv, .{ | ||
| 215 | .{ .v1_6, "1.6" }, | ||
| 216 | .{ .v1_5, "1.5" }, | ||
| 217 | .{ .v1_4, "1.4" }, | ||
| 218 | .{ .v1_3, "1.3" }, | ||
| 219 | .{ .v1_2, "1.2" }, | ||
| 220 | .{ .v1_1, "1.1" }, | ||
| 221 | }), | ||
| 222 | else => null, | ||
| 223 | }; | ||
| 224 | |||
| 225 | if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub); | ||
| 226 | try llvm_triple.append('-'); | ||
| 227 | |||
| 228 | try llvm_triple.appendSlice(switch (target.os.tag) { | ||
| 229 | .driverkit, | ||
| 230 | .ios, | ||
| 231 | .maccatalyst, | ||
| 232 | .macos, | ||
| 233 | .tvos, | ||
| 234 | .visionos, | ||
| 235 | .watchos, | ||
| 236 | => "apple", | ||
| 237 | .ps4, | ||
| 238 | .ps5, | ||
| 239 | => "scei", | ||
| 240 | .amdhsa, | ||
| 241 | .amdpal, | ||
| 242 | => "amd", | ||
| 243 | .cuda, | ||
| 244 | .nvcl, | ||
| 245 | => "nvidia", | ||
| 246 | .mesa3d, | ||
| 247 | => "mesa", | ||
| 248 | else => "unknown", | ||
| 249 | }); | ||
| 250 | try llvm_triple.append('-'); | ||
| 251 | |||
| 252 | const llvm_os = switch (target.os.tag) { | ||
| 253 | .dragonfly => "dragonfly", | ||
| 254 | .freebsd => "freebsd", | ||
| 255 | .fuchsia => "fuchsia", | ||
| 256 | .linux => "linux", | ||
| 257 | .netbsd => "netbsd", | ||
| 258 | .openbsd => "openbsd", | ||
| 259 | .illumos => "solaris", | ||
| 260 | .windows, .uefi => "windows", | ||
| 261 | .haiku => "haiku", | ||
| 262 | .rtems => "rtems", | ||
| 263 | .cuda => "cuda", | ||
| 264 | .nvcl => "nvcl", | ||
| 265 | .amdhsa => "amdhsa", | ||
| 266 | .ps3 => "lv2", | ||
| 267 | .ps4 => "ps4", | ||
| 268 | .ps5 => "ps5", | ||
| 269 | .mesa3d => "mesa3d", | ||
| 270 | .amdpal => "amdpal", | ||
| 271 | .hermit => "hermit", | ||
| 272 | .hurd => "hurd", | ||
| 273 | .wasi => "wasi", | ||
| 274 | .emscripten => "emscripten", | ||
| 275 | .macos => "macosx", | ||
| 276 | .ios, .maccatalyst => "ios", | ||
| 277 | .tvos => "tvos", | ||
| 278 | .watchos => "watchos", | ||
| 279 | .driverkit => "driverkit", | ||
| 280 | .visionos => "xros", | ||
| 281 | .serenity => "serenity", | ||
| 282 | .vulkan => "vulkan", | ||
| 283 | .managarm => "managarm", | ||
| 284 | |||
| 285 | .contiki, | ||
| 286 | .freestanding, | ||
| 287 | .opencl, // https://llvm.org/docs/SPIRVUsage.html#target-triples | ||
| 288 | .opengl, | ||
| 289 | .other, | ||
| 290 | .plan9, | ||
| 291 | .psx, | ||
| 292 | .psp, | ||
| 293 | .vita, | ||
| 294 | .tios, | ||
| 295 | .@"3ds", | ||
| 296 | .wiiu, | ||
| 297 | .@"switch", | ||
| 298 | .ashetos, | ||
| 299 | => "unknown", | ||
| 300 | }; | ||
| 301 | try llvm_triple.appendSlice(llvm_os); | ||
| 302 | |||
| 303 | switch (target.os.versionRange()) { | ||
| 304 | .none, | ||
| 305 | .windows, | ||
| 306 | => {}, | ||
| 307 | .semver => |ver| if (target.os.tag == .wasi and ver.min.major == 0) { | ||
| 308 | try llvm_triple.print("p{d}", .{ver.min.minor}); | ||
| 309 | } else if (target.os.tag != .amdhsa) { | ||
| 310 | try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 311 | ver.min.major, | ||
| 312 | ver.min.minor, | ||
| 313 | ver.min.patch, | ||
| 314 | }); | ||
| 315 | }, | ||
| 316 | inline .linux, .hurd => |ver| try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 317 | ver.range.min.major, | ||
| 318 | ver.range.min.minor, | ||
| 319 | ver.range.min.patch, | ||
| 320 | }), | ||
| 321 | } | ||
| 322 | try llvm_triple.append('-'); | ||
| 323 | |||
| 324 | const llvm_abi = switch (target.abi) { | ||
| 325 | .none => if (target.os.tag == .maccatalyst) "macabi" else "unknown", | ||
| 326 | .gnu => "gnu", | ||
| 327 | .gnuabin32 => "gnuabin32", | ||
| 328 | .gnuabi64 => "gnuabi64", | ||
| 329 | .gnueabi => "gnueabi", | ||
| 330 | .gnueabihf => "gnueabihf", | ||
| 331 | .gnuf32 => "gnuf32", | ||
| 332 | .gnusf => "gnusf", | ||
| 333 | .gnux32 => "gnux32", | ||
| 334 | .ilp32 => "unknown", | ||
| 335 | .eabi => "eabi", | ||
| 336 | .eabihf => "eabihf", | ||
| 337 | .abin32 => "unknown", | ||
| 338 | .x32 => "muslx32", // https://github.com/ziglang/zig/issues/25649 | ||
| 339 | .android => "android", | ||
| 340 | .androideabi => "androideabi", | ||
| 341 | .musl => switch (target.os.tag) { | ||
| 342 | // For WASI/Emscripten, "musl" refers to the libc, not really the ABI. | ||
| 343 | // "unknown" provides better compatibility with LLVM-based tooling for these targets. | ||
| 344 | .wasi, .emscripten => "unknown", | ||
| 345 | else => "musl", | ||
| 346 | }, | ||
| 347 | .muslabin32 => "muslabin32", | ||
| 348 | .muslabi64 => "muslabi64", | ||
| 349 | .musleabi => "musleabi", | ||
| 350 | .musleabihf => "musleabihf", | ||
| 351 | .muslf32 => "muslf32", | ||
| 352 | .muslsf => "muslsf", | ||
| 353 | .muslx32 => "muslx32", | ||
| 354 | .msvc => "msvc", | ||
| 355 | .itanium => "itanium", | ||
| 356 | .simulator => "simulator", | ||
| 357 | .ohos, .ohoseabi => "ohos", | ||
| 358 | .call0 => "unknown", | ||
| 359 | }; | ||
| 360 | try llvm_triple.appendSlice(llvm_abi); | ||
| 361 | |||
| 362 | switch (target.os.versionRange()) { | ||
| 363 | .none, | ||
| 364 | .semver, | ||
| 365 | .windows, | ||
| 366 | => {}, | ||
| 367 | inline .hurd, .linux => |ver| if (target.abi.isGnu()) { | ||
| 368 | try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 369 | ver.glibc.major, | ||
| 370 | ver.glibc.minor, | ||
| 371 | ver.glibc.patch, | ||
| 372 | }); | ||
| 373 | } else if (@TypeOf(ver) == std.Target.Os.LinuxVersionRange and target.abi.isAndroid()) { | ||
| 374 | try llvm_triple.print("{d}", .{ver.android}); | ||
| 375 | }, | ||
| 376 | } | ||
| 377 | |||
| 378 | return llvm_triple.toOwnedSlice(); | ||
| 379 | } | ||
| 380 | |||
| 90 | pub const DataLayout = struct { | 381 | pub const DataLayout = struct { |
| 91 | endian: ?std.lang.Endian, | 382 | endian: ?std.lang.Endian, |
| 92 | int_specs: PrimitiveSpec.Map, | 383 | int_specs: PrimitiveSpec.Map, |
| ... | @@ -9610,6 +9901,9 @@ pub fn init(options: Options) Allocator.Error!Builder { | ... | @@ -9610,6 +9901,9 @@ pub fn init(options: Options) Allocator.Error!Builder { |
| 9610 | try self.string_indices.append(self.gpa, 0); | 9901 | try self.string_indices.append(self.gpa, 0); |
| 9611 | assert(try self.string("") == .empty); | 9902 | assert(try self.string("") == .empty); |
| 9612 | 9903 | ||
| 9904 | const llvm_triple = try tripleForTarget(self.gpa, options.target); | ||
| 9905 | defer self.gpa.free(llvm_triple); | ||
| 9906 | self.target_triple = try self.string(llvm_triple); | ||
| 9613 | self.data_layout = try .parseString(try self.string(DataLayout.stringForTarget(options.target)), &self); | 9907 | self.data_layout = try .parseString(try self.string(DataLayout.stringForTarget(options.target)), &self); |
| 9614 | 9908 | ||
| 9615 | try self.strtab_string_indices.append(self.gpa, 0); | 9909 | try self.strtab_string_indices.append(self.gpa, 0); |
| ... | @@ -9617,8 +9911,6 @@ pub fn init(options: Options) Allocator.Error!Builder { | ... | @@ -9617,8 +9911,6 @@ pub fn init(options: Options) Allocator.Error!Builder { |
| 9617 | 9911 | ||
| 9618 | if (options.name.len > 0) self.source_filename = try self.string(options.name); | 9912 | if (options.name.len > 0) self.source_filename = try self.string(options.name); |
| 9619 | 9913 | ||
| 9620 | if (options.triple.len > 0) self.target_triple = try self.string(options.triple); | ||
| 9621 | |||
| 9622 | { | 9914 | { |
| 9623 | const static_len = @typeInfo(Type).@"enum".field_names.len - 1; | 9915 | const static_len = @typeInfo(Type).@"enum".field_names.len - 1; |
| 9624 | try self.type_map.ensureTotalCapacity(self.gpa, static_len); | 9916 | try self.type_map.ensureTotalCapacity(self.gpa, static_len); |
src/Compilation.zig+1-1
| ... | @@ -6574,7 +6574,7 @@ pub fn addCCArgs( | ... | @@ -6574,7 +6574,7 @@ pub fn addCCArgs( |
| 6574 | try argv.append("-integrated-as"); | 6574 | try argv.append("-integrated-as"); |
| 6575 | } | 6575 | } |
| 6576 | 6576 | ||
| 6577 | const llvm_triple = try @import("codegen/llvm.zig").targetTriple(arena, target); | 6577 | const llvm_triple = try std.zig.llvm.Builder.tripleForTarget(arena, target); |
| 6578 | try argv.appendSlice(&[_][]const u8{ "-target", llvm_triple }); | 6578 | try argv.appendSlice(&[_][]const u8{ "-target", llvm_triple }); |
| 6579 | 6579 | ||
| 6580 | if (target.cpu.arch.isThumb()) { | 6580 | if (target.cpu.arch.isThumb()) { |
src/codegen/llvm.zig-294
| ... | @@ -46,298 +46,6 @@ pub fn legalizeFeatures(target: *const std.Target) ?*const Air.Legalize.Features | ... | @@ -46,298 +46,6 @@ pub fn legalizeFeatures(target: *const std.Target) ?*const Air.Legalize.Features |
| 46 | }; | 46 | }; |
| 47 | } | 47 | } |
| 48 | 48 | ||
| 49 | fn subArchName(target: *const std.Target, comptime family: std.Target.Cpu.Arch.Family, mappings: anytype) ?[]const u8 { | ||
| 50 | inline for (mappings) |mapping| { | ||
| 51 | if (target.cpu.has(family, mapping[0])) return mapping[1]; | ||
| 52 | } | ||
| 53 | |||
| 54 | return null; | ||
| 55 | } | ||
| 56 | |||
| 57 | pub fn targetTriple(allocator: Allocator, target: *const std.Target) ![]const u8 { | ||
| 58 | var llvm_triple = std.array_list.Managed(u8).init(allocator); | ||
| 59 | defer llvm_triple.deinit(); | ||
| 60 | |||
| 61 | const llvm_arch = switch (target.cpu.arch) { | ||
| 62 | .arm => "arm", | ||
| 63 | .armeb => "armeb", | ||
| 64 | .aarch64 => if (target.abi == .ilp32) "aarch64_32" else "aarch64", | ||
| 65 | .aarch64_be => "aarch64_be", | ||
| 66 | .arc => "arc", | ||
| 67 | .avr => "avr", | ||
| 68 | .bpfel => "bpfel", | ||
| 69 | .bpfeb => "bpfeb", | ||
| 70 | .csky => "csky", | ||
| 71 | .hexagon => "hexagon", | ||
| 72 | .loongarch32 => "loongarch32", | ||
| 73 | .loongarch64 => "loongarch64", | ||
| 74 | .m68k => "m68k", | ||
| 75 | // MIPS sub-architectures are a bit irregular, so we handle them manually here. | ||
| 76 | .mips => if (target.cpu.has(.mips, .mips32r6)) "mipsisa32r6" else "mips", | ||
| 77 | .mipsel => if (target.cpu.has(.mips, .mips32r6)) "mipsisa32r6el" else "mipsel", | ||
| 78 | .mips64 => if (target.cpu.has(.mips, .mips64r6)) "mipsisa64r6" else "mips64", | ||
| 79 | .mips64el => if (target.cpu.has(.mips, .mips64r6)) "mipsisa64r6el" else "mips64el", | ||
| 80 | .msp430 => "msp430", | ||
| 81 | .powerpc => "powerpc", | ||
| 82 | .powerpcle => "powerpcle", | ||
| 83 | .powerpc64 => "powerpc64", | ||
| 84 | .powerpc64le => "powerpc64le", | ||
| 85 | .amdgcn => "amdgcn", | ||
| 86 | .riscv32 => "riscv32", | ||
| 87 | .riscv32be => "riscv32be", | ||
| 88 | .riscv64 => "riscv64", | ||
| 89 | .riscv64be => "riscv64be", | ||
| 90 | .sparc => "sparc", | ||
| 91 | .sparc64 => "sparc64", | ||
| 92 | .s390x => "s390x", | ||
| 93 | .thumb => "thumb", | ||
| 94 | .thumbeb => "thumbeb", | ||
| 95 | .x86 => "i386", | ||
| 96 | .x86_64 => "x86_64", | ||
| 97 | .xcore => "xcore", | ||
| 98 | .xtensa => "xtensa", | ||
| 99 | .nvptx => "nvptx", | ||
| 100 | .nvptx64 => "nvptx64", | ||
| 101 | .spirv32 => switch (target.os.tag) { | ||
| 102 | .vulkan, .opengl => "spirv", | ||
| 103 | else => "spirv32", | ||
| 104 | }, | ||
| 105 | .spirv64 => "spirv64", | ||
| 106 | .lanai => "lanai", | ||
| 107 | .wasm32 => "wasm32", | ||
| 108 | .wasm64 => "wasm64", | ||
| 109 | .ve => "ve", | ||
| 110 | |||
| 111 | .alpha, | ||
| 112 | .arceb, | ||
| 113 | .ez80, | ||
| 114 | .hppa, | ||
| 115 | .hppa64, | ||
| 116 | .kalimba, | ||
| 117 | .kvx, | ||
| 118 | .m88k, | ||
| 119 | .microblaze, | ||
| 120 | .microblazeel, | ||
| 121 | .or1k, | ||
| 122 | .propeller, | ||
| 123 | .sh, | ||
| 124 | .sheb, | ||
| 125 | .x86_16, | ||
| 126 | .xtensaeb, | ||
| 127 | => unreachable, // Gated by hasLlvmSupport(). | ||
| 128 | }; | ||
| 129 | |||
| 130 | try llvm_triple.appendSlice(llvm_arch); | ||
| 131 | |||
| 132 | const llvm_sub_arch: ?[]const u8 = switch (target.cpu.arch) { | ||
| 133 | .arm, .armeb, .thumb, .thumbeb => subArchName(target, .arm, .{ | ||
| 134 | .{ .v4t, "v4t" }, | ||
| 135 | .{ .v5t, "v5t" }, | ||
| 136 | .{ .v5te, "v5te" }, | ||
| 137 | .{ .v5tej, "v5tej" }, | ||
| 138 | .{ .v6, "v6" }, | ||
| 139 | .{ .v6k, "v6k" }, | ||
| 140 | .{ .v6kz, "v6kz" }, | ||
| 141 | .{ .v6m, "v6m" }, | ||
| 142 | .{ .v6t2, "v6t2" }, | ||
| 143 | .{ .v7a, "v7a" }, | ||
| 144 | .{ .v7em, "v7em" }, | ||
| 145 | .{ .v7m, "v7m" }, | ||
| 146 | .{ .v7r, "v7r" }, | ||
| 147 | .{ .v7ve, "v7ve" }, | ||
| 148 | .{ .v8a, "v8a" }, | ||
| 149 | .{ .v8_1a, "v8.1a" }, | ||
| 150 | .{ .v8_2a, "v8.2a" }, | ||
| 151 | .{ .v8_3a, "v8.3a" }, | ||
| 152 | .{ .v8_4a, "v8.4a" }, | ||
| 153 | .{ .v8_5a, "v8.5a" }, | ||
| 154 | .{ .v8_6a, "v8.6a" }, | ||
| 155 | .{ .v8_7a, "v8.7a" }, | ||
| 156 | .{ .v8_8a, "v8.8a" }, | ||
| 157 | .{ .v8_9a, "v8.9a" }, | ||
| 158 | .{ .v8m, "v8m.base" }, | ||
| 159 | .{ .v8m_main, "v8m.main" }, | ||
| 160 | .{ .v8_1m_main, "v8.1m.main" }, | ||
| 161 | .{ .v8r, "v8r" }, | ||
| 162 | .{ .v9a, "v9a" }, | ||
| 163 | .{ .v9_1a, "v9.1a" }, | ||
| 164 | .{ .v9_2a, "v9.2a" }, | ||
| 165 | .{ .v9_3a, "v9.3a" }, | ||
| 166 | .{ .v9_4a, "v9.4a" }, | ||
| 167 | .{ .v9_5a, "v9.5a" }, | ||
| 168 | .{ .v9_6a, "v9.6a" }, | ||
| 169 | .{ .v9_7a, "v9.7a" }, | ||
| 170 | }), | ||
| 171 | .powerpc => subArchName(target, .powerpc, .{ | ||
| 172 | .{ .spe, "spe" }, | ||
| 173 | }), | ||
| 174 | .spirv32, .spirv64 => subArchName(target, .spirv, .{ | ||
| 175 | .{ .v1_6, "1.6" }, | ||
| 176 | .{ .v1_5, "1.5" }, | ||
| 177 | .{ .v1_4, "1.4" }, | ||
| 178 | .{ .v1_3, "1.3" }, | ||
| 179 | .{ .v1_2, "1.2" }, | ||
| 180 | .{ .v1_1, "1.1" }, | ||
| 181 | }), | ||
| 182 | else => null, | ||
| 183 | }; | ||
| 184 | |||
| 185 | if (llvm_sub_arch) |sub| try llvm_triple.appendSlice(sub); | ||
| 186 | try llvm_triple.append('-'); | ||
| 187 | |||
| 188 | try llvm_triple.appendSlice(switch (target.os.tag) { | ||
| 189 | .driverkit, | ||
| 190 | .ios, | ||
| 191 | .maccatalyst, | ||
| 192 | .macos, | ||
| 193 | .tvos, | ||
| 194 | .visionos, | ||
| 195 | .watchos, | ||
| 196 | => "apple", | ||
| 197 | .ps4, | ||
| 198 | .ps5, | ||
| 199 | => "scei", | ||
| 200 | .amdhsa, | ||
| 201 | .amdpal, | ||
| 202 | => "amd", | ||
| 203 | .cuda, | ||
| 204 | .nvcl, | ||
| 205 | => "nvidia", | ||
| 206 | .mesa3d, | ||
| 207 | => "mesa", | ||
| 208 | else => "unknown", | ||
| 209 | }); | ||
| 210 | try llvm_triple.append('-'); | ||
| 211 | |||
| 212 | const llvm_os = switch (target.os.tag) { | ||
| 213 | .dragonfly => "dragonfly", | ||
| 214 | .freebsd => "freebsd", | ||
| 215 | .fuchsia => "fuchsia", | ||
| 216 | .linux => "linux", | ||
| 217 | .netbsd => "netbsd", | ||
| 218 | .openbsd => "openbsd", | ||
| 219 | .illumos => "solaris", | ||
| 220 | .windows, .uefi => "windows", | ||
| 221 | .haiku => "haiku", | ||
| 222 | .rtems => "rtems", | ||
| 223 | .cuda => "cuda", | ||
| 224 | .nvcl => "nvcl", | ||
| 225 | .amdhsa => "amdhsa", | ||
| 226 | .ps3 => "lv2", | ||
| 227 | .ps4 => "ps4", | ||
| 228 | .ps5 => "ps5", | ||
| 229 | .mesa3d => "mesa3d", | ||
| 230 | .amdpal => "amdpal", | ||
| 231 | .hermit => "hermit", | ||
| 232 | .hurd => "hurd", | ||
| 233 | .wasi => "wasi", | ||
| 234 | .emscripten => "emscripten", | ||
| 235 | .macos => "macosx", | ||
| 236 | .ios, .maccatalyst => "ios", | ||
| 237 | .tvos => "tvos", | ||
| 238 | .watchos => "watchos", | ||
| 239 | .driverkit => "driverkit", | ||
| 240 | .visionos => "xros", | ||
| 241 | .serenity => "serenity", | ||
| 242 | .vulkan => "vulkan", | ||
| 243 | .managarm => "managarm", | ||
| 244 | |||
| 245 | .contiki, | ||
| 246 | .freestanding, | ||
| 247 | .opencl, // https://llvm.org/docs/SPIRVUsage.html#target-triples | ||
| 248 | .opengl, | ||
| 249 | .other, | ||
| 250 | .plan9, | ||
| 251 | .psx, | ||
| 252 | .psp, | ||
| 253 | .vita, | ||
| 254 | .tios, | ||
| 255 | .@"3ds", | ||
| 256 | .wiiu, | ||
| 257 | .@"switch", | ||
| 258 | .ashetos, | ||
| 259 | => "unknown", | ||
| 260 | }; | ||
| 261 | try llvm_triple.appendSlice(llvm_os); | ||
| 262 | |||
| 263 | switch (target.os.versionRange()) { | ||
| 264 | .none, | ||
| 265 | .windows, | ||
| 266 | => {}, | ||
| 267 | .semver => |ver| if (target.os.tag == .wasi and ver.min.major == 0) { | ||
| 268 | try llvm_triple.print("p{d}", .{ver.min.minor}); | ||
| 269 | } else if (target.os.tag != .amdhsa) { | ||
| 270 | try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 271 | ver.min.major, | ||
| 272 | ver.min.minor, | ||
| 273 | ver.min.patch, | ||
| 274 | }); | ||
| 275 | }, | ||
| 276 | inline .linux, .hurd => |ver| try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 277 | ver.range.min.major, | ||
| 278 | ver.range.min.minor, | ||
| 279 | ver.range.min.patch, | ||
| 280 | }), | ||
| 281 | } | ||
| 282 | try llvm_triple.append('-'); | ||
| 283 | |||
| 284 | const llvm_abi = switch (target.abi) { | ||
| 285 | .none => if (target.os.tag == .maccatalyst) "macabi" else "unknown", | ||
| 286 | .gnu => "gnu", | ||
| 287 | .gnuabin32 => "gnuabin32", | ||
| 288 | .gnuabi64 => "gnuabi64", | ||
| 289 | .gnueabi => "gnueabi", | ||
| 290 | .gnueabihf => "gnueabihf", | ||
| 291 | .gnuf32 => "gnuf32", | ||
| 292 | .gnusf => "gnusf", | ||
| 293 | .gnux32 => "gnux32", | ||
| 294 | .ilp32 => "unknown", | ||
| 295 | .eabi => "eabi", | ||
| 296 | .eabihf => "eabihf", | ||
| 297 | .abin32 => "unknown", | ||
| 298 | .x32 => "muslx32", // https://github.com/ziglang/zig/issues/25649 | ||
| 299 | .android => "android", | ||
| 300 | .androideabi => "androideabi", | ||
| 301 | .musl => switch (target.os.tag) { | ||
| 302 | // For WASI/Emscripten, "musl" refers to the libc, not really the ABI. | ||
| 303 | // "unknown" provides better compatibility with LLVM-based tooling for these targets. | ||
| 304 | .wasi, .emscripten => "unknown", | ||
| 305 | else => "musl", | ||
| 306 | }, | ||
| 307 | .muslabin32 => "muslabin32", | ||
| 308 | .muslabi64 => "muslabi64", | ||
| 309 | .musleabi => "musleabi", | ||
| 310 | .musleabihf => "musleabihf", | ||
| 311 | .muslf32 => "muslf32", | ||
| 312 | .muslsf => "muslsf", | ||
| 313 | .muslx32 => "muslx32", | ||
| 314 | .msvc => "msvc", | ||
| 315 | .itanium => "itanium", | ||
| 316 | .simulator => "simulator", | ||
| 317 | .ohos, .ohoseabi => "ohos", | ||
| 318 | .call0 => "unknown", | ||
| 319 | }; | ||
| 320 | try llvm_triple.appendSlice(llvm_abi); | ||
| 321 | |||
| 322 | switch (target.os.versionRange()) { | ||
| 323 | .none, | ||
| 324 | .semver, | ||
| 325 | .windows, | ||
| 326 | => {}, | ||
| 327 | inline .hurd, .linux => |ver| if (target.abi.isGnu()) { | ||
| 328 | try llvm_triple.print("{d}.{d}.{d}", .{ | ||
| 329 | ver.glibc.major, | ||
| 330 | ver.glibc.minor, | ||
| 331 | ver.glibc.patch, | ||
| 332 | }); | ||
| 333 | } else if (@TypeOf(ver) == std.Target.Os.LinuxVersionRange and target.abi.isAndroid()) { | ||
| 334 | try llvm_triple.print("{d}", .{ver.android}); | ||
| 335 | }, | ||
| 336 | } | ||
| 337 | |||
| 338 | return llvm_triple.toOwnedSlice(); | ||
| 339 | } | ||
| 340 | |||
| 341 | pub fn supportsTailCall(target: *const std.Target) bool { | 49 | pub fn supportsTailCall(target: *const std.Target) bool { |
| 342 | return switch (target.cpu.arch) { | 50 | return switch (target.cpu.arch) { |
| 343 | .wasm32, .wasm64 => target.cpu.has(.wasm, .tail_call), | 51 | .wasm32, .wasm64 => target.cpu.has(.wasm, .tail_call), |
| ... | @@ -456,14 +164,12 @@ pub const Object = struct { | ... | @@ -456,14 +164,12 @@ pub const Object = struct { |
| 456 | const comp = zcu.comp; | 164 | const comp = zcu.comp; |
| 457 | const gpa = comp.gpa; | 165 | const gpa = comp.gpa; |
| 458 | const target = zcu.getTarget(); | 166 | const target = zcu.getTarget(); |
| 459 | const llvm_target_triple = try targetTriple(arena, target); | ||
| 460 | 167 | ||
| 461 | var builder = try Builder.init(.{ | 168 | var builder = try Builder.init(.{ |
| 462 | .allocator = gpa, | 169 | .allocator = gpa, |
| 463 | .strip = comp.config.debug_format == .strip, | 170 | .strip = comp.config.debug_format == .strip, |
| 464 | .name = comp.root_name, | 171 | .name = comp.root_name, |
| 465 | .target = target, | 172 | .target = target, |
| 466 | .triple = llvm_target_triple, | ||
| 467 | }); | 173 | }); |
| 468 | errdefer builder.deinit(); | 174 | errdefer builder.deinit(); |
| 469 | 175 |