Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2016 Andrew Kelley
3 : : *
4 : : * This file is part of zig, which is MIT licensed.
5 : : * See http://opensource.org/licenses/MIT
6 : : */
7 : :
8 : : #include "buffer.hpp"
9 : : #include "error.hpp"
10 : : #include "target.hpp"
11 : : #include "util.hpp"
12 : : #include "os.hpp"
13 : : #include "compiler.hpp"
14 : : #include "glibc.hpp"
15 : :
16 : : #include <stdio.h>
17 : :
18 : : static const SubArchList subarch_list_list[] = {
19 : : SubArchListNone,
20 : : SubArchListArm32,
21 : : SubArchListArm64,
22 : : SubArchListKalimba,
23 : : SubArchListMips,
24 : : };
25 : :
26 : : static const ZigLLVM_SubArchType subarch_list_arm32[] = {
27 : : ZigLLVM_ARMSubArch_v8_5a,
28 : : ZigLLVM_ARMSubArch_v8_4a,
29 : : ZigLLVM_ARMSubArch_v8_3a,
30 : : ZigLLVM_ARMSubArch_v8_2a,
31 : : ZigLLVM_ARMSubArch_v8_1a,
32 : : ZigLLVM_ARMSubArch_v8,
33 : : ZigLLVM_ARMSubArch_v8r,
34 : : ZigLLVM_ARMSubArch_v8m_baseline,
35 : : ZigLLVM_ARMSubArch_v8m_mainline,
36 : : ZigLLVM_ARMSubArch_v7,
37 : : ZigLLVM_ARMSubArch_v7em,
38 : : ZigLLVM_ARMSubArch_v7m,
39 : : ZigLLVM_ARMSubArch_v7s,
40 : : ZigLLVM_ARMSubArch_v7k,
41 : : ZigLLVM_ARMSubArch_v7ve,
42 : : ZigLLVM_ARMSubArch_v6,
43 : : ZigLLVM_ARMSubArch_v6m,
44 : : ZigLLVM_ARMSubArch_v6k,
45 : : ZigLLVM_ARMSubArch_v6t2,
46 : : ZigLLVM_ARMSubArch_v5,
47 : : ZigLLVM_ARMSubArch_v5te,
48 : : ZigLLVM_ARMSubArch_v4t,
49 : :
50 : : };
51 : :
52 : : static const ZigLLVM_SubArchType subarch_list_arm64[] = {
53 : : ZigLLVM_ARMSubArch_v8_5a,
54 : : ZigLLVM_ARMSubArch_v8_4a,
55 : : ZigLLVM_ARMSubArch_v8_3a,
56 : : ZigLLVM_ARMSubArch_v8_2a,
57 : : ZigLLVM_ARMSubArch_v8_1a,
58 : : ZigLLVM_ARMSubArch_v8,
59 : : ZigLLVM_ARMSubArch_v8r,
60 : : ZigLLVM_ARMSubArch_v8m_baseline,
61 : : ZigLLVM_ARMSubArch_v8m_mainline,
62 : : };
63 : :
64 : : static const ZigLLVM_SubArchType subarch_list_kalimba[] = {
65 : : ZigLLVM_KalimbaSubArch_v5,
66 : : ZigLLVM_KalimbaSubArch_v4,
67 : : ZigLLVM_KalimbaSubArch_v3,
68 : : };
69 : :
70 : : static const ZigLLVM_SubArchType subarch_list_mips[] = {
71 : : ZigLLVM_MipsSubArch_r6,
72 : : };
73 : :
74 : : static const ZigLLVM_ArchType arch_list[] = {
75 : : ZigLLVM_arm, // ARM (little endian): arm, armv.*, xscale
76 : : ZigLLVM_armeb, // ARM (big endian): armeb
77 : : ZigLLVM_aarch64, // AArch64 (little endian): aarch64
78 : : ZigLLVM_aarch64_be, // AArch64 (big endian): aarch64_be
79 : : ZigLLVM_arc, // ARC: Synopsys ARC
80 : : ZigLLVM_avr, // AVR: Atmel AVR microcontroller
81 : : ZigLLVM_bpfel, // eBPF or extended BPF or 64-bit BPF (little endian)
82 : : ZigLLVM_bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian)
83 : : ZigLLVM_hexagon, // Hexagon: hexagon
84 : : ZigLLVM_mips, // MIPS: mips, mipsallegrex, mipsr6
85 : : ZigLLVM_mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el
86 : : ZigLLVM_mips64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
87 : : ZigLLVM_mips64el, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
88 : : ZigLLVM_msp430, // MSP430: msp430
89 : : ZigLLVM_ppc, // PPC: powerpc
90 : : ZigLLVM_ppc64, // PPC64: powerpc64, ppu
91 : : ZigLLVM_ppc64le, // PPC64LE: powerpc64le
92 : : ZigLLVM_r600, // R600: AMD GPUs HD2XXX - HD6XXX
93 : : ZigLLVM_amdgcn, // AMDGCN: AMD GCN GPUs
94 : : ZigLLVM_riscv32, // RISC-V (32-bit): riscv32
95 : : ZigLLVM_riscv64, // RISC-V (64-bit): riscv64
96 : : ZigLLVM_sparc, // Sparc: sparc
97 : : ZigLLVM_sparcv9, // Sparcv9: Sparcv9
98 : : ZigLLVM_sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
99 : : ZigLLVM_systemz, // SystemZ: s390x
100 : : ZigLLVM_tce, // TCE (http://tce.cs.tut.fi/): tce
101 : : ZigLLVM_tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele
102 : : ZigLLVM_thumb, // Thumb (little endian): thumb, thumbv.*
103 : : ZigLLVM_thumbeb, // Thumb (big endian): thumbeb
104 : : ZigLLVM_x86, // X86: i[3-9]86
105 : : ZigLLVM_x86_64, // X86-64: amd64, x86_64
106 : : ZigLLVM_xcore, // XCore: xcore
107 : : ZigLLVM_nvptx, // NVPTX: 32-bit
108 : : ZigLLVM_nvptx64, // NVPTX: 64-bit
109 : : ZigLLVM_le32, // le32: generic little-endian 32-bit CPU (PNaCl)
110 : : ZigLLVM_le64, // le64: generic little-endian 64-bit CPU (PNaCl)
111 : : ZigLLVM_amdil, // AMDIL
112 : : ZigLLVM_amdil64, // AMDIL with 64-bit pointers
113 : : ZigLLVM_hsail, // AMD HSAIL
114 : : ZigLLVM_hsail64, // AMD HSAIL with 64-bit pointers
115 : : ZigLLVM_spir, // SPIR: standard portable IR for OpenCL 32-bit version
116 : : ZigLLVM_spir64, // SPIR: standard portable IR for OpenCL 64-bit version
117 : : ZigLLVM_kalimba, // Kalimba: generic kalimba
118 : : ZigLLVM_shave, // SHAVE: Movidius vector VLIW processors
119 : : ZigLLVM_lanai, // Lanai: Lanai 32-bit
120 : : ZigLLVM_wasm32, // WebAssembly with 32-bit pointers
121 : : ZigLLVM_wasm64, // WebAssembly with 64-bit pointers
122 : : ZigLLVM_renderscript32, // 32-bit RenderScript
123 : : ZigLLVM_renderscript64, // 64-bit RenderScript
124 : : };
125 : :
126 : : static const ZigLLVM_VendorType vendor_list[] = {
127 : : ZigLLVM_Apple,
128 : : ZigLLVM_PC,
129 : : ZigLLVM_SCEI,
130 : : ZigLLVM_BGP,
131 : : ZigLLVM_BGQ,
132 : : ZigLLVM_Freescale,
133 : : ZigLLVM_IBM,
134 : : ZigLLVM_ImaginationTechnologies,
135 : : ZigLLVM_MipsTechnologies,
136 : : ZigLLVM_NVIDIA,
137 : : ZigLLVM_CSR,
138 : : ZigLLVM_Myriad,
139 : : ZigLLVM_AMD,
140 : : ZigLLVM_Mesa,
141 : : ZigLLVM_SUSE,
142 : : };
143 : :
144 : : static const Os os_list[] = {
145 : : OsFreestanding,
146 : : OsAnanas,
147 : : OsCloudABI,
148 : : OsDragonFly,
149 : : OsFreeBSD,
150 : : OsFuchsia,
151 : : OsIOS,
152 : : OsKFreeBSD,
153 : : OsLinux,
154 : : OsLv2, // PS3
155 : : OsMacOSX,
156 : : OsNetBSD,
157 : : OsOpenBSD,
158 : : OsSolaris,
159 : : OsWindows,
160 : : OsHaiku,
161 : : OsMinix,
162 : : OsRTEMS,
163 : : OsNaCl, // Native Client
164 : : OsCNK, // BG/P Compute-Node Kernel
165 : : OsAIX,
166 : : OsCUDA, // NVIDIA CUDA
167 : : OsNVCL, // NVIDIA OpenCL
168 : : OsAMDHSA, // AMD HSA Runtime
169 : : OsPS4,
170 : : OsELFIAMCU,
171 : : OsTvOS, // Apple tvOS
172 : : OsWatchOS, // Apple watchOS
173 : : OsMesa3D,
174 : : OsContiki,
175 : : OsAMDPAL,
176 : : OsHermitCore,
177 : : OsHurd,
178 : : OsWASI,
179 : : OsZen,
180 : : OsUefi,
181 : : };
182 : :
183 : : // Coordinate with zig_llvm.h
184 : : static const ZigLLVM_EnvironmentType abi_list[] = {
185 : : ZigLLVM_UnknownEnvironment,
186 : :
187 : : ZigLLVM_GNU,
188 : : ZigLLVM_GNUABIN32,
189 : : ZigLLVM_GNUABI64,
190 : : ZigLLVM_GNUEABI,
191 : : ZigLLVM_GNUEABIHF,
192 : : ZigLLVM_GNUX32,
193 : : ZigLLVM_CODE16,
194 : : ZigLLVM_EABI,
195 : : ZigLLVM_EABIHF,
196 : : ZigLLVM_Android,
197 : : ZigLLVM_Musl,
198 : : ZigLLVM_MuslEABI,
199 : : ZigLLVM_MuslEABIHF,
200 : : ZigLLVM_MSVC,
201 : : ZigLLVM_Itanium,
202 : : ZigLLVM_Cygnus,
203 : : ZigLLVM_CoreCLR,
204 : : ZigLLVM_Simulator,
205 : : };
206 : :
207 : : static const ZigLLVM_ObjectFormatType oformat_list[] = {
208 : : ZigLLVM_UnknownObjectFormat,
209 : : ZigLLVM_COFF,
210 : : ZigLLVM_ELF,
211 : : ZigLLVM_MachO,
212 : : ZigLLVM_Wasm,
213 : : };
214 : :
215 : 13 : size_t target_oformat_count(void) {
216 : 13 : return array_length(oformat_list);
217 : : }
218 : :
219 : 65 : ZigLLVM_ObjectFormatType target_oformat_enum(size_t index) {
220 : 65 : assert(index < array_length(oformat_list));
221 : 65 : return oformat_list[index];
222 : : }
223 : :
224 : 65 : const char *target_oformat_name(ZigLLVM_ObjectFormatType oformat) {
225 [ + + + + : 65 : switch (oformat) {
+ - ]
226 : 13 : case ZigLLVM_UnknownObjectFormat: return "unknown";
227 : 13 : case ZigLLVM_COFF: return "coff";
228 : 13 : case ZigLLVM_ELF: return "elf";
229 : 13 : case ZigLLVM_MachO: return "macho";
230 : 13 : case ZigLLVM_Wasm: return "wasm";
231 : : }
232 : 0 : zig_unreachable();
233 : : }
234 : :
235 : 13 : size_t target_arch_count(void) {
236 : 13 : return array_length(arch_list);
237 : : }
238 : :
239 : 637 : ZigLLVM_ArchType target_arch_enum(size_t index) {
240 : 637 : assert(index < array_length(arch_list));
241 : 637 : return arch_list[index];
242 : : }
243 : :
244 : 0 : size_t target_vendor_count(void) {
245 : 0 : return array_length(vendor_list);
246 : : }
247 : :
248 : 0 : ZigLLVM_VendorType target_vendor_enum(size_t index) {
249 : 0 : assert(index < array_length(vendor_list));
250 : 0 : return vendor_list[index];
251 : : }
252 : :
253 : 13 : size_t target_os_count(void) {
254 : 13 : return array_length(os_list);
255 : : }
256 : 468 : Os target_os_enum(size_t index) {
257 : 468 : assert(index < array_length(os_list));
258 : 468 : return os_list[index];
259 : : }
260 : :
261 : 677 : ZigLLVM_OSType get_llvm_os_type(Os os_type) {
262 [ - + + + : 677 : switch (os_type) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
- ]
263 : 0 : case OsFreestanding:
264 : : case OsZen:
265 : 0 : return ZigLLVM_UnknownOS;
266 : 21 : case OsAnanas:
267 : 21 : return ZigLLVM_Ananas;
268 : 21 : case OsCloudABI:
269 : 21 : return ZigLLVM_CloudABI;
270 : 21 : case OsDragonFly:
271 : 21 : return ZigLLVM_DragonFly;
272 : 21 : case OsFreeBSD:
273 : 21 : return ZigLLVM_FreeBSD;
274 : 21 : case OsFuchsia:
275 : 21 : return ZigLLVM_Fuchsia;
276 : 21 : case OsIOS:
277 : 21 : return ZigLLVM_IOS;
278 : 21 : case OsKFreeBSD:
279 : 21 : return ZigLLVM_KFreeBSD;
280 : 156 : case OsLinux:
281 : 156 : return ZigLLVM_Linux;
282 : 21 : case OsLv2:
283 : 21 : return ZigLLVM_Lv2;
284 : 28 : case OsMacOSX:
285 : 28 : return ZigLLVM_MacOSX;
286 : 17 : case OsNetBSD:
287 : 17 : return ZigLLVM_NetBSD;
288 : 17 : case OsOpenBSD:
289 : 17 : return ZigLLVM_OpenBSD;
290 : 17 : case OsSolaris:
291 : 17 : return ZigLLVM_Solaris;
292 : 27 : case OsWindows:
293 : : case OsUefi:
294 : 27 : return ZigLLVM_Win32;
295 : 13 : case OsHaiku:
296 : 13 : return ZigLLVM_Haiku;
297 : 13 : case OsMinix:
298 : 13 : return ZigLLVM_Minix;
299 : 13 : case OsRTEMS:
300 : 13 : return ZigLLVM_RTEMS;
301 : 13 : case OsNaCl:
302 : 13 : return ZigLLVM_NaCl;
303 : 13 : case OsCNK:
304 : 13 : return ZigLLVM_CNK;
305 : 13 : case OsAIX:
306 : 13 : return ZigLLVM_AIX;
307 : 13 : case OsCUDA:
308 : 13 : return ZigLLVM_CUDA;
309 : 13 : case OsNVCL:
310 : 13 : return ZigLLVM_NVCL;
311 : 13 : case OsAMDHSA:
312 : 13 : return ZigLLVM_AMDHSA;
313 : 13 : case OsPS4:
314 : 13 : return ZigLLVM_PS4;
315 : 13 : case OsELFIAMCU:
316 : 13 : return ZigLLVM_ELFIAMCU;
317 : 13 : case OsTvOS:
318 : 13 : return ZigLLVM_TvOS;
319 : 13 : case OsWatchOS:
320 : 13 : return ZigLLVM_WatchOS;
321 : 13 : case OsMesa3D:
322 : 13 : return ZigLLVM_Mesa3D;
323 : 13 : case OsContiki:
324 : 13 : return ZigLLVM_Contiki;
325 : 13 : case OsAMDPAL:
326 : 13 : return ZigLLVM_AMDPAL;
327 : 13 : case OsHermitCore:
328 : 13 : return ZigLLVM_HermitCore;
329 : 13 : case OsHurd:
330 : 13 : return ZigLLVM_Hurd;
331 : 13 : case OsWASI:
332 : 13 : return ZigLLVM_WASI;
333 : : }
334 : 0 : zig_unreachable();
335 : : }
336 : :
337 : 26 : static Os get_zig_os_type(ZigLLVM_OSType os_type) {
338 [ - - - - : 26 : switch (os_type) {
- - - - +
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- ]
339 : 0 : case ZigLLVM_UnknownOS:
340 : 0 : return OsFreestanding;
341 : 0 : case ZigLLVM_Ananas:
342 : 0 : return OsAnanas;
343 : 0 : case ZigLLVM_CloudABI:
344 : 0 : return OsCloudABI;
345 : 0 : case ZigLLVM_DragonFly:
346 : 0 : return OsDragonFly;
347 : 0 : case ZigLLVM_FreeBSD:
348 : 0 : return OsFreeBSD;
349 : 0 : case ZigLLVM_Fuchsia:
350 : 0 : return OsFuchsia;
351 : 0 : case ZigLLVM_IOS:
352 : 0 : return OsIOS;
353 : 0 : case ZigLLVM_KFreeBSD:
354 : 0 : return OsKFreeBSD;
355 : 26 : case ZigLLVM_Linux:
356 : 26 : return OsLinux;
357 : 0 : case ZigLLVM_Lv2:
358 : 0 : return OsLv2;
359 : 0 : case ZigLLVM_Darwin:
360 : : case ZigLLVM_MacOSX:
361 : 0 : return OsMacOSX;
362 : 0 : case ZigLLVM_NetBSD:
363 : 0 : return OsNetBSD;
364 : 0 : case ZigLLVM_OpenBSD:
365 : 0 : return OsOpenBSD;
366 : 0 : case ZigLLVM_Solaris:
367 : 0 : return OsSolaris;
368 : 0 : case ZigLLVM_Win32:
369 : 0 : return OsWindows;
370 : 0 : case ZigLLVM_Haiku:
371 : 0 : return OsHaiku;
372 : 0 : case ZigLLVM_Minix:
373 : 0 : return OsMinix;
374 : 0 : case ZigLLVM_RTEMS:
375 : 0 : return OsRTEMS;
376 : 0 : case ZigLLVM_NaCl:
377 : 0 : return OsNaCl;
378 : 0 : case ZigLLVM_CNK:
379 : 0 : return OsCNK;
380 : 0 : case ZigLLVM_AIX:
381 : 0 : return OsAIX;
382 : 0 : case ZigLLVM_CUDA:
383 : 0 : return OsCUDA;
384 : 0 : case ZigLLVM_NVCL:
385 : 0 : return OsNVCL;
386 : 0 : case ZigLLVM_AMDHSA:
387 : 0 : return OsAMDHSA;
388 : 0 : case ZigLLVM_PS4:
389 : 0 : return OsPS4;
390 : 0 : case ZigLLVM_ELFIAMCU:
391 : 0 : return OsELFIAMCU;
392 : 0 : case ZigLLVM_TvOS:
393 : 0 : return OsTvOS;
394 : 0 : case ZigLLVM_WatchOS:
395 : 0 : return OsWatchOS;
396 : 0 : case ZigLLVM_Mesa3D:
397 : 0 : return OsMesa3D;
398 : 0 : case ZigLLVM_Contiki:
399 : 0 : return OsContiki;
400 : 0 : case ZigLLVM_AMDPAL:
401 : 0 : return OsAMDPAL;
402 : 0 : case ZigLLVM_HermitCore:
403 : 0 : return OsHermitCore;
404 : 0 : case ZigLLVM_Hurd:
405 : 0 : return OsHurd;
406 : 0 : case ZigLLVM_WASI:
407 : 0 : return OsWASI;
408 : : }
409 : 0 : zig_unreachable();
410 : : }
411 : :
412 : 634 : const char *target_os_name(Os os_type) {
413 [ + + + + : 634 : switch (os_type) {
- ]
414 : 21 : case OsFreestanding:
415 : 21 : return "freestanding";
416 : 13 : case OsZen:
417 : 13 : return "zen";
418 : 13 : case OsUefi:
419 : 13 : return "uefi";
420 : 587 : case OsAnanas:
421 : : case OsCloudABI:
422 : : case OsDragonFly:
423 : : case OsFreeBSD:
424 : : case OsFuchsia:
425 : : case OsIOS:
426 : : case OsKFreeBSD:
427 : : case OsLinux:
428 : : case OsLv2: // PS3
429 : : case OsMacOSX:
430 : : case OsNetBSD:
431 : : case OsOpenBSD:
432 : : case OsSolaris:
433 : : case OsWindows:
434 : : case OsHaiku:
435 : : case OsMinix:
436 : : case OsRTEMS:
437 : : case OsNaCl: // Native Client
438 : : case OsCNK: // BG/P Compute-Node Kernel
439 : : case OsAIX:
440 : : case OsCUDA: // NVIDIA CUDA
441 : : case OsNVCL: // NVIDIA OpenCL
442 : : case OsAMDHSA: // AMD HSA Runtime
443 : : case OsPS4:
444 : : case OsELFIAMCU:
445 : : case OsTvOS: // Apple tvOS
446 : : case OsWatchOS: // Apple watchOS
447 : : case OsMesa3D:
448 : : case OsContiki:
449 : : case OsAMDPAL:
450 : : case OsHermitCore:
451 : : case OsHurd:
452 : : case OsWASI:
453 : 587 : return ZigLLVMGetOSTypeName(get_llvm_os_type(os_type));
454 : : }
455 : 0 : zig_unreachable();
456 : : }
457 : :
458 : 13 : size_t target_abi_count(void) {
459 : 13 : return array_length(abi_list);
460 : : }
461 : 247 : ZigLLVM_EnvironmentType target_abi_enum(size_t index) {
462 : 247 : assert(index < array_length(abi_list));
463 : 247 : return abi_list[index];
464 : : }
465 : 553 : const char *target_abi_name(ZigLLVM_EnvironmentType abi) {
466 [ + + ]: 553 : if (abi == ZigLLVM_UnknownEnvironment)
467 : 71 : return "none";
468 : 482 : return ZigLLVMGetEnvironmentTypeName(abi);
469 : : }
470 : :
471 : 106 : Error target_parse_glibc_version(ZigGLibCVersion *glibc_ver, const char *text) {
472 : 106 : glibc_ver->major = 2;
473 : 106 : glibc_ver->minor = 0;
474 : 106 : glibc_ver->patch = 0;
475 : 106 : SplitIterator it = memSplit(str(text), str("GLIBC_."));
476 : : {
477 : 106 : Optional<Slice<uint8_t>> opt_component = SplitIterator_next(&it);
478 [ - + ]: 106 : if (!opt_component.is_some) return ErrorUnknownABI;
479 : 106 : glibc_ver->major = strtoul(buf_ptr(buf_create_from_slice(opt_component.value)), nullptr, 10);
480 : : }
481 : : {
482 : 106 : Optional<Slice<uint8_t>> opt_component = SplitIterator_next(&it);
483 [ - + ]: 106 : if (!opt_component.is_some) return ErrorNone;
484 : 106 : glibc_ver->minor = strtoul(buf_ptr(buf_create_from_slice(opt_component.value)), nullptr, 10);
485 : : }
486 : : {
487 : 106 : Optional<Slice<uint8_t>> opt_component = SplitIterator_next(&it);
488 [ + + ]: 106 : if (!opt_component.is_some) return ErrorNone;
489 : 24 : glibc_ver->patch = strtoul(buf_ptr(buf_create_from_slice(opt_component.value)), nullptr, 10);
490 : : }
491 : 106 : return ErrorNone;
492 : : }
493 : :
494 : 26 : void get_native_target(ZigTarget *target) {
495 : : // first zero initialize
496 : 26 : *target = {};
497 : :
498 : : ZigLLVM_OSType os_type;
499 : : ZigLLVM_ObjectFormatType oformat; // ignored; based on arch/os
500 : 26 : ZigLLVMGetNativeTarget(
501 : : &target->arch,
502 : : &target->sub_arch,
503 : : &target->vendor,
504 : : &os_type,
505 : : &target->abi,
506 : : &oformat);
507 : 26 : target->os = get_zig_os_type(os_type);
508 : 26 : target->is_native = true;
509 [ - + ]: 26 : if (target->abi == ZigLLVM_UnknownEnvironment) {
510 : 0 : target->abi = target_default_abi(target->arch, target->os);
511 : : }
512 [ + - ]: 26 : if (target_is_glibc(target)) {
513 : 26 : target->glibc_version = allocate<ZigGLibCVersion>(1);
514 : 26 : *target->glibc_version = {2, 17, 0};
515 : : #ifdef ZIG_OS_LINUX
516 : : Error err;
517 : 26 : if ((err = glibc_detect_native_version(target->glibc_version))) {
518 : : // Fall back to the default version.
519 : : }
520 : : #endif
521 : : }
522 : 26 : }
523 : :
524 : 58 : Error target_parse_archsub(ZigLLVM_ArchType *out_arch, ZigLLVM_SubArchType *out_sub,
525 : : const char *archsub_ptr, size_t archsub_len)
526 : : {
527 : 58 : *out_arch = ZigLLVM_UnknownArch;
528 : 58 : *out_sub = ZigLLVM_NoSubArch;
529 [ + + ]: 1530 : for (size_t arch_i = 0; arch_i < array_length(arch_list); arch_i += 1) {
530 : 1518 : ZigLLVM_ArchType arch = arch_list[arch_i];
531 : 1518 : SubArchList sub_arch_list = target_subarch_list(arch);
532 : 1518 : size_t subarch_count = target_subarch_count(sub_arch_list);
533 [ + + ]: 1518 : if (mem_eql_str(archsub_ptr, archsub_len, target_arch_name(arch))) {
534 : 58 : *out_arch = arch;
535 [ + + ]: 58 : if (subarch_count == 0) {
536 : 46 : return ErrorNone;
537 : : }
538 : : }
539 [ + + ]: 6248 : for (size_t sub_i = 0; sub_i < subarch_count; sub_i += 1) {
540 : 4776 : ZigLLVM_SubArchType sub = target_subarch_enum(sub_arch_list, sub_i);
541 : : char arch_name[64];
542 : 4776 : int n = sprintf(arch_name, "%s%s", target_arch_name(arch), target_subarch_name(sub));
543 [ - + ]: 4776 : if (mem_eql_mem(arch_name, n, archsub_ptr, archsub_len)) {
544 : 0 : *out_arch = arch;
545 : 0 : *out_sub = sub;
546 : 0 : return ErrorNone;
547 : : }
548 : : }
549 : : }
550 : 12 : return ErrorUnknownArchitecture;
551 : : }
552 : :
553 : 2155 : SubArchList target_subarch_list(ZigLLVM_ArchType arch) {
554 [ - + + + : 2155 : switch (arch) {
+ - ]
555 : 0 : case ZigLLVM_UnknownArch:
556 : 0 : zig_unreachable();
557 : 220 : case ZigLLVM_arm:
558 : : case ZigLLVM_armeb:
559 : : case ZigLLVM_thumb:
560 : : case ZigLLVM_thumbeb:
561 : 220 : return SubArchListArm32;
562 : :
563 : 142 : case ZigLLVM_aarch64:
564 : : case ZigLLVM_aarch64_be:
565 : 142 : return SubArchListArm64;
566 : :
567 : 25 : case ZigLLVM_kalimba:
568 : 25 : return SubArchListKalimba;
569 : :
570 : 1768 : case ZigLLVM_arc:
571 : : case ZigLLVM_avr:
572 : : case ZigLLVM_bpfel:
573 : : case ZigLLVM_bpfeb:
574 : : case ZigLLVM_hexagon:
575 : : case ZigLLVM_mips:
576 : : case ZigLLVM_mipsel:
577 : : case ZigLLVM_mips64:
578 : : case ZigLLVM_mips64el:
579 : : case ZigLLVM_msp430:
580 : : case ZigLLVM_ppc:
581 : : case ZigLLVM_ppc64:
582 : : case ZigLLVM_ppc64le:
583 : : case ZigLLVM_r600:
584 : : case ZigLLVM_amdgcn:
585 : : case ZigLLVM_riscv32:
586 : : case ZigLLVM_riscv64:
587 : : case ZigLLVM_sparc:
588 : : case ZigLLVM_sparcv9:
589 : : case ZigLLVM_sparcel:
590 : : case ZigLLVM_systemz:
591 : : case ZigLLVM_tce:
592 : : case ZigLLVM_tcele:
593 : : case ZigLLVM_x86:
594 : : case ZigLLVM_x86_64:
595 : : case ZigLLVM_xcore:
596 : : case ZigLLVM_nvptx:
597 : : case ZigLLVM_nvptx64:
598 : : case ZigLLVM_le32:
599 : : case ZigLLVM_le64:
600 : : case ZigLLVM_amdil:
601 : : case ZigLLVM_amdil64:
602 : : case ZigLLVM_hsail:
603 : : case ZigLLVM_hsail64:
604 : : case ZigLLVM_spir:
605 : : case ZigLLVM_spir64:
606 : : case ZigLLVM_shave:
607 : : case ZigLLVM_lanai:
608 : : case ZigLLVM_wasm32:
609 : : case ZigLLVM_wasm64:
610 : : case ZigLLVM_renderscript32:
611 : : case ZigLLVM_renderscript64:
612 : 1768 : return SubArchListNone;
613 : : }
614 : 0 : zig_unreachable();
615 : : }
616 : :
617 : 1570 : size_t target_subarch_count(SubArchList sub_arch_list) {
618 [ + + + + : 1570 : switch (sub_arch_list) {
+ - ]
619 : 1222 : case SubArchListNone:
620 : 1222 : return 0;
621 : 181 : case SubArchListArm32:
622 : 181 : return array_length(subarch_list_arm32);
623 : 129 : case SubArchListArm64:
624 : 129 : return array_length(subarch_list_arm64);
625 : 25 : case SubArchListKalimba:
626 : 25 : return array_length(subarch_list_kalimba);
627 : 13 : case SubArchListMips:
628 : 13 : return array_length(subarch_list_mips);
629 : : }
630 : 0 : zig_unreachable();
631 : : }
632 : :
633 : 5231 : ZigLLVM_SubArchType target_subarch_enum(SubArchList sub_arch_list, size_t i) {
634 [ - + + + : 5231 : switch (sub_arch_list) {
+ - ]
635 : 0 : case SubArchListNone:
636 : 0 : zig_unreachable();
637 : 3982 : case SubArchListArm32:
638 : 3982 : assert(i < array_length(subarch_list_arm32));
639 : 3982 : return subarch_list_arm32[i];
640 : 1161 : case SubArchListArm64:
641 : 1161 : assert(i < array_length(subarch_list_arm64));
642 : 1161 : return subarch_list_arm64[i];
643 : 75 : case SubArchListKalimba:
644 : 75 : assert(i < array_length(subarch_list_kalimba));
645 : 75 : return subarch_list_kalimba[i];
646 : 13 : case SubArchListMips:
647 : 13 : assert(i < array_length(subarch_list_mips));
648 : 13 : return subarch_list_mips[i];
649 : : }
650 : 0 : zig_unreachable();
651 : : }
652 : :
653 : 5231 : const char *target_subarch_name(ZigLLVM_SubArchType subarch) {
654 [ - + + + : 5231 : switch (subarch) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + - ]
655 : 0 : case ZigLLVM_NoSubArch:
656 : 0 : return "";
657 : 310 : case ZigLLVM_ARMSubArch_v8_5a:
658 : 310 : return "v8_5a";
659 : 310 : case ZigLLVM_ARMSubArch_v8_4a:
660 : 310 : return "v8_4a";
661 : 310 : case ZigLLVM_ARMSubArch_v8_3a:
662 : 310 : return "v8_3a";
663 : 310 : case ZigLLVM_ARMSubArch_v8_2a:
664 : 310 : return "v8_2a";
665 : 310 : case ZigLLVM_ARMSubArch_v8_1a:
666 : 310 : return "v8_1a";
667 : 310 : case ZigLLVM_ARMSubArch_v8:
668 : 310 : return "v8";
669 : 310 : case ZigLLVM_ARMSubArch_v8r:
670 : 310 : return "v8r";
671 : 310 : case ZigLLVM_ARMSubArch_v8m_baseline:
672 : 310 : return "v8m_baseline";
673 : 310 : case ZigLLVM_ARMSubArch_v8m_mainline:
674 : 310 : return "v8m_mainline";
675 : 181 : case ZigLLVM_ARMSubArch_v7:
676 : 181 : return "v7";
677 : 181 : case ZigLLVM_ARMSubArch_v7em:
678 : 181 : return "v7em";
679 : 181 : case ZigLLVM_ARMSubArch_v7m:
680 : 181 : return "v7m";
681 : 181 : case ZigLLVM_ARMSubArch_v7s:
682 : 181 : return "v7s";
683 : 181 : case ZigLLVM_ARMSubArch_v7k:
684 : 181 : return "v7k";
685 : 181 : case ZigLLVM_ARMSubArch_v7ve:
686 : 181 : return "v7ve";
687 : 181 : case ZigLLVM_ARMSubArch_v6:
688 : 181 : return "v6";
689 : 181 : case ZigLLVM_ARMSubArch_v6m:
690 : 181 : return "v6m";
691 : 181 : case ZigLLVM_ARMSubArch_v6k:
692 : 181 : return "v6k";
693 : 181 : case ZigLLVM_ARMSubArch_v6t2:
694 : 181 : return "v6t2";
695 : 181 : case ZigLLVM_ARMSubArch_v5:
696 : 181 : return "v5";
697 : 181 : case ZigLLVM_ARMSubArch_v5te:
698 : 181 : return "v5te";
699 : 181 : case ZigLLVM_ARMSubArch_v4t:
700 : 181 : return "v4t";
701 : 25 : case ZigLLVM_KalimbaSubArch_v3:
702 : 25 : return "v3";
703 : 25 : case ZigLLVM_KalimbaSubArch_v4:
704 : 25 : return "v4";
705 : 25 : case ZigLLVM_KalimbaSubArch_v5:
706 : 25 : return "v5";
707 : 13 : case ZigLLVM_MipsSubArch_r6:
708 : 13 : return "r6";
709 : : }
710 : 0 : zig_unreachable();
711 : : }
712 : :
713 : 13 : size_t target_subarch_list_count(void) {
714 : 13 : return array_length(subarch_list_list);
715 : : }
716 : :
717 : 52 : SubArchList target_subarch_list_enum(size_t index) {
718 : 52 : assert(index < array_length(subarch_list_list));
719 : 52 : return subarch_list_list[index];
720 : : }
721 : :
722 : 143 : const char *target_subarch_list_name(SubArchList sub_arch_list) {
723 [ - + + + : 143 : switch (sub_arch_list) {
+ - ]
724 : 0 : case SubArchListNone:
725 : 0 : return "None";
726 : 65 : case SubArchListArm32:
727 : 65 : return "Arm32";
728 : 39 : case SubArchListArm64:
729 : 39 : return "Arm64";
730 : 26 : case SubArchListKalimba:
731 : 26 : return "Kalimba";
732 : 13 : case SubArchListMips:
733 : 13 : return "Mips";
734 : : }
735 : 0 : zig_unreachable();
736 : : }
737 : :
738 : 8 : Error target_parse_os(Os *out_os, const char *os_ptr, size_t os_len) {
739 [ + - ]: 104 : for (size_t i = 0; i < array_length(os_list); i += 1) {
740 : 104 : Os os = os_list[i];
741 : 104 : const char *os_name = target_os_name(os);
742 [ + + ]: 104 : if (mem_eql_str(os_ptr, os_len, os_name)) {
743 : 8 : *out_os = os;
744 : 8 : return ErrorNone;
745 : : }
746 : : }
747 : 0 : return ErrorUnknownOperatingSystem;
748 : : }
749 : :
750 : 58 : Error target_parse_abi(ZigLLVM_EnvironmentType *out_abi, const char *abi_ptr, size_t abi_len) {
751 [ + - ]: 260 : for (size_t i = 0; i < array_length(abi_list); i += 1) {
752 : 260 : ZigLLVM_EnvironmentType abi = abi_list[i];
753 : 260 : const char *abi_name = target_abi_name(abi);
754 [ + + ]: 260 : if (mem_eql_str(abi_ptr, abi_len, abi_name)) {
755 : 58 : *out_abi = abi;
756 : 58 : return ErrorNone;
757 : : }
758 : : }
759 : 0 : return ErrorUnknownABI;
760 : : }
761 : :
762 : 8 : Error target_parse_triple(ZigTarget *target, const char *triple) {
763 : : Error err;
764 : :
765 : : // first initialize all to zero
766 : 8 : *target = {};
767 : :
768 : 8 : SplitIterator it = memSplit(str(triple), str("-"));
769 : :
770 : 8 : Optional<Slice<uint8_t>> opt_archsub = SplitIterator_next(&it);
771 : 8 : Optional<Slice<uint8_t>> opt_os = SplitIterator_next(&it);
772 : 8 : Optional<Slice<uint8_t>> opt_abi = SplitIterator_next(&it);
773 : :
774 [ - + ]: 8 : if (!opt_archsub.is_some)
775 : 0 : return ErrorMissingArchitecture;
776 : :
777 [ - + ]: 8 : if ((err = target_parse_archsub(&target->arch, &target->sub_arch,
778 : 8 : (char*)opt_archsub.value.ptr, opt_archsub.value.len)))
779 : : {
780 : 0 : return err;
781 : : }
782 : :
783 [ - + ]: 8 : if (!opt_os.is_some)
784 : 0 : return ErrorMissingOperatingSystem;
785 : :
786 [ - + ]: 8 : if ((err = target_parse_os(&target->os, (char*)opt_os.value.ptr, opt_os.value.len))) {
787 : 0 : return err;
788 : : }
789 : :
790 [ + - ]: 8 : if (opt_abi.is_some) {
791 [ - + ]: 8 : if ((err = target_parse_abi(&target->abi, (char*)opt_abi.value.ptr, opt_abi.value.len))) {
792 : 0 : return err;
793 : : }
794 : : } else {
795 : 0 : target->abi = target_default_abi(target->arch, target->os);
796 : : }
797 : 8 : return ErrorNone;
798 : : }
799 : :
800 : 7023 : const char *target_arch_name(ZigLLVM_ArchType arch) {
801 : 7023 : return ZigLLVMGetArchTypeName(arch);
802 : : }
803 : :
804 : 18 : void init_all_targets(void) {
805 : 18 : LLVMInitializeAllTargets();
806 : 18 : LLVMInitializeAllTargetInfos();
807 : 18 : LLVMInitializeAllTargetMCs();
808 : 18 : LLVMInitializeAllAsmPrinters();
809 : 18 : LLVMInitializeAllAsmParsers();
810 : 18 : }
811 : :
812 : 0 : void target_triple_zig(Buf *triple, const ZigTarget *target) {
813 : 0 : buf_resize(triple, 0);
814 : 0 : buf_appendf(triple, "%s%s-%s-%s",
815 : 0 : ZigLLVMGetArchTypeName(target->arch),
816 : 0 : ZigLLVMGetSubArchTypeName(target->sub_arch),
817 : 0 : ZigLLVMGetOSTypeName(get_llvm_os_type(target->os)),
818 : 0 : ZigLLVMGetEnvironmentTypeName(target->abi));
819 : 0 : }
820 : :
821 : 81 : void target_triple_llvm(Buf *triple, const ZigTarget *target) {
822 : 81 : buf_resize(triple, 0);
823 : 81 : buf_appendf(triple, "%s%s-%s-%s-%s",
824 : 81 : ZigLLVMGetArchTypeName(target->arch),
825 : 81 : ZigLLVMGetSubArchTypeName(target->sub_arch),
826 : 81 : ZigLLVMGetVendorTypeName(target->vendor),
827 : 81 : ZigLLVMGetOSTypeName(get_llvm_os_type(target->os)),
828 : 81 : ZigLLVMGetEnvironmentTypeName(target->abi));
829 : 81 : }
830 : :
831 : 1832 : bool target_os_is_darwin(Os os) {
832 [ + + ]: 1832 : switch (os) {
833 : 939 : case OsMacOSX:
834 : : case OsIOS:
835 : : case OsWatchOS:
836 : : case OsTvOS:
837 : 939 : return true;
838 : 893 : default:
839 : 893 : return false;
840 : : }
841 : : }
842 : :
843 : 120 : ZigLLVM_ObjectFormatType target_object_format(const ZigTarget *target) {
844 [ + - ][ + + ]: 120 : if (target->os == OsUefi || target->os == OsWindows) {
845 : 27 : return ZigLLVM_COFF;
846 [ + + ]: 93 : } else if (target_os_is_darwin(target->os)) {
847 : 22 : return ZigLLVM_MachO;
848 : : }
849 [ + - ][ - + ]: 71 : if (target->arch == ZigLLVM_wasm32 ||
850 : 71 : target->arch == ZigLLVM_wasm64)
851 : : {
852 : 0 : return ZigLLVM_Wasm;
853 : : }
854 : 71 : return ZigLLVM_ELF;
855 : : }
856 : :
857 : : // See lib/Support/Triple.cpp in LLVM for the source of this data.
858 : : // getArchPointerBitWidth
859 : 273 : uint32_t target_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
860 [ - - - + : 273 : switch (arch) {
- ]
861 : 0 : case ZigLLVM_UnknownArch:
862 : 0 : return 0;
863 : :
864 : 0 : case ZigLLVM_avr:
865 : : case ZigLLVM_msp430:
866 : 0 : return 16;
867 : :
868 : 0 : case ZigLLVM_arc:
869 : : case ZigLLVM_arm:
870 : : case ZigLLVM_armeb:
871 : : case ZigLLVM_hexagon:
872 : : case ZigLLVM_le32:
873 : : case ZigLLVM_mips:
874 : : case ZigLLVM_mipsel:
875 : : case ZigLLVM_nvptx:
876 : : case ZigLLVM_ppc:
877 : : case ZigLLVM_r600:
878 : : case ZigLLVM_riscv32:
879 : : case ZigLLVM_sparc:
880 : : case ZigLLVM_sparcel:
881 : : case ZigLLVM_tce:
882 : : case ZigLLVM_tcele:
883 : : case ZigLLVM_thumb:
884 : : case ZigLLVM_thumbeb:
885 : : case ZigLLVM_x86:
886 : : case ZigLLVM_xcore:
887 : : case ZigLLVM_amdil:
888 : : case ZigLLVM_hsail:
889 : : case ZigLLVM_spir:
890 : : case ZigLLVM_kalimba:
891 : : case ZigLLVM_lanai:
892 : : case ZigLLVM_shave:
893 : : case ZigLLVM_wasm32:
894 : : case ZigLLVM_renderscript32:
895 : 0 : return 32;
896 : :
897 : 273 : case ZigLLVM_aarch64:
898 : : case ZigLLVM_aarch64_be:
899 : : case ZigLLVM_amdgcn:
900 : : case ZigLLVM_bpfel:
901 : : case ZigLLVM_bpfeb:
902 : : case ZigLLVM_le64:
903 : : case ZigLLVM_mips64:
904 : : case ZigLLVM_mips64el:
905 : : case ZigLLVM_nvptx64:
906 : : case ZigLLVM_ppc64:
907 : : case ZigLLVM_ppc64le:
908 : : case ZigLLVM_riscv64:
909 : : case ZigLLVM_sparcv9:
910 : : case ZigLLVM_systemz:
911 : : case ZigLLVM_x86_64:
912 : : case ZigLLVM_amdil64:
913 : : case ZigLLVM_hsail64:
914 : : case ZigLLVM_spir64:
915 : : case ZigLLVM_wasm64:
916 : : case ZigLLVM_renderscript64:
917 : 273 : return 64;
918 : : }
919 : 0 : zig_unreachable();
920 : : }
921 : :
922 : 223 : uint32_t target_arch_largest_atomic_bits(ZigLLVM_ArchType arch) {
923 [ - - - - : 223 : switch (arch) {
+ - ]
924 : 0 : case ZigLLVM_UnknownArch:
925 : 0 : zig_unreachable();
926 : :
927 : 0 : case ZigLLVM_avr:
928 : : case ZigLLVM_msp430:
929 : 0 : return 16;
930 : :
931 : 0 : case ZigLLVM_arc:
932 : : case ZigLLVM_arm:
933 : : case ZigLLVM_armeb:
934 : : case ZigLLVM_hexagon:
935 : : case ZigLLVM_le32:
936 : : case ZigLLVM_mips:
937 : : case ZigLLVM_mipsel:
938 : : case ZigLLVM_nvptx:
939 : : case ZigLLVM_ppc:
940 : : case ZigLLVM_r600:
941 : : case ZigLLVM_riscv32:
942 : : case ZigLLVM_sparc:
943 : : case ZigLLVM_sparcel:
944 : : case ZigLLVM_tce:
945 : : case ZigLLVM_tcele:
946 : : case ZigLLVM_thumb:
947 : : case ZigLLVM_thumbeb:
948 : : case ZigLLVM_x86:
949 : : case ZigLLVM_xcore:
950 : : case ZigLLVM_amdil:
951 : : case ZigLLVM_hsail:
952 : : case ZigLLVM_spir:
953 : : case ZigLLVM_kalimba:
954 : : case ZigLLVM_lanai:
955 : : case ZigLLVM_shave:
956 : : case ZigLLVM_wasm32:
957 : : case ZigLLVM_renderscript32:
958 : 0 : return 32;
959 : :
960 : 0 : case ZigLLVM_aarch64:
961 : : case ZigLLVM_aarch64_be:
962 : : case ZigLLVM_amdgcn:
963 : : case ZigLLVM_bpfel:
964 : : case ZigLLVM_bpfeb:
965 : : case ZigLLVM_le64:
966 : : case ZigLLVM_mips64:
967 : : case ZigLLVM_mips64el:
968 : : case ZigLLVM_nvptx64:
969 : : case ZigLLVM_ppc64:
970 : : case ZigLLVM_ppc64le:
971 : : case ZigLLVM_riscv64:
972 : : case ZigLLVM_sparcv9:
973 : : case ZigLLVM_systemz:
974 : : case ZigLLVM_amdil64:
975 : : case ZigLLVM_hsail64:
976 : : case ZigLLVM_spir64:
977 : : case ZigLLVM_wasm64:
978 : : case ZigLLVM_renderscript64:
979 : 0 : return 64;
980 : :
981 : 223 : case ZigLLVM_x86_64:
982 : 223 : return 128;
983 : : }
984 : 0 : zig_unreachable();
985 : : }
986 : :
987 : 168 : uint32_t target_c_type_size_in_bits(const ZigTarget *target, CIntType id) {
988 [ - + + - : 168 : switch (target->os) {
- - ]
989 : 0 : case OsFreestanding:
990 [ # # ]: 0 : switch (target->arch) {
991 : 0 : case ZigLLVM_msp430:
992 [ # # # # : 0 : switch (id) {
# # ]
993 : 0 : case CIntTypeShort:
994 : : case CIntTypeUShort:
995 : 0 : return 16;
996 : 0 : case CIntTypeInt:
997 : : case CIntTypeUInt:
998 : 0 : return 16;
999 : 0 : case CIntTypeLong:
1000 : : case CIntTypeULong:
1001 : 0 : return 32;
1002 : 0 : case CIntTypeLongLong:
1003 : : case CIntTypeULongLong:
1004 : 0 : return 64;
1005 : 0 : case CIntTypeCount:
1006 : 0 : zig_unreachable();
1007 : : }
1008 : : default:
1009 [ # # # # : 0 : switch (id) {
# # ]
1010 : 0 : case CIntTypeShort:
1011 : : case CIntTypeUShort:
1012 : 0 : return 16;
1013 : 0 : case CIntTypeInt:
1014 : : case CIntTypeUInt:
1015 : 0 : return 32;
1016 : 0 : case CIntTypeLong:
1017 : : case CIntTypeULong:
1018 : 0 : return target_arch_pointer_bit_width(target->arch);
1019 : 0 : case CIntTypeLongLong:
1020 : : case CIntTypeULongLong:
1021 : 0 : return 64;
1022 : 0 : case CIntTypeCount:
1023 : 0 : zig_unreachable();
1024 : : }
1025 : : }
1026 : : case OsLinux:
1027 : : case OsMacOSX:
1028 : : case OsZen:
1029 : : case OsFreeBSD:
1030 : : case OsNetBSD:
1031 : : case OsOpenBSD:
1032 : : case OsWASI:
1033 [ + + + + : 136 : switch (id) {
- - ]
1034 : 34 : case CIntTypeShort:
1035 : : case CIntTypeUShort:
1036 : 34 : return 16;
1037 : 34 : case CIntTypeInt:
1038 : : case CIntTypeUInt:
1039 : 34 : return 32;
1040 : 34 : case CIntTypeLong:
1041 : : case CIntTypeULong:
1042 : 34 : return target_arch_pointer_bit_width(target->arch);
1043 : 34 : case CIntTypeLongLong:
1044 : : case CIntTypeULongLong:
1045 : 34 : return 64;
1046 : 0 : case CIntTypeCount:
1047 : 0 : zig_unreachable();
1048 : : }
1049 : : case OsUefi:
1050 : : case OsWindows:
1051 [ + + + - : 32 : switch (id) {
- ]
1052 : 8 : case CIntTypeShort:
1053 : : case CIntTypeUShort:
1054 : 8 : return 16;
1055 : 16 : case CIntTypeInt:
1056 : : case CIntTypeUInt:
1057 : : case CIntTypeLong:
1058 : : case CIntTypeULong:
1059 : 16 : return 32;
1060 : 8 : case CIntTypeLongLong:
1061 : : case CIntTypeULongLong:
1062 : 8 : return 64;
1063 : 0 : case CIntTypeCount:
1064 : 0 : zig_unreachable();
1065 : : }
1066 : : case OsIOS:
1067 [ # # # # : 0 : switch (id) {
# ]
1068 : 0 : case CIntTypeShort:
1069 : : case CIntTypeUShort:
1070 : 0 : return 16;
1071 : 0 : case CIntTypeInt:
1072 : : case CIntTypeUInt:
1073 : 0 : return 32;
1074 : 0 : case CIntTypeLong:
1075 : : case CIntTypeULong:
1076 : : case CIntTypeLongLong:
1077 : : case CIntTypeULongLong:
1078 : 0 : return 64;
1079 : 0 : case CIntTypeCount:
1080 : 0 : zig_unreachable();
1081 : : }
1082 : : case OsAnanas:
1083 : : case OsCloudABI:
1084 : : case OsDragonFly:
1085 : : case OsKFreeBSD:
1086 : : case OsLv2:
1087 : : case OsSolaris:
1088 : : case OsHaiku:
1089 : : case OsMinix:
1090 : : case OsRTEMS:
1091 : : case OsNaCl:
1092 : : case OsCNK:
1093 : : case OsAIX:
1094 : : case OsCUDA:
1095 : : case OsNVCL:
1096 : : case OsAMDHSA:
1097 : : case OsPS4:
1098 : : case OsELFIAMCU:
1099 : : case OsTvOS:
1100 : : case OsWatchOS:
1101 : : case OsMesa3D:
1102 : : case OsFuchsia:
1103 : : case OsContiki:
1104 : : case OsAMDPAL:
1105 : : case OsHermitCore:
1106 : : case OsHurd:
1107 : 0 : zig_panic("TODO c type size in bits for this target");
1108 : : }
1109 : 0 : zig_unreachable();
1110 : : }
1111 : :
1112 : 0 : bool target_allows_addr_zero(const ZigTarget *target) {
1113 : 0 : return target->os == OsFreestanding;
1114 : : }
1115 : :
1116 : 99 : const char *target_o_file_ext(const ZigTarget *target) {
1117 [ - + ][ + + ]: 190 : if (target->abi == ZigLLVM_MSVC ||
1118 [ + + ][ # # ]: 190 : (target->os == OsWindows && !target_abi_is_gnu(target->abi)) ||
[ - + ]
1119 : 91 : target->os == OsUefi) {
1120 : 8 : return ".obj";
1121 : : } else {
1122 : 91 : return ".o";
1123 : : }
1124 : : }
1125 : :
1126 : 0 : const char *target_asm_file_ext(const ZigTarget *target) {
1127 : 0 : return ".s";
1128 : : }
1129 : :
1130 : 0 : const char *target_llvm_ir_file_ext(const ZigTarget *target) {
1131 : 0 : return ".ll";
1132 : : }
1133 : :
1134 : 18 : const char *target_exe_file_ext(const ZigTarget *target) {
1135 [ + + ]: 18 : if (target->os == OsWindows) {
1136 : 4 : return ".exe";
1137 [ - + ]: 14 : } else if (target->os == OsUefi) {
1138 : 0 : return ".efi";
1139 [ - + ]: 14 : } else if (target_is_wasm(target)) {
1140 : 0 : return ".wasm";
1141 : : } else {
1142 : 14 : return "";
1143 : : }
1144 : : }
1145 : :
1146 : 23 : const char *target_lib_file_prefix(const ZigTarget *target) {
1147 [ - + ][ + - ]: 46 : if ((target->os == OsWindows && !target_abi_is_gnu(target->abi)) ||
[ + + ]
1148 [ + + - + ]: 46 : target->os == OsUefi ||
1149 : 19 : target_is_wasm(target))
1150 : : {
1151 : 4 : return "";
1152 : : } else {
1153 : 19 : return "lib";
1154 : : }
1155 : : }
1156 : :
1157 : 23 : const char *target_lib_file_ext(const ZigTarget *target, bool is_static,
1158 : : size_t version_major, size_t version_minor, size_t version_patch)
1159 : : {
1160 [ - + ]: 23 : if (target_is_wasm(target)) {
1161 : 0 : return ".wasm";
1162 : : }
1163 [ + + ][ - + ]: 23 : if (target->os == OsWindows || target->os == OsUefi) {
1164 [ + - ]: 4 : if (is_static) {
1165 [ + - ][ - + ]: 4 : if (target->os == OsWindows && target_abi_is_gnu(target->abi)) {
[ - + ]
1166 : 0 : return ".a";
1167 : : } else {
1168 : 4 : return ".lib";
1169 : : }
1170 : : } else {
1171 : 0 : return ".dll";
1172 : : }
1173 : : } else {
1174 [ + + ]: 19 : if (is_static) {
1175 : 14 : return ".a";
1176 [ - + ]: 5 : } else if (target_os_is_darwin(target->os)) {
1177 : 0 : return buf_ptr(buf_sprintf(".%" ZIG_PRI_usize ".%" ZIG_PRI_usize ".%" ZIG_PRI_usize ".dylib",
1178 : 0 : version_major, version_minor, version_patch));
1179 : : } else {
1180 : 5 : return buf_ptr(buf_sprintf(".so.%" ZIG_PRI_usize ".%" ZIG_PRI_usize ".%" ZIG_PRI_usize,
1181 : 5 : version_major, version_minor, version_patch));
1182 : : }
1183 : : }
1184 : : }
1185 : :
1186 : : enum FloatAbi {
1187 : : FloatAbiHard,
1188 : : FloatAbiSoft,
1189 : : FloatAbiSoftFp,
1190 : : };
1191 : :
1192 : 0 : static FloatAbi get_float_abi(const ZigTarget *target) {
1193 : 0 : const ZigLLVM_EnvironmentType env = target->abi;
1194 [ # # ][ # # ]: 0 : if (env == ZigLLVM_GNUEABIHF ||
1195 [ # # ]: 0 : env == ZigLLVM_EABIHF ||
1196 : : env == ZigLLVM_MuslEABIHF)
1197 : : {
1198 : 0 : return FloatAbiHard;
1199 : : } else {
1200 : 0 : return FloatAbiSoft;
1201 : : }
1202 : : }
1203 : :
1204 : 0 : static bool is_64_bit(ZigLLVM_ArchType arch) {
1205 : 0 : return target_arch_pointer_bit_width(arch) == 64;
1206 : : }
1207 : :
1208 : 12 : const char *target_dynamic_linker(const ZigTarget *target) {
1209 [ - - + + : 12 : switch (target->os) {
- - ]
1210 : 0 : case OsFreeBSD:
1211 : 0 : return "/libexec/ld-elf.so.1";
1212 : 0 : case OsNetBSD:
1213 : 0 : return "/libexec/ld.elf_so";
1214 : 4 : case OsLinux: {
1215 : 4 : const ZigLLVM_EnvironmentType abi = target->abi;
1216 [ - + ]: 4 : if (abi == ZigLLVM_Android) {
1217 [ # # ]: 0 : if (is_64_bit(target->arch)) {
1218 : 0 : return "/system/bin/linker64";
1219 : : } else {
1220 : 0 : return "/system/bin/linker";
1221 : : }
1222 : : }
1223 : :
1224 [ - - - - : 4 : switch (target->arch) {
- - - - -
- - - + -
- - - - ]
1225 : 0 : case ZigLLVM_UnknownArch:
1226 : 0 : zig_unreachable();
1227 : 0 : case ZigLLVM_x86:
1228 : : case ZigLLVM_sparc:
1229 : : case ZigLLVM_sparcel:
1230 : 0 : return "/lib/ld-linux.so.2";
1231 : :
1232 : 0 : case ZigLLVM_aarch64:
1233 : 0 : return "/lib/ld-linux-aarch64.so.1";
1234 : :
1235 : 0 : case ZigLLVM_aarch64_be:
1236 : 0 : return "/lib/ld-linux-aarch64_be.so.1";
1237 : :
1238 : 0 : case ZigLLVM_arm:
1239 : : case ZigLLVM_thumb:
1240 [ # # ]: 0 : if (get_float_abi(target) == FloatAbiHard) {
1241 : 0 : return "/lib/ld-linux-armhf.so.3";
1242 : : } else {
1243 : 0 : return "/lib/ld-linux.so.3";
1244 : : }
1245 : :
1246 : 0 : case ZigLLVM_armeb:
1247 : : case ZigLLVM_thumbeb:
1248 [ # # ]: 0 : if (get_float_abi(target) == FloatAbiHard) {
1249 : 0 : return "/lib/ld-linux-armhf.so.3";
1250 : : } else {
1251 : 0 : return "/lib/ld-linux.so.3";
1252 : : }
1253 : :
1254 : 0 : case ZigLLVM_mips:
1255 : : case ZigLLVM_mipsel:
1256 : : case ZigLLVM_mips64:
1257 : : case ZigLLVM_mips64el:
1258 : 0 : zig_panic("TODO implement target_dynamic_linker for mips");
1259 : :
1260 : 0 : case ZigLLVM_ppc:
1261 : 0 : return "/lib/ld.so.1";
1262 : :
1263 : 0 : case ZigLLVM_ppc64:
1264 : 0 : return "/lib64/ld64.so.2";
1265 : :
1266 : 0 : case ZigLLVM_ppc64le:
1267 : 0 : return "/lib64/ld64.so.2";
1268 : :
1269 : 0 : case ZigLLVM_systemz:
1270 : 0 : return "/lib64/ld64.so.1";
1271 : :
1272 : 0 : case ZigLLVM_sparcv9:
1273 : 0 : return "/lib64/ld-linux.so.2";
1274 : :
1275 : 4 : case ZigLLVM_x86_64:
1276 [ - + ]: 4 : if (abi == ZigLLVM_GNUX32) {
1277 : 0 : return "/libx32/ld-linux-x32.so.2";
1278 : : }
1279 [ + - ][ + - ]: 4 : if (abi == ZigLLVM_Musl || abi == ZigLLVM_MuslEABI || abi == ZigLLVM_MuslEABIHF) {
[ - + ]
1280 : 0 : return "/lib/ld-musl-x86_64.so.1";
1281 : : }
1282 : 4 : return "/lib64/ld-linux-x86-64.so.2";
1283 : :
1284 : 0 : case ZigLLVM_wasm32:
1285 : : case ZigLLVM_wasm64:
1286 : 0 : return nullptr;
1287 : :
1288 : 0 : case ZigLLVM_riscv32:
1289 : 0 : return "/lib/ld-linux-riscv32-ilp32.so.1";
1290 : 0 : case ZigLLVM_riscv64:
1291 : 0 : return "/lib/ld-linux-riscv64-lp64.so.1";
1292 : :
1293 : 0 : case ZigLLVM_arc:
1294 : : case ZigLLVM_avr:
1295 : : case ZigLLVM_bpfel:
1296 : : case ZigLLVM_bpfeb:
1297 : : case ZigLLVM_hexagon:
1298 : : case ZigLLVM_msp430:
1299 : : case ZigLLVM_r600:
1300 : : case ZigLLVM_amdgcn:
1301 : : case ZigLLVM_tce:
1302 : : case ZigLLVM_tcele:
1303 : : case ZigLLVM_xcore:
1304 : : case ZigLLVM_nvptx:
1305 : : case ZigLLVM_nvptx64:
1306 : : case ZigLLVM_le32:
1307 : : case ZigLLVM_le64:
1308 : : case ZigLLVM_amdil:
1309 : : case ZigLLVM_amdil64:
1310 : : case ZigLLVM_hsail:
1311 : : case ZigLLVM_hsail64:
1312 : : case ZigLLVM_spir:
1313 : : case ZigLLVM_spir64:
1314 : : case ZigLLVM_kalimba:
1315 : : case ZigLLVM_shave:
1316 : : case ZigLLVM_lanai:
1317 : : case ZigLLVM_renderscript32:
1318 : : case ZigLLVM_renderscript64:
1319 : 0 : zig_panic("TODO implement target_dynamic_linker for this arch");
1320 : : }
1321 : 0 : zig_unreachable();
1322 : : }
1323 : 8 : case OsFreestanding:
1324 : : case OsIOS:
1325 : : case OsTvOS:
1326 : : case OsWatchOS:
1327 : : case OsMacOSX:
1328 : : case OsUefi:
1329 : : case OsWindows:
1330 : 8 : return nullptr;
1331 : :
1332 : 0 : case OsAnanas:
1333 : : case OsCloudABI:
1334 : : case OsDragonFly:
1335 : : case OsFuchsia:
1336 : : case OsKFreeBSD:
1337 : : case OsLv2:
1338 : : case OsOpenBSD:
1339 : : case OsSolaris:
1340 : : case OsHaiku:
1341 : : case OsMinix:
1342 : : case OsRTEMS:
1343 : : case OsNaCl:
1344 : : case OsCNK:
1345 : : case OsAIX:
1346 : : case OsCUDA:
1347 : : case OsNVCL:
1348 : : case OsAMDHSA:
1349 : : case OsPS4:
1350 : : case OsELFIAMCU:
1351 : : case OsMesa3D:
1352 : : case OsContiki:
1353 : : case OsAMDPAL:
1354 : : case OsZen:
1355 : : case OsHermitCore:
1356 : : case OsHurd:
1357 : : case OsWASI:
1358 : 0 : zig_panic("TODO implement target_dynamic_linker for this OS");
1359 : : }
1360 : 0 : zig_unreachable();
1361 : : }
1362 : :
1363 : 16 : bool target_can_exec(const ZigTarget *host_target, const ZigTarget *guest_target) {
1364 : 16 : assert(host_target != nullptr);
1365 : :
1366 [ - + ]: 16 : if (guest_target == nullptr) {
1367 : : // null guest target means that the guest target is native
1368 : 0 : return true;
1369 : : }
1370 : :
1371 [ + + ][ + - ]: 16 : if (guest_target->os == host_target->os && guest_target->arch == host_target->arch &&
[ + - ]
1372 : 8 : guest_target->sub_arch == host_target->sub_arch)
1373 : : {
1374 : : // OS, arch, and sub-arch match
1375 : 8 : return true;
1376 : : }
1377 : :
1378 [ + + ][ - + ]: 8 : if (guest_target->os == OsWindows && host_target->os == OsWindows &&
[ # # ]
1379 [ # # ]: 0 : host_target->arch == ZigLLVM_x86_64 && guest_target->arch == ZigLLVM_x86)
1380 : : {
1381 : : // 64-bit windows can run 32-bit programs
1382 : 0 : return true;
1383 : : }
1384 : :
1385 : 8 : return false;
1386 : : }
1387 : :
1388 : 8 : const char *arch_stack_pointer_register_name(ZigLLVM_ArchType arch) {
1389 [ - - + - : 8 : switch (arch) {
- - ]
1390 : 0 : case ZigLLVM_UnknownArch:
1391 : 0 : zig_unreachable();
1392 : 0 : case ZigLLVM_x86:
1393 : 0 : return "esp";
1394 : 8 : case ZigLLVM_x86_64:
1395 : 8 : return "rsp";
1396 : 0 : case ZigLLVM_arm:
1397 : : case ZigLLVM_armeb:
1398 : : case ZigLLVM_thumb:
1399 : : case ZigLLVM_thumbeb:
1400 : : case ZigLLVM_aarch64:
1401 : : case ZigLLVM_aarch64_be:
1402 : 0 : return "sp";
1403 : :
1404 : 0 : case ZigLLVM_amdgcn:
1405 : : case ZigLLVM_amdil:
1406 : : case ZigLLVM_amdil64:
1407 : : case ZigLLVM_arc:
1408 : : case ZigLLVM_avr:
1409 : : case ZigLLVM_bpfeb:
1410 : : case ZigLLVM_bpfel:
1411 : : case ZigLLVM_hexagon:
1412 : : case ZigLLVM_lanai:
1413 : : case ZigLLVM_hsail:
1414 : : case ZigLLVM_hsail64:
1415 : : case ZigLLVM_kalimba:
1416 : : case ZigLLVM_le32:
1417 : : case ZigLLVM_le64:
1418 : : case ZigLLVM_mips:
1419 : : case ZigLLVM_mips64:
1420 : : case ZigLLVM_mips64el:
1421 : : case ZigLLVM_mipsel:
1422 : : case ZigLLVM_msp430:
1423 : : case ZigLLVM_nvptx:
1424 : : case ZigLLVM_nvptx64:
1425 : : case ZigLLVM_ppc64le:
1426 : : case ZigLLVM_r600:
1427 : : case ZigLLVM_renderscript32:
1428 : : case ZigLLVM_renderscript64:
1429 : : case ZigLLVM_riscv32:
1430 : : case ZigLLVM_riscv64:
1431 : : case ZigLLVM_shave:
1432 : : case ZigLLVM_sparc:
1433 : : case ZigLLVM_sparcel:
1434 : : case ZigLLVM_sparcv9:
1435 : : case ZigLLVM_spir:
1436 : : case ZigLLVM_spir64:
1437 : : case ZigLLVM_systemz:
1438 : : case ZigLLVM_tce:
1439 : : case ZigLLVM_tcele:
1440 : : case ZigLLVM_wasm32:
1441 : : case ZigLLVM_wasm64:
1442 : : case ZigLLVM_xcore:
1443 : : case ZigLLVM_ppc:
1444 : : case ZigLLVM_ppc64:
1445 : 0 : zig_panic("TODO populate this table with stack pointer register name for this CPU architecture");
1446 : : }
1447 : 0 : zig_unreachable();
1448 : : }
1449 : :
1450 : 0 : bool target_is_arm(const ZigTarget *target) {
1451 [ # # # # ]: 0 : switch (target->arch) {
1452 : 0 : case ZigLLVM_UnknownArch:
1453 : 0 : zig_unreachable();
1454 : 0 : case ZigLLVM_aarch64:
1455 : : case ZigLLVM_arm:
1456 : : case ZigLLVM_thumb:
1457 : : case ZigLLVM_aarch64_be:
1458 : : case ZigLLVM_armeb:
1459 : : case ZigLLVM_thumbeb:
1460 : 0 : return true;
1461 : :
1462 : 0 : case ZigLLVM_x86:
1463 : : case ZigLLVM_x86_64:
1464 : : case ZigLLVM_amdgcn:
1465 : : case ZigLLVM_amdil:
1466 : : case ZigLLVM_amdil64:
1467 : : case ZigLLVM_arc:
1468 : : case ZigLLVM_avr:
1469 : : case ZigLLVM_bpfeb:
1470 : : case ZigLLVM_bpfel:
1471 : : case ZigLLVM_hexagon:
1472 : : case ZigLLVM_lanai:
1473 : : case ZigLLVM_hsail:
1474 : : case ZigLLVM_hsail64:
1475 : : case ZigLLVM_kalimba:
1476 : : case ZigLLVM_le32:
1477 : : case ZigLLVM_le64:
1478 : : case ZigLLVM_mips:
1479 : : case ZigLLVM_mips64:
1480 : : case ZigLLVM_mips64el:
1481 : : case ZigLLVM_mipsel:
1482 : : case ZigLLVM_msp430:
1483 : : case ZigLLVM_nvptx:
1484 : : case ZigLLVM_nvptx64:
1485 : : case ZigLLVM_ppc64le:
1486 : : case ZigLLVM_r600:
1487 : : case ZigLLVM_renderscript32:
1488 : : case ZigLLVM_renderscript64:
1489 : : case ZigLLVM_riscv32:
1490 : : case ZigLLVM_riscv64:
1491 : : case ZigLLVM_shave:
1492 : : case ZigLLVM_sparc:
1493 : : case ZigLLVM_sparcel:
1494 : : case ZigLLVM_sparcv9:
1495 : : case ZigLLVM_spir:
1496 : : case ZigLLVM_spir64:
1497 : : case ZigLLVM_systemz:
1498 : : case ZigLLVM_tce:
1499 : : case ZigLLVM_tcele:
1500 : : case ZigLLVM_wasm32:
1501 : : case ZigLLVM_wasm64:
1502 : : case ZigLLVM_xcore:
1503 : : case ZigLLVM_ppc:
1504 : : case ZigLLVM_ppc64:
1505 : 0 : return false;
1506 : : }
1507 : 0 : zig_unreachable();
1508 : : }
1509 : :
1510 : : // Valgrind supports more, but Zig does not support them yet.
1511 : 2916 : bool target_has_valgrind_support(const ZigTarget *target) {
1512 [ - + - ]: 2916 : switch (target->arch) {
1513 : 0 : case ZigLLVM_UnknownArch:
1514 : 0 : zig_unreachable();
1515 : 2916 : case ZigLLVM_x86_64:
1516 [ + + ][ + + ]: 3321 : return (target->os == OsLinux || target_os_is_darwin(target->os) || target->os == OsSolaris ||
[ + - ][ + - ]
1517 [ - + ]: 3321 : (target->os == OsWindows && target->abi != ZigLLVM_MSVC));
1518 : 0 : default:
1519 : 0 : return false;
1520 : : }
1521 : : zig_unreachable();
1522 : : }
1523 : :
1524 : 283 : bool target_os_requires_libc(Os os) {
1525 : : // On Darwin, we always link libSystem which contains libc.
1526 : : // Similarly on FreeBSD and NetBSD we always link system libc
1527 : : // since this is the stable syscall interface.
1528 [ + + ][ + - ]: 283 : return (target_os_is_darwin(os) || os == OsFreeBSD || os == OsNetBSD);
[ - + ]
1529 : : }
1530 : :
1531 : 35 : bool target_supports_fpic(const ZigTarget *target) {
1532 : : // This is not whether the target supports Position Independent Code, but whether the -fPIC
1533 : : // C compiler argument is valid.
1534 : 35 : return target->os != OsWindows;
1535 : : }
1536 : :
1537 : 34 : bool target_supports_stack_probing(const ZigTarget *target) {
1538 [ + + ][ + - ]: 34 : return target->os != OsWindows && (target->arch == ZigLLVM_x86 || target->arch == ZigLLVM_x86_64);
[ + - ]
1539 : : }
1540 : :
1541 : 236 : bool target_requires_pic(const ZigTarget *target, bool linking_libc) {
1542 : : // This function returns whether non-pic code is completely invalid on the given target.
1543 [ + + ][ + + ]: 268 : return target->os == OsWindows || target_os_requires_libc(target->os) ||
[ + + ]
1544 [ + - ]: 268 : (linking_libc && target_is_glibc(target));
1545 : : }
1546 : :
1547 : 80 : bool target_is_glibc(const ZigTarget *target) {
1548 [ + + ][ + - ]: 80 : return target->os == OsLinux && target_abi_is_gnu(target->abi);
1549 : : }
1550 : :
1551 : 8 : bool target_is_musl(const ZigTarget *target) {
1552 [ + - ][ - + ]: 8 : return target->os == OsLinux && target_abi_is_musl(target->abi);
1553 : : }
1554 : :
1555 : 495 : bool target_is_wasm(const ZigTarget *target) {
1556 [ + - ][ - + ]: 495 : return target->arch == ZigLLVM_wasm32 || target->arch == ZigLLVM_wasm64;
1557 : : }
1558 : :
1559 : 120 : bool target_is_single_threaded(const ZigTarget *target) {
1560 : 120 : return target_is_wasm(target);
1561 : : }
1562 : :
1563 : 0 : ZigLLVM_EnvironmentType target_default_abi(ZigLLVM_ArchType arch, Os os) {
1564 [ # # ][ # # ]: 0 : if (arch == ZigLLVM_wasm32 || arch == ZigLLVM_wasm64) {
1565 : 0 : return ZigLLVM_Musl;
1566 : : }
1567 [ # # # # : 0 : switch (os) {
# ]
1568 : 0 : case OsFreestanding:
1569 : : case OsAnanas:
1570 : : case OsCloudABI:
1571 : : case OsDragonFly:
1572 : : case OsLv2:
1573 : : case OsSolaris:
1574 : : case OsHaiku:
1575 : : case OsMinix:
1576 : : case OsRTEMS:
1577 : : case OsNaCl:
1578 : : case OsCNK:
1579 : : case OsAIX:
1580 : : case OsCUDA:
1581 : : case OsNVCL:
1582 : : case OsAMDHSA:
1583 : : case OsPS4:
1584 : : case OsELFIAMCU:
1585 : : case OsMesa3D:
1586 : : case OsContiki:
1587 : : case OsAMDPAL:
1588 : : case OsZen:
1589 : : case OsHermitCore:
1590 : 0 : return ZigLLVM_EABI;
1591 : 0 : case OsOpenBSD:
1592 : : case OsMacOSX:
1593 : : case OsFreeBSD:
1594 : : case OsIOS:
1595 : : case OsTvOS:
1596 : : case OsWatchOS:
1597 : : case OsFuchsia:
1598 : : case OsKFreeBSD:
1599 : : case OsNetBSD:
1600 : : case OsHurd:
1601 : 0 : return ZigLLVM_GNU;
1602 : 0 : case OsUefi:
1603 : : case OsWindows:
1604 : 0 : return ZigLLVM_MSVC;
1605 : 0 : case OsLinux:
1606 : : case OsWASI:
1607 : 0 : return ZigLLVM_Musl;
1608 : : }
1609 : 0 : zig_unreachable();
1610 : : }
1611 : :
1612 : 158 : bool target_abi_is_gnu(ZigLLVM_EnvironmentType abi) {
1613 [ + + ]: 158 : switch (abi) {
1614 : 72 : case ZigLLVM_GNU:
1615 : : case ZigLLVM_GNUABIN32:
1616 : : case ZigLLVM_GNUABI64:
1617 : : case ZigLLVM_GNUEABI:
1618 : : case ZigLLVM_GNUEABIHF:
1619 : : case ZigLLVM_GNUX32:
1620 : 72 : return true;
1621 : 86 : default:
1622 : 86 : return false;
1623 : : }
1624 : : }
1625 : :
1626 : 86 : bool target_abi_is_musl(ZigLLVM_EnvironmentType abi) {
1627 [ - + ]: 86 : switch (abi) {
1628 : 0 : case ZigLLVM_Musl:
1629 : : case ZigLLVM_MuslEABI:
1630 : : case ZigLLVM_MuslEABIHF:
1631 : 0 : return true;
1632 : 86 : default:
1633 : 86 : return false;
1634 : : }
1635 : : }
1636 : :
1637 : : struct AvailableLibC {
1638 : : ZigLLVM_ArchType arch;
1639 : : Os os;
1640 : : ZigLLVM_EnvironmentType abi;
1641 : : };
1642 : :
1643 : : static const AvailableLibC libcs_available[] = {
1644 : : {ZigLLVM_aarch64_be, OsLinux, ZigLLVM_GNU},
1645 : : {ZigLLVM_aarch64_be, OsLinux, ZigLLVM_Musl},
1646 : : {ZigLLVM_aarch64_be, OsWindows, ZigLLVM_GNU},
1647 : : {ZigLLVM_aarch64, OsLinux, ZigLLVM_GNU},
1648 : : {ZigLLVM_aarch64, OsLinux, ZigLLVM_Musl},
1649 : : {ZigLLVM_aarch64, OsWindows, ZigLLVM_GNU},
1650 : : {ZigLLVM_armeb, OsLinux, ZigLLVM_GNUEABI},
1651 : : {ZigLLVM_armeb, OsLinux, ZigLLVM_GNUEABIHF},
1652 : : {ZigLLVM_armeb, OsLinux, ZigLLVM_MuslEABI},
1653 : : {ZigLLVM_armeb, OsLinux, ZigLLVM_MuslEABIHF},
1654 : : {ZigLLVM_armeb, OsWindows, ZigLLVM_GNU},
1655 : : {ZigLLVM_arm, OsLinux, ZigLLVM_GNUEABI},
1656 : : {ZigLLVM_arm, OsLinux, ZigLLVM_GNUEABIHF},
1657 : : {ZigLLVM_arm, OsLinux, ZigLLVM_MuslEABI},
1658 : : {ZigLLVM_arm, OsLinux, ZigLLVM_MuslEABIHF},
1659 : : {ZigLLVM_arm, OsWindows, ZigLLVM_GNU},
1660 : : {ZigLLVM_x86, OsLinux, ZigLLVM_GNU},
1661 : : {ZigLLVM_x86, OsLinux, ZigLLVM_Musl},
1662 : : {ZigLLVM_x86, OsWindows, ZigLLVM_GNU},
1663 : : {ZigLLVM_mips64el, OsLinux, ZigLLVM_GNUABI64},
1664 : : {ZigLLVM_mips64el, OsLinux, ZigLLVM_GNUABIN32},
1665 : : {ZigLLVM_mips64el, OsLinux, ZigLLVM_Musl},
1666 : : {ZigLLVM_mips64, OsLinux, ZigLLVM_GNUABI64},
1667 : : {ZigLLVM_mips64, OsLinux, ZigLLVM_GNUABIN32},
1668 : : {ZigLLVM_mips64, OsLinux, ZigLLVM_Musl},
1669 : : {ZigLLVM_mipsel, OsLinux, ZigLLVM_GNU},
1670 : : {ZigLLVM_mipsel, OsLinux, ZigLLVM_Musl},
1671 : : {ZigLLVM_mips, OsLinux, ZigLLVM_GNU},
1672 : : {ZigLLVM_mips, OsLinux, ZigLLVM_Musl},
1673 : : {ZigLLVM_ppc64le, OsLinux, ZigLLVM_GNU},
1674 : : {ZigLLVM_ppc64le, OsLinux, ZigLLVM_Musl},
1675 : : {ZigLLVM_ppc64, OsLinux, ZigLLVM_GNU},
1676 : : {ZigLLVM_ppc64, OsLinux, ZigLLVM_Musl},
1677 : : {ZigLLVM_ppc, OsLinux, ZigLLVM_GNU},
1678 : : {ZigLLVM_ppc, OsLinux, ZigLLVM_Musl},
1679 : : {ZigLLVM_riscv64, OsLinux, ZigLLVM_GNU},
1680 : : {ZigLLVM_riscv64, OsLinux, ZigLLVM_Musl},
1681 : : {ZigLLVM_systemz, OsLinux, ZigLLVM_GNU},
1682 : : {ZigLLVM_systemz, OsLinux, ZigLLVM_Musl},
1683 : : {ZigLLVM_sparc, OsLinux, ZigLLVM_GNU},
1684 : : {ZigLLVM_sparcv9, OsLinux, ZigLLVM_GNU},
1685 : : {ZigLLVM_wasm32, OsFreestanding, ZigLLVM_Musl},
1686 : : {ZigLLVM_x86_64, OsLinux, ZigLLVM_GNU},
1687 : : {ZigLLVM_x86_64, OsLinux, ZigLLVM_GNUX32},
1688 : : {ZigLLVM_x86_64, OsLinux, ZigLLVM_Musl},
1689 : : {ZigLLVM_x86_64, OsWindows, ZigLLVM_GNU},
1690 : : };
1691 : :
1692 : 14 : bool target_can_build_libc(const ZigTarget *target) {
1693 [ + + ]: 626 : for (size_t i = 0; i < array_length(libcs_available); i += 1) {
1694 [ + + ][ + + ]: 620 : if (target->arch == libcs_available[i].arch &&
1695 [ + - ]: 8 : target->os == libcs_available[i].os &&
1696 : 8 : target->abi == libcs_available[i].abi)
1697 : : {
1698 : 8 : return true;
1699 : : }
1700 : : }
1701 : 6 : return false;
1702 : : }
1703 : :
1704 : 8 : const char *target_libc_generic_name(const ZigTarget *target) {
1705 [ - + ]: 8 : if (target->os == OsWindows) {
1706 : 0 : return "mingw";
1707 : : }
1708 [ + - - - ]: 8 : switch (target->abi) {
1709 : 8 : case ZigLLVM_GNU:
1710 : : case ZigLLVM_GNUABIN32:
1711 : : case ZigLLVM_GNUABI64:
1712 : : case ZigLLVM_GNUEABI:
1713 : : case ZigLLVM_GNUEABIHF:
1714 : : case ZigLLVM_GNUX32:
1715 : 8 : return "glibc";
1716 : 0 : case ZigLLVM_Musl:
1717 : : case ZigLLVM_MuslEABI:
1718 : : case ZigLLVM_MuslEABIHF:
1719 : : case ZigLLVM_UnknownEnvironment:
1720 : 0 : return "musl";
1721 : 0 : case ZigLLVM_CODE16:
1722 : : case ZigLLVM_EABI:
1723 : : case ZigLLVM_EABIHF:
1724 : : case ZigLLVM_Android:
1725 : : case ZigLLVM_MSVC:
1726 : : case ZigLLVM_Itanium:
1727 : : case ZigLLVM_Cygnus:
1728 : : case ZigLLVM_CoreCLR:
1729 : : case ZigLLVM_Simulator:
1730 : 0 : zig_unreachable();
1731 : : }
1732 : 0 : zig_unreachable();
1733 : : }
1734 : :
1735 : 128 : bool target_is_libc_lib_name(const ZigTarget *target, const char *name) {
1736 [ + + ]: 128 : if (strcmp(name, "c") == 0)
1737 : 50 : return true;
1738 : :
1739 [ + - ][ + - ]: 78 : if (target_abi_is_gnu(target->abi) || target_abi_is_musl(target->abi) || target_os_is_darwin(target->os)) {
[ - + ][ - + ]
1740 [ # # ]: 0 : if (strcmp(name, "m") == 0)
1741 : 0 : return true;
1742 [ # # ]: 0 : if (strcmp(name, "rt") == 0)
1743 : 0 : return true;
1744 [ # # ]: 0 : if (strcmp(name, "pthread") == 0)
1745 : 0 : return true;
1746 [ # # ]: 0 : if (strcmp(name, "crypt") == 0)
1747 : 0 : return true;
1748 [ # # ]: 0 : if (strcmp(name, "util") == 0)
1749 : 0 : return true;
1750 [ # # ]: 0 : if (strcmp(name, "xnet") == 0)
1751 : 0 : return true;
1752 [ # # ]: 0 : if (strcmp(name, "resolv") == 0)
1753 : 0 : return true;
1754 [ # # ]: 0 : if (strcmp(name, "dl") == 0)
1755 : 0 : return true;
1756 : : }
1757 : :
1758 : 78 : return false;
1759 : : }
1760 : :
1761 : 0 : size_t target_libc_count(void) {
1762 : 0 : return array_length(libcs_available);
1763 : : }
1764 : :
1765 : 0 : void target_libc_enum(size_t index, ZigTarget *out_target) {
1766 : 0 : assert(index < array_length(libcs_available));
1767 : 0 : out_target->arch = libcs_available[index].arch;
1768 : 0 : out_target->os = libcs_available[index].os;
1769 : 0 : out_target->abi = libcs_available[index].abi;
1770 : 0 : out_target->sub_arch = ZigLLVM_NoSubArch;
1771 : 0 : out_target->vendor = ZigLLVM_UnknownVendor;
1772 : 0 : out_target->is_native = false;
1773 : 0 : }
1774 : :
1775 : 160 : bool target_has_debug_info(const ZigTarget *target) {
1776 : 160 : return !target_is_wasm(target);
1777 : : }
1778 : :
1779 : 0 : const char *target_arch_musl_name(ZigLLVM_ArchType arch) {
1780 [ # # # # : 0 : switch (arch) {
# # # # #
# # ]
1781 : 0 : case ZigLLVM_aarch64:
1782 : : case ZigLLVM_aarch64_be:
1783 : 0 : return "aarch64";
1784 : 0 : case ZigLLVM_arm:
1785 : : case ZigLLVM_armeb:
1786 : 0 : return "arm";
1787 : 0 : case ZigLLVM_mips:
1788 : : case ZigLLVM_mipsel:
1789 : 0 : return "mips";
1790 : 0 : case ZigLLVM_mips64el:
1791 : : case ZigLLVM_mips64:
1792 : 0 : return "mips64";
1793 : 0 : case ZigLLVM_ppc:
1794 : 0 : return "powerpc";
1795 : 0 : case ZigLLVM_ppc64:
1796 : : case ZigLLVM_ppc64le:
1797 : 0 : return "powerpc64";
1798 : 0 : case ZigLLVM_systemz:
1799 : 0 : return "s390x";
1800 : 0 : case ZigLLVM_x86:
1801 : 0 : return "i386";
1802 : 0 : case ZigLLVM_x86_64:
1803 : 0 : return "x86_64";
1804 : 0 : case ZigLLVM_riscv64:
1805 : 0 : return "riscv64";
1806 : 0 : default:
1807 : 0 : zig_unreachable();
1808 : : }
1809 : : }
1810 : :
1811 : 2 : bool target_supports_libunwind(const ZigTarget *target) {
1812 [ + - ][ - + ]: 2 : if (target->arch == ZigLLVM_arm || target->arch == ZigLLVM_armeb) {
1813 : 0 : return false;
1814 : : }
1815 : 2 : return true;
1816 : : }
1817 : :
1818 : :
1819 : 1088 : unsigned target_fn_align(const ZigTarget *target) {
1820 : 1088 : return 16;
1821 : : }
|
