1 //===--- Targets.cpp - Implement target feature support -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements construction of a TargetInfo object from a
10 // target triple.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "Targets.h"
15
16 #include "Targets/AArch64.h"
17 #include "Targets/AMDGPU.h"
18 #include "Targets/ARC.h"
19 #include "Targets/ARM.h"
20 #include "Targets/AVR.h"
21 #include "Targets/BPF.h"
22 #include "Targets/CSKY.h"
23 #include "Targets/DirectX.h"
24 #include "Targets/Hexagon.h"
25 #include "Targets/Lanai.h"
26 #include "Targets/LoongArch.h"
27 #include "Targets/M68k.h"
28 #include "Targets/MSP430.h"
29 #include "Targets/Mips.h"
30 #include "Targets/NVPTX.h"
31 #include "Targets/OSTargets.h"
32 #include "Targets/PNaCl.h"
33 #include "Targets/PPC.h"
34 #include "Targets/RISCV.h"
35 #include "Targets/SPIR.h"
36 #include "Targets/Sparc.h"
37 #include "Targets/SystemZ.h"
38 #include "Targets/TCE.h"
39 #include "Targets/VE.h"
40 #include "Targets/WebAssembly.h"
41 #include "Targets/X86.h"
42 #include "Targets/XCore.h"
43 #include "Targets/Xtensa.h"
44 #include "clang/Basic/Diagnostic.h"
45 #include "clang/Basic/DiagnosticFrontend.h"
46 #include "llvm/ADT/StringExtras.h"
47 #include "llvm/TargetParser/Triple.h"
48
49 using namespace clang;
50
51 namespace clang {
52 namespace targets {
53 //===----------------------------------------------------------------------===//
54 // Common code shared among targets.
55 //===----------------------------------------------------------------------===//
56
57 /// DefineStd - Define a macro name and standard variants. For example if
58 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
59 /// when in GNU mode.
DefineStd(MacroBuilder & Builder,StringRef MacroName,const LangOptions & Opts)60 void DefineStd(MacroBuilder &Builder, StringRef MacroName,
61 const LangOptions &Opts) {
62 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
63
64 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
65 // in the user's namespace.
66 if (Opts.GNUMode)
67 Builder.defineMacro(MacroName);
68
69 // Define __unix.
70 Builder.defineMacro("__" + MacroName);
71
72 // Define __unix__.
73 Builder.defineMacro("__" + MacroName + "__");
74 }
75
defineCPUMacros(MacroBuilder & Builder,StringRef CPUName,bool Tuning)76 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {
77 Builder.defineMacro("__" + CPUName);
78 Builder.defineMacro("__" + CPUName + "__");
79 if (Tuning)
80 Builder.defineMacro("__tune_" + CPUName + "__");
81 }
82
addCygMingDefines(const LangOptions & Opts,MacroBuilder & Builder)83 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
84 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
85 // supports __declspec natively under -fdeclspec (also enabled with
86 // -fms-extensions), but we define a no-op __declspec macro anyway for
87 // pre-processor compatibility.
88 if (Opts.DeclSpecKeyword)
89 Builder.defineMacro("__declspec", "__declspec");
90 else
91 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
92
93 if (!Opts.MicrosoftExt) {
94 // Provide macros for all the calling convention keywords. Provide both
95 // single and double underscore prefixed variants. These are available on
96 // x64 as well as x86, even though they have no effect.
97 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
98 for (const char *CC : CCs) {
99 std::string GCCSpelling = "__attribute__((__";
100 GCCSpelling += CC;
101 GCCSpelling += "__))";
102 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
103 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
104 }
105 }
106 }
107
108 //===----------------------------------------------------------------------===//
109 // Driver code
110 //===----------------------------------------------------------------------===//
111
AllocateTarget(const llvm::Triple & Triple,const TargetOptions & Opts)112 std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple,
113 const TargetOptions &Opts) {
114 llvm::Triple::OSType os = Triple.getOS();
115
116 switch (Triple.getArch()) {
117 default:
118 return nullptr;
119
120 case llvm::Triple::arc:
121 return std::make_unique<ARCTargetInfo>(Triple, Opts);
122
123 case llvm::Triple::xcore:
124 return std::make_unique<XCoreTargetInfo>(Triple, Opts);
125
126 case llvm::Triple::hexagon:
127 if (os == llvm::Triple::Linux &&
128 Triple.getEnvironment() == llvm::Triple::Musl)
129 return std::make_unique<LinuxTargetInfo<HexagonTargetInfo>>(Triple, Opts);
130 return std::make_unique<HexagonTargetInfo>(Triple, Opts);
131
132 case llvm::Triple::lanai:
133 return std::make_unique<LanaiTargetInfo>(Triple, Opts);
134
135 case llvm::Triple::aarch64_32:
136 if (Triple.isOSDarwin())
137 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);
138 else if (Triple.isAppleMachO())
139 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);
140
141 return nullptr;
142 case llvm::Triple::aarch64:
143 if (Triple.isOSDarwin())
144 return std::make_unique<DarwinAArch64TargetInfo>(Triple, Opts);
145 else if (Triple.isAppleMachO())
146 return std::make_unique<AppleMachOAArch64TargetInfo>(Triple, Opts);
147
148 switch (os) {
149 case llvm::Triple::FreeBSD:
150 return std::make_unique<FreeBSDTargetInfo<AArch64leTargetInfo>>(Triple,
151 Opts);
152 case llvm::Triple::Fuchsia:
153 return std::make_unique<FuchsiaTargetInfo<AArch64leTargetInfo>>(Triple,
154 Opts);
155 case llvm::Triple::Haiku:
156 return std::make_unique<HaikuTargetInfo<AArch64leTargetInfo>>(Triple,
157 Opts);
158 case llvm::Triple::Linux:
159 switch (Triple.getEnvironment()) {
160 default:
161 return std::make_unique<LinuxTargetInfo<AArch64leTargetInfo>>(Triple,
162 Opts);
163 case llvm::Triple::OpenHOS:
164 return std::make_unique<OHOSTargetInfo<AArch64leTargetInfo>>(Triple,
165 Opts);
166 }
167 case llvm::Triple::Managarm:
168 return std::make_unique<ManagarmTargetInfo<AArch64leTargetInfo>>(Triple,
169 Opts);
170 case llvm::Triple::NetBSD:
171 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple,
172 Opts);
173 case llvm::Triple::OpenBSD:
174 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple,
175 Opts);
176 case llvm::Triple::Win32:
177 switch (Triple.getEnvironment()) {
178 case llvm::Triple::GNU:
179 return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts);
180 case llvm::Triple::MSVC:
181 default: // Assume MSVC for unknown environments
182 return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts);
183 }
184 default:
185 return std::make_unique<AArch64leTargetInfo>(Triple, Opts);
186 }
187
188 case llvm::Triple::aarch64_be:
189 switch (os) {
190 case llvm::Triple::FreeBSD:
191 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple,
192 Opts);
193 case llvm::Triple::Fuchsia:
194 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple,
195 Opts);
196 case llvm::Triple::Linux:
197 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple,
198 Opts);
199 case llvm::Triple::NetBSD:
200 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple,
201 Opts);
202 default:
203 return std::make_unique<AArch64beTargetInfo>(Triple, Opts);
204 }
205
206 case llvm::Triple::arm:
207 case llvm::Triple::thumb:
208 if (Triple.isOSBinFormatMachO())
209 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);
210
211 switch (os) {
212 case llvm::Triple::Linux:
213 switch (Triple.getEnvironment()) {
214 default:
215 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts);
216 case llvm::Triple::OpenHOS:
217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
218 }
219 case llvm::Triple::LiteOS:
220 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
221 case llvm::Triple::FreeBSD:
222 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
223 case llvm::Triple::NetBSD:
224 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
225 case llvm::Triple::OpenBSD:
226 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
227 case llvm::Triple::RTEMS:
228 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
229 case llvm::Triple::Haiku:
230 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts);
231 case llvm::Triple::NaCl:
232 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(Triple, Opts);
233 case llvm::Triple::Win32:
234 switch (Triple.getEnvironment()) {
235 case llvm::Triple::Cygnus:
236 return std::make_unique<CygwinARMTargetInfo>(Triple, Opts);
237 case llvm::Triple::GNU:
238 return std::make_unique<MinGWARMTargetInfo>(Triple, Opts);
239 case llvm::Triple::Itanium:
240 return std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts);
241 case llvm::Triple::MSVC:
242 default: // Assume MSVC for unknown environments
243 return std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts);
244 }
245 default:
246 return std::make_unique<ARMleTargetInfo>(Triple, Opts);
247 }
248
249 case llvm::Triple::armeb:
250 case llvm::Triple::thumbeb:
251 if (Triple.isOSDarwin())
252 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);
253 else if (Triple.isAppleMachO())
254 return std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts);
255
256 switch (os) {
257 case llvm::Triple::Linux:
258 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
259 case llvm::Triple::NetBSD:
260 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
261 case llvm::Triple::RTEMS:
262 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
263 case llvm::Triple::NaCl:
264 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
265 default:
266 return std::make_unique<ARMbeTargetInfo>(Triple, Opts);
267 }
268
269 case llvm::Triple::avr:
270 return std::make_unique<AVRTargetInfo>(Triple, Opts);
271 case llvm::Triple::bpfeb:
272 case llvm::Triple::bpfel:
273 return std::make_unique<BPFTargetInfo>(Triple, Opts);
274
275 case llvm::Triple::msp430:
276 return std::make_unique<MSP430TargetInfo>(Triple, Opts);
277
278 case llvm::Triple::mips:
279 switch (os) {
280 case llvm::Triple::Linux:
281 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
282 case llvm::Triple::RTEMS:
283 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
284 case llvm::Triple::FreeBSD:
285 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
286 case llvm::Triple::NetBSD:
287 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
288 default:
289 return std::make_unique<MipsTargetInfo>(Triple, Opts);
290 }
291
292 case llvm::Triple::mipsel:
293 switch (os) {
294 case llvm::Triple::Linux:
295 switch (Triple.getEnvironment()) {
296 default:
297 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
298 case llvm::Triple::OpenHOS:
299 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts);
300 }
301 case llvm::Triple::RTEMS:
302 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
303 case llvm::Triple::FreeBSD:
304 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
305 case llvm::Triple::NetBSD:
306 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
307 case llvm::Triple::NaCl:
308 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(Triple,
309 Opts);
310 case llvm::Triple::Win32:
311 switch (Triple.getEnvironment()) {
312 case llvm::Triple::GNU:
313 return std::make_unique<MinGWMipsTargetInfo>(Triple, Opts);
314 case llvm::Triple::MSVC:
315 default: // Assume MSVC for unknown environments
316 return std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts);
317 }
318 default:
319 return std::make_unique<MipsTargetInfo>(Triple, Opts);
320 }
321
322 case llvm::Triple::mips64:
323 switch (os) {
324 case llvm::Triple::Linux:
325 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
326 case llvm::Triple::RTEMS:
327 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
328 case llvm::Triple::FreeBSD:
329 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
330 case llvm::Triple::NetBSD:
331 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
332 case llvm::Triple::OpenBSD:
333 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
334 default:
335 return std::make_unique<MipsTargetInfo>(Triple, Opts);
336 }
337
338 case llvm::Triple::mips64el:
339 switch (os) {
340 case llvm::Triple::Linux:
341 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
342 case llvm::Triple::RTEMS:
343 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
344 case llvm::Triple::FreeBSD:
345 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
346 case llvm::Triple::NetBSD:
347 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
348 case llvm::Triple::OpenBSD:
349 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
350 default:
351 return std::make_unique<MipsTargetInfo>(Triple, Opts);
352 }
353
354 case llvm::Triple::m68k:
355 switch (os) {
356 case llvm::Triple::Linux:
357 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts);
358 case llvm::Triple::NetBSD:
359 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts);
360 default:
361 return std::make_unique<M68kTargetInfo>(Triple, Opts);
362 }
363
364 case llvm::Triple::ppc:
365 switch (os) {
366 case llvm::Triple::Linux:
367 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
368 case llvm::Triple::FreeBSD:
369 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
370 case llvm::Triple::NetBSD:
371 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
372 case llvm::Triple::OpenBSD:
373 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
374 case llvm::Triple::RTEMS:
375 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts);
376 case llvm::Triple::AIX:
377 return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts);
378 default:
379 return std::make_unique<PPC32TargetInfo>(Triple, Opts);
380 }
381
382 case llvm::Triple::ppcle:
383 switch (os) {
384 case llvm::Triple::Linux:
385 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
386 case llvm::Triple::FreeBSD:
387 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
388 default:
389 return std::make_unique<PPC32TargetInfo>(Triple, Opts);
390 }
391
392 case llvm::Triple::ppc64:
393 switch (os) {
394 case llvm::Triple::Linux:
395 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
396 case llvm::Triple::Lv2:
397 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts);
398 case llvm::Triple::FreeBSD:
399 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
400 case llvm::Triple::NetBSD:
401 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
402 case llvm::Triple::OpenBSD:
403 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
404 case llvm::Triple::AIX:
405 return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts);
406 default:
407 return std::make_unique<PPC64TargetInfo>(Triple, Opts);
408 }
409
410 case llvm::Triple::ppc64le:
411 switch (os) {
412 case llvm::Triple::Linux:
413 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
414 case llvm::Triple::FreeBSD:
415 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
416 case llvm::Triple::NetBSD:
417 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
418 case llvm::Triple::OpenBSD:
419 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
420 default:
421 return std::make_unique<PPC64TargetInfo>(Triple, Opts);
422 }
423
424 case llvm::Triple::nvptx:
425 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
426 /*TargetPointerWidth=*/32);
427 case llvm::Triple::nvptx64:
428 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
429 /*TargetPointerWidth=*/64);
430
431 case llvm::Triple::amdgcn:
432 case llvm::Triple::r600:
433 return std::make_unique<AMDGPUTargetInfo>(Triple, Opts);
434
435 case llvm::Triple::riscv32:
436 switch (os) {
437 case llvm::Triple::NetBSD:
438 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple,
439 Opts);
440 case llvm::Triple::Linux:
441 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts);
442 default:
443 return std::make_unique<RISCV32TargetInfo>(Triple, Opts);
444 }
445
446 case llvm::Triple::riscv64:
447 switch (os) {
448 case llvm::Triple::FreeBSD:
449 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple,
450 Opts);
451 case llvm::Triple::NetBSD:
452 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple,
453 Opts);
454 case llvm::Triple::OpenBSD:
455 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple,
456 Opts);
457 case llvm::Triple::Fuchsia:
458 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple,
459 Opts);
460 case llvm::Triple::Haiku:
461 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple,
462 Opts);
463 case llvm::Triple::Linux:
464 switch (Triple.getEnvironment()) {
465 default:
466 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple,
467 Opts);
468 case llvm::Triple::OpenHOS:
469 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple,
470 Opts);
471 }
472 case llvm::Triple::Managarm:
473 return std::make_unique<ManagarmTargetInfo<RISCV64TargetInfo>>(Triple,
474 Opts);
475 default:
476 return std::make_unique<RISCV64TargetInfo>(Triple, Opts);
477 }
478
479 case llvm::Triple::sparc:
480 switch (os) {
481 case llvm::Triple::Linux:
482 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
483 case llvm::Triple::Solaris:
484 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple,
485 Opts);
486 case llvm::Triple::NetBSD:
487 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple,
488 Opts);
489 case llvm::Triple::RTEMS:
490 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
491 default:
492 return std::make_unique<SparcV8TargetInfo>(Triple, Opts);
493 }
494
495 case llvm::Triple::sparcel:
496 switch (os) {
497 case llvm::Triple::Linux:
498 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple,
499 Opts);
500 case llvm::Triple::RTEMS:
501 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple,
502 Opts);
503 default:
504 return std::make_unique<SparcV8elTargetInfo>(Triple, Opts);
505 }
506
507 case llvm::Triple::sparcv9:
508 switch (os) {
509 case llvm::Triple::Linux:
510 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts);
511 case llvm::Triple::Solaris:
512 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple,
513 Opts);
514 case llvm::Triple::NetBSD:
515 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple,
516 Opts);
517 case llvm::Triple::OpenBSD:
518 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple,
519 Opts);
520 case llvm::Triple::FreeBSD:
521 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple,
522 Opts);
523 default:
524 return std::make_unique<SparcV9TargetInfo>(Triple, Opts);
525 }
526
527 case llvm::Triple::systemz:
528 switch (os) {
529 case llvm::Triple::Linux:
530 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts);
531 case llvm::Triple::ZOS:
532 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts);
533 default:
534 return std::make_unique<SystemZTargetInfo>(Triple, Opts);
535 }
536
537 case llvm::Triple::tce:
538 return std::make_unique<TCETargetInfo>(Triple, Opts);
539
540 case llvm::Triple::tcele:
541 return std::make_unique<TCELETargetInfo>(Triple, Opts);
542
543 case llvm::Triple::x86:
544 if (Triple.isOSDarwin())
545 return std::make_unique<DarwinI386TargetInfo>(Triple, Opts);
546 else if (Triple.isAppleMachO())
547 return std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts);
548
549 switch (os) {
550 case llvm::Triple::Linux: {
551 switch (Triple.getEnvironment()) {
552 default:
553 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple,
554 Opts);
555 case llvm::Triple::Android:
556 return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts);
557 }
558 }
559 case llvm::Triple::DragonFly:
560 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple,
561 Opts);
562 case llvm::Triple::NetBSD:
563 return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts);
564 case llvm::Triple::OpenBSD:
565 return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts);
566 case llvm::Triple::FreeBSD:
567 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
568 Opts);
569 case llvm::Triple::Fuchsia:
570 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple,
571 Opts);
572 case llvm::Triple::KFreeBSD:
573 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
574 Opts);
575 case llvm::Triple::Solaris:
576 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple,
577 Opts);
578 case llvm::Triple::Win32: {
579 switch (Triple.getEnvironment()) {
580 case llvm::Triple::Cygnus:
581 return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts);
582 case llvm::Triple::GNU:
583 return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts);
584 case llvm::Triple::Itanium:
585 case llvm::Triple::MSVC:
586 default: // Assume MSVC for unknown environments
587 return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts);
588 }
589 }
590 case llvm::Triple::Haiku:
591 return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts);
592 case llvm::Triple::RTEMS:
593 return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);
594 case llvm::Triple::NaCl:
595 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts);
596 case llvm::Triple::ELFIAMCU:
597 return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);
598 case llvm::Triple::Hurd:
599 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);
600 default:
601 return std::make_unique<X86_32TargetInfo>(Triple, Opts);
602 }
603
604 case llvm::Triple::x86_64:
605 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
606 return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);
607
608 switch (os) {
609 case llvm::Triple::Linux: {
610 switch (Triple.getEnvironment()) {
611 default:
612 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple,
613 Opts);
614 case llvm::Triple::Android:
615 return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts);
616 case llvm::Triple::OpenHOS:
617 return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts);
618 }
619 }
620 case llvm::Triple::DragonFly:
621 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple,
622 Opts);
623 case llvm::Triple::NetBSD:
624 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts);
625 case llvm::Triple::OpenBSD:
626 return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts);
627 case llvm::Triple::FreeBSD:
628 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
629 Opts);
630 case llvm::Triple::Fuchsia:
631 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple,
632 Opts);
633 case llvm::Triple::KFreeBSD:
634 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
635 Opts);
636 case llvm::Triple::Solaris:
637 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple,
638 Opts);
639 case llvm::Triple::UEFI:
640 return std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts);
641
642 case llvm::Triple::Win32: {
643 switch (Triple.getEnvironment()) {
644 case llvm::Triple::Cygnus:
645 return std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts);
646 case llvm::Triple::GNU:
647 return std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts);
648 case llvm::Triple::MSVC:
649 default: // Assume MSVC for unknown environments
650 return std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts);
651 }
652 }
653 case llvm::Triple::Haiku:
654 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts);
655 case llvm::Triple::NaCl:
656 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts);
657 case llvm::Triple::PS4:
658 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
659 case llvm::Triple::PS5:
660 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
661 case llvm::Triple::Hurd:
662 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts);
663 case llvm::Triple::Managarm:
664 return std::make_unique<ManagarmTargetInfo<X86_64TargetInfo>>(Triple,
665 Opts);
666 default:
667 return std::make_unique<X86_64TargetInfo>(Triple, Opts);
668 }
669
670 case llvm::Triple::spir: {
671 if (os != llvm::Triple::UnknownOS ||
672 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
673 return nullptr;
674 return std::make_unique<SPIR32TargetInfo>(Triple, Opts);
675 }
676 case llvm::Triple::spir64: {
677 if (os != llvm::Triple::UnknownOS ||
678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
679 return nullptr;
680 return std::make_unique<SPIR64TargetInfo>(Triple, Opts);
681 }
682 case llvm::Triple::spirv: {
683 return std::make_unique<SPIRVTargetInfo>(Triple, Opts);
684 }
685 case llvm::Triple::spirv32: {
686 if (os != llvm::Triple::UnknownOS ||
687 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
688 return nullptr;
689 return std::make_unique<SPIRV32TargetInfo>(Triple, Opts);
690 }
691 case llvm::Triple::spirv64: {
692 if (os != llvm::Triple::UnknownOS ||
693 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {
694 if (os == llvm::Triple::OSType::AMDHSA)
695 return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts);
696 return nullptr;
697 }
698 return std::make_unique<SPIRV64TargetInfo>(Triple, Opts);
699 }
700 case llvm::Triple::wasm32:
701 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
702 Triple.getVendor() != llvm::Triple::UnknownVendor ||
703 !Triple.isOSBinFormatWasm())
704 return nullptr;
705 switch (os) {
706 case llvm::Triple::WASI:
707 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple,
708 Opts);
709 case llvm::Triple::Emscripten:
710 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(
711 Triple, Opts);
712 case llvm::Triple::UnknownOS:
713 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(
714 Triple, Opts);
715 default:
716 return nullptr;
717 }
718 case llvm::Triple::wasm64:
719 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
720 Triple.getVendor() != llvm::Triple::UnknownVendor ||
721 !Triple.isOSBinFormatWasm())
722 return nullptr;
723 switch (os) {
724 case llvm::Triple::WASI:
725 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple,
726 Opts);
727 case llvm::Triple::Emscripten:
728 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(
729 Triple, Opts);
730 case llvm::Triple::UnknownOS:
731 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(
732 Triple, Opts);
733 default:
734 return nullptr;
735 }
736
737 case llvm::Triple::dxil:
738 return std::make_unique<DirectXTargetInfo>(Triple, Opts);
739
740 case llvm::Triple::ve:
741 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts);
742
743 case llvm::Triple::csky:
744 switch (os) {
745 case llvm::Triple::Linux:
746 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts);
747 default:
748 return std::make_unique<CSKYTargetInfo>(Triple, Opts);
749 }
750 case llvm::Triple::loongarch32:
751 switch (os) {
752 case llvm::Triple::Linux:
753 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,
754 Opts);
755 default:
756 return std::make_unique<LoongArch32TargetInfo>(Triple, Opts);
757 }
758 case llvm::Triple::loongarch64:
759 switch (os) {
760 case llvm::Triple::Linux:
761 switch (Triple.getEnvironment()) {
762 default:
763 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,
764 Opts);
765 case llvm::Triple::OpenHOS:
766 return std::make_unique<OHOSTargetInfo<LoongArch64TargetInfo>>(Triple,
767 Opts);
768 }
769 case llvm::Triple::FreeBSD:
770 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple,
771 Opts);
772 case llvm::Triple::OpenBSD:
773 return std::make_unique<OpenBSDTargetInfo<LoongArch64TargetInfo>>(Triple,
774 Opts);
775 default:
776 return std::make_unique<LoongArch64TargetInfo>(Triple, Opts);
777 }
778
779 case llvm::Triple::xtensa:
780 return std::make_unique<XtensaTargetInfo>(Triple, Opts);
781 }
782 }
783 } // namespace targets
784 } // namespace clang
785
786 using namespace clang::targets;
787 /// CreateTargetInfo - Return the target info object for the specified target
788 /// options.
CreateTargetInfo(DiagnosticsEngine & Diags,TargetOptions & OptsRef)789 TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
790 TargetOptions &OptsRef) {
791 TargetOptions *Opts = &OptsRef;
792
793 llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple));
794
795 // Construct the target
796 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts);
797 if (!Target) {
798 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
799 return nullptr;
800 }
801 Target->TargetOpts = Opts;
802
803 // Set the target CPU if specified.
804 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
805 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
806 SmallVector<StringRef, 32> ValidList;
807 Target->fillValidCPUList(ValidList);
808 if (!ValidList.empty())
809 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
810 return nullptr;
811 }
812
813 // Check the TuneCPU name if specified.
814 if (!Opts->TuneCPU.empty() &&
815 !Target->isValidTuneCPUName(Opts->TuneCPU)) {
816 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;
817 SmallVector<StringRef, 32> ValidList;
818 Target->fillValidTuneCPUList(ValidList);
819 if (!ValidList.empty())
820 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
821 return nullptr;
822 }
823
824 // Set the target ABI if specified.
825 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
826 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
827 return nullptr;
828 }
829
830 // Set the fp math unit.
831 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
832 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
833 return nullptr;
834 }
835
836 // Compute the default target features, we need the target to handle this
837 // because features may have dependencies on one another.
838 llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) {
839 if (Target->isReadOnlyFeature(Name.substr(1))) {
840 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;
841 return true;
842 }
843 return false;
844 });
845 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,
846 Opts->FeaturesAsWritten))
847 return nullptr;
848
849 // Add the features to the compile options.
850 Opts->Features.clear();
851 for (const auto &F : Opts->FeatureMap)
852 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
853 // Sort here, so we handle the features in a predictable order. (This matters
854 // when we're dealing with features that overlap.)
855 llvm::sort(Opts->Features);
856
857 if (!Target->handleTargetFeatures(Opts->Features, Diags))
858 return nullptr;
859
860 Target->setSupportedOpenCLOpts();
861 Target->setCommandLineOpenCLOpts();
862 Target->setMaxAtomicWidth();
863
864 if (!Opts->DarwinTargetVariantTriple.empty())
865 Target->DarwinTargetVariantTriple =
866 llvm::Triple(Opts->DarwinTargetVariantTriple);
867
868 if (!Target->validateTarget(Diags))
869 return nullptr;
870
871 Target->CheckFixedPointBits();
872
873 return Target.release();
874 }
875 /// validateOpenCLTarget - Check that OpenCL target has valid
876 /// options setting based on OpenCL version.
validateOpenCLTarget(const LangOptions & Opts,DiagnosticsEngine & Diags) const877 bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
878 DiagnosticsEngine &Diags) const {
879 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
880
881 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
882 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
883 !hasFeatureEnabled(OpenCLFeaturesMap, Name))
884 Diags.Report(diag::warn_opencl_unsupported_core_feature)
885 << Name << Opts.OpenCLCPlusPlus
886 << Opts.getOpenCLVersionTuple().getAsString();
887 };
888 #define OPENCL_GENERIC_EXTENSION(Ext, ...) \
889 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);
890 #include "clang/Basic/OpenCLExtensions.def"
891
892 // Validate that feature macros are set properly for OpenCL C 3.0.
893 // In other cases assume that target is always valid.
894 if (Opts.getOpenCLCompatibleVersion() < 300)
895 return true;
896
897 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) &&
898 OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags);
899 }
900