clang 20.0.0git
Targets.cpp
Go to the documentation of this file.
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
49using namespace clang;
50
51namespace clang {
52namespace 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.
60void 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
76void 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
83void 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
112std::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::NetBSD:
168 return std::make_unique<NetBSDTargetInfo<AArch64leTargetInfo>>(Triple,
169 Opts);
170 case llvm::Triple::OpenBSD:
171 return std::make_unique<OpenBSDTargetInfo<AArch64leTargetInfo>>(Triple,
172 Opts);
173 case llvm::Triple::Win32:
174 switch (Triple.getEnvironment()) {
175 case llvm::Triple::GNU:
176 return std::make_unique<MinGWARM64TargetInfo>(Triple, Opts);
177 case llvm::Triple::MSVC:
178 default: // Assume MSVC for unknown environments
179 return std::make_unique<MicrosoftARM64TargetInfo>(Triple, Opts);
180 }
181 default:
182 return std::make_unique<AArch64leTargetInfo>(Triple, Opts);
183 }
184
185 case llvm::Triple::aarch64_be:
186 switch (os) {
187 case llvm::Triple::FreeBSD:
188 return std::make_unique<FreeBSDTargetInfo<AArch64beTargetInfo>>(Triple,
189 Opts);
190 case llvm::Triple::Fuchsia:
191 return std::make_unique<FuchsiaTargetInfo<AArch64beTargetInfo>>(Triple,
192 Opts);
193 case llvm::Triple::Linux:
194 return std::make_unique<LinuxTargetInfo<AArch64beTargetInfo>>(Triple,
195 Opts);
196 case llvm::Triple::NetBSD:
197 return std::make_unique<NetBSDTargetInfo<AArch64beTargetInfo>>(Triple,
198 Opts);
199 default:
200 return std::make_unique<AArch64beTargetInfo>(Triple, Opts);
201 }
202
203 case llvm::Triple::arm:
204 case llvm::Triple::thumb:
205 if (Triple.isOSBinFormatMachO())
206 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);
207
208 switch (os) {
209 case llvm::Triple::Linux:
210 switch (Triple.getEnvironment()) {
211 default:
212 return std::make_unique<LinuxTargetInfo<ARMleTargetInfo>>(Triple, Opts);
213 case llvm::Triple::OpenHOS:
214 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
215 }
216 case llvm::Triple::LiteOS:
217 return std::make_unique<OHOSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
218 case llvm::Triple::FreeBSD:
219 return std::make_unique<FreeBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
220 case llvm::Triple::NetBSD:
221 return std::make_unique<NetBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
222 case llvm::Triple::OpenBSD:
223 return std::make_unique<OpenBSDTargetInfo<ARMleTargetInfo>>(Triple, Opts);
224 case llvm::Triple::RTEMS:
225 return std::make_unique<RTEMSTargetInfo<ARMleTargetInfo>>(Triple, Opts);
226 case llvm::Triple::Haiku:
227 return std::make_unique<HaikuTargetInfo<ARMleTargetInfo>>(Triple, Opts);
228 case llvm::Triple::NaCl:
229 return std::make_unique<NaClTargetInfo<ARMleTargetInfo>>(Triple, Opts);
230 case llvm::Triple::Win32:
231 switch (Triple.getEnvironment()) {
232 case llvm::Triple::Cygnus:
233 return std::make_unique<CygwinARMTargetInfo>(Triple, Opts);
234 case llvm::Triple::GNU:
235 return std::make_unique<MinGWARMTargetInfo>(Triple, Opts);
236 case llvm::Triple::Itanium:
237 return std::make_unique<ItaniumWindowsARMleTargetInfo>(Triple, Opts);
238 case llvm::Triple::MSVC:
239 default: // Assume MSVC for unknown environments
240 return std::make_unique<MicrosoftARMleTargetInfo>(Triple, Opts);
241 }
242 default:
243 return std::make_unique<ARMleTargetInfo>(Triple, Opts);
244 }
245
246 case llvm::Triple::armeb:
247 case llvm::Triple::thumbeb:
248 if (Triple.isOSDarwin())
249 return std::make_unique<DarwinARMTargetInfo>(Triple, Opts);
250 else if (Triple.isAppleMachO())
251 return std::make_unique<AppleMachOARMTargetInfo>(Triple, Opts);
252
253 switch (os) {
254 case llvm::Triple::Linux:
255 return std::make_unique<LinuxTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
256 case llvm::Triple::NetBSD:
257 return std::make_unique<NetBSDTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
258 case llvm::Triple::RTEMS:
259 return std::make_unique<RTEMSTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
260 case llvm::Triple::NaCl:
261 return std::make_unique<NaClTargetInfo<ARMbeTargetInfo>>(Triple, Opts);
262 default:
263 return std::make_unique<ARMbeTargetInfo>(Triple, Opts);
264 }
265
266 case llvm::Triple::avr:
267 return std::make_unique<AVRTargetInfo>(Triple, Opts);
268 case llvm::Triple::bpfeb:
269 case llvm::Triple::bpfel:
270 return std::make_unique<BPFTargetInfo>(Triple, Opts);
271
272 case llvm::Triple::msp430:
273 return std::make_unique<MSP430TargetInfo>(Triple, Opts);
274
275 case llvm::Triple::mips:
276 switch (os) {
277 case llvm::Triple::Linux:
278 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
279 case llvm::Triple::RTEMS:
280 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
281 case llvm::Triple::FreeBSD:
282 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
283 case llvm::Triple::NetBSD:
284 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
285 default:
286 return std::make_unique<MipsTargetInfo>(Triple, Opts);
287 }
288
289 case llvm::Triple::mipsel:
290 switch (os) {
291 case llvm::Triple::Linux:
292 switch (Triple.getEnvironment()) {
293 default:
294 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
295 case llvm::Triple::OpenHOS:
296 return std::make_unique<OHOSTargetInfo<MipsTargetInfo>>(Triple, Opts);
297 }
298 case llvm::Triple::RTEMS:
299 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
300 case llvm::Triple::FreeBSD:
301 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
302 case llvm::Triple::NetBSD:
303 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
304 case llvm::Triple::NaCl:
305 return std::make_unique<NaClTargetInfo<NaClMips32TargetInfo>>(Triple,
306 Opts);
307 case llvm::Triple::Win32:
308 switch (Triple.getEnvironment()) {
309 case llvm::Triple::GNU:
310 return std::make_unique<MinGWMipsTargetInfo>(Triple, Opts);
311 case llvm::Triple::MSVC:
312 default: // Assume MSVC for unknown environments
313 return std::make_unique<MicrosoftMipsTargetInfo>(Triple, Opts);
314 }
315 default:
316 return std::make_unique<MipsTargetInfo>(Triple, Opts);
317 }
318
319 case llvm::Triple::mips64:
320 switch (os) {
321 case llvm::Triple::Linux:
322 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
323 case llvm::Triple::RTEMS:
324 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
325 case llvm::Triple::FreeBSD:
326 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
327 case llvm::Triple::NetBSD:
328 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
329 case llvm::Triple::OpenBSD:
330 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
331 default:
332 return std::make_unique<MipsTargetInfo>(Triple, Opts);
333 }
334
335 case llvm::Triple::mips64el:
336 switch (os) {
337 case llvm::Triple::Linux:
338 return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
339 case llvm::Triple::RTEMS:
340 return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
341 case llvm::Triple::FreeBSD:
342 return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
343 case llvm::Triple::NetBSD:
344 return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
345 case llvm::Triple::OpenBSD:
346 return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
347 default:
348 return std::make_unique<MipsTargetInfo>(Triple, Opts);
349 }
350
351 case llvm::Triple::m68k:
352 switch (os) {
353 case llvm::Triple::Linux:
354 return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts);
355 case llvm::Triple::NetBSD:
356 return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts);
357 default:
358 return std::make_unique<M68kTargetInfo>(Triple, Opts);
359 }
360
361 case llvm::Triple::ppc:
362 switch (os) {
363 case llvm::Triple::Linux:
364 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
365 case llvm::Triple::FreeBSD:
366 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
367 case llvm::Triple::NetBSD:
368 return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
369 case llvm::Triple::OpenBSD:
370 return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
371 case llvm::Triple::RTEMS:
372 return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts);
373 case llvm::Triple::AIX:
374 return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts);
375 default:
376 return std::make_unique<PPC32TargetInfo>(Triple, Opts);
377 }
378
379 case llvm::Triple::ppcle:
380 switch (os) {
381 case llvm::Triple::Linux:
382 return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
383 case llvm::Triple::FreeBSD:
384 return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
385 default:
386 return std::make_unique<PPC32TargetInfo>(Triple, Opts);
387 }
388
389 case llvm::Triple::ppc64:
390 switch (os) {
391 case llvm::Triple::Linux:
392 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
393 case llvm::Triple::Lv2:
394 return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts);
395 case llvm::Triple::FreeBSD:
396 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
397 case llvm::Triple::NetBSD:
398 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
399 case llvm::Triple::OpenBSD:
400 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
401 case llvm::Triple::AIX:
402 return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts);
403 default:
404 return std::make_unique<PPC64TargetInfo>(Triple, Opts);
405 }
406
407 case llvm::Triple::ppc64le:
408 switch (os) {
409 case llvm::Triple::Linux:
410 return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
411 case llvm::Triple::FreeBSD:
412 return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
413 case llvm::Triple::NetBSD:
414 return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
415 case llvm::Triple::OpenBSD:
416 return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
417 default:
418 return std::make_unique<PPC64TargetInfo>(Triple, Opts);
419 }
420
421 case llvm::Triple::nvptx:
422 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
423 /*TargetPointerWidth=*/32);
424 case llvm::Triple::nvptx64:
425 return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
426 /*TargetPointerWidth=*/64);
427
428 case llvm::Triple::amdgcn:
429 case llvm::Triple::r600:
430 return std::make_unique<AMDGPUTargetInfo>(Triple, Opts);
431
432 case llvm::Triple::riscv32:
433 switch (os) {
434 case llvm::Triple::NetBSD:
435 return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple,
436 Opts);
437 case llvm::Triple::Linux:
438 return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts);
439 default:
440 return std::make_unique<RISCV32TargetInfo>(Triple, Opts);
441 }
442
443 case llvm::Triple::riscv64:
444 switch (os) {
445 case llvm::Triple::FreeBSD:
446 return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple,
447 Opts);
448 case llvm::Triple::NetBSD:
449 return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple,
450 Opts);
451 case llvm::Triple::OpenBSD:
452 return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple,
453 Opts);
454 case llvm::Triple::Fuchsia:
455 return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple,
456 Opts);
457 case llvm::Triple::Haiku:
458 return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple,
459 Opts);
460 case llvm::Triple::Linux:
461 switch (Triple.getEnvironment()) {
462 default:
463 return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple,
464 Opts);
465 case llvm::Triple::OpenHOS:
466 return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple,
467 Opts);
468 }
469 default:
470 return std::make_unique<RISCV64TargetInfo>(Triple, Opts);
471 }
472
473 case llvm::Triple::sparc:
474 switch (os) {
475 case llvm::Triple::Linux:
476 return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
477 case llvm::Triple::Solaris:
478 return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple,
479 Opts);
480 case llvm::Triple::NetBSD:
481 return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple,
482 Opts);
483 case llvm::Triple::RTEMS:
484 return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
485 default:
486 return std::make_unique<SparcV8TargetInfo>(Triple, Opts);
487 }
488
489 case llvm::Triple::sparcel:
490 switch (os) {
491 case llvm::Triple::Linux:
492 return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple,
493 Opts);
494 case llvm::Triple::RTEMS:
495 return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple,
496 Opts);
497 default:
498 return std::make_unique<SparcV8elTargetInfo>(Triple, Opts);
499 }
500
501 case llvm::Triple::sparcv9:
502 switch (os) {
503 case llvm::Triple::Linux:
504 return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts);
505 case llvm::Triple::Solaris:
506 return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple,
507 Opts);
508 case llvm::Triple::NetBSD:
509 return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple,
510 Opts);
511 case llvm::Triple::OpenBSD:
512 return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple,
513 Opts);
514 case llvm::Triple::FreeBSD:
515 return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple,
516 Opts);
517 default:
518 return std::make_unique<SparcV9TargetInfo>(Triple, Opts);
519 }
520
521 case llvm::Triple::systemz:
522 switch (os) {
523 case llvm::Triple::Linux:
524 return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts);
525 case llvm::Triple::ZOS:
526 return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts);
527 default:
528 return std::make_unique<SystemZTargetInfo>(Triple, Opts);
529 }
530
531 case llvm::Triple::tce:
532 return std::make_unique<TCETargetInfo>(Triple, Opts);
533
534 case llvm::Triple::tcele:
535 return std::make_unique<TCELETargetInfo>(Triple, Opts);
536
537 case llvm::Triple::x86:
538 if (Triple.isOSDarwin())
539 return std::make_unique<DarwinI386TargetInfo>(Triple, Opts);
540 else if (Triple.isAppleMachO())
541 return std::make_unique<AppleMachOI386TargetInfo>(Triple, Opts);
542
543 switch (os) {
544 case llvm::Triple::Linux: {
545 switch (Triple.getEnvironment()) {
546 default:
547 return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple,
548 Opts);
549 case llvm::Triple::Android:
550 return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts);
551 }
552 }
553 case llvm::Triple::DragonFly:
554 return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple,
555 Opts);
556 case llvm::Triple::NetBSD:
557 return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts);
558 case llvm::Triple::OpenBSD:
559 return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts);
560 case llvm::Triple::FreeBSD:
561 return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
562 Opts);
563 case llvm::Triple::Fuchsia:
564 return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple,
565 Opts);
566 case llvm::Triple::KFreeBSD:
567 return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
568 Opts);
569 case llvm::Triple::Solaris:
570 return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple,
571 Opts);
572 case llvm::Triple::Win32: {
573 switch (Triple.getEnvironment()) {
574 case llvm::Triple::Cygnus:
575 return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts);
576 case llvm::Triple::GNU:
577 return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts);
578 case llvm::Triple::Itanium:
579 case llvm::Triple::MSVC:
580 default: // Assume MSVC for unknown environments
581 return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts);
582 }
583 }
584 case llvm::Triple::Haiku:
585 return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts);
586 case llvm::Triple::RTEMS:
587 return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);
588 case llvm::Triple::NaCl:
589 return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts);
590 case llvm::Triple::ELFIAMCU:
591 return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);
592 case llvm::Triple::Hurd:
593 return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);
594 default:
595 return std::make_unique<X86_32TargetInfo>(Triple, Opts);
596 }
597
598 case llvm::Triple::x86_64:
599 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
600 return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);
601
602 switch (os) {
603 case llvm::Triple::Linux: {
604 switch (Triple.getEnvironment()) {
605 default:
606 return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple,
607 Opts);
608 case llvm::Triple::Android:
609 return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts);
610 case llvm::Triple::OpenHOS:
611 return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts);
612 }
613 }
614 case llvm::Triple::DragonFly:
615 return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple,
616 Opts);
617 case llvm::Triple::NetBSD:
618 return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts);
619 case llvm::Triple::OpenBSD:
620 return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts);
621 case llvm::Triple::FreeBSD:
622 return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
623 Opts);
624 case llvm::Triple::Fuchsia:
625 return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple,
626 Opts);
627 case llvm::Triple::KFreeBSD:
628 return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
629 Opts);
630 case llvm::Triple::Solaris:
631 return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple,
632 Opts);
633 case llvm::Triple::UEFI:
634 return std::make_unique<UEFIX86_64TargetInfo>(Triple, Opts);
635
636 case llvm::Triple::Win32: {
637 switch (Triple.getEnvironment()) {
638 case llvm::Triple::Cygnus:
639 return std::make_unique<CygwinX86_64TargetInfo>(Triple, Opts);
640 case llvm::Triple::GNU:
641 return std::make_unique<MinGWX86_64TargetInfo>(Triple, Opts);
642 case llvm::Triple::MSVC:
643 default: // Assume MSVC for unknown environments
644 return std::make_unique<MicrosoftX86_64TargetInfo>(Triple, Opts);
645 }
646 }
647 case llvm::Triple::Haiku:
648 return std::make_unique<HaikuTargetInfo<X86_64TargetInfo>>(Triple, Opts);
649 case llvm::Triple::NaCl:
650 return std::make_unique<NaClTargetInfo<X86_64TargetInfo>>(Triple, Opts);
651 case llvm::Triple::PS4:
652 return std::make_unique<PS4OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
653 case llvm::Triple::PS5:
654 return std::make_unique<PS5OSTargetInfo<X86_64TargetInfo>>(Triple, Opts);
655 case llvm::Triple::Hurd:
656 return std::make_unique<HurdTargetInfo<X86_64TargetInfo>>(Triple, Opts);
657 default:
658 return std::make_unique<X86_64TargetInfo>(Triple, Opts);
659 }
660
661 case llvm::Triple::spir: {
662 if (os != llvm::Triple::UnknownOS ||
663 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
664 return nullptr;
665 return std::make_unique<SPIR32TargetInfo>(Triple, Opts);
666 }
667 case llvm::Triple::spir64: {
668 if (os != llvm::Triple::UnknownOS ||
669 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
670 return nullptr;
671 return std::make_unique<SPIR64TargetInfo>(Triple, Opts);
672 }
673 case llvm::Triple::spirv: {
674 return std::make_unique<SPIRVTargetInfo>(Triple, Opts);
675 }
676 case llvm::Triple::spirv32: {
677 if (os != llvm::Triple::UnknownOS ||
678 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
679 return nullptr;
680 return std::make_unique<SPIRV32TargetInfo>(Triple, Opts);
681 }
682 case llvm::Triple::spirv64: {
683 if (os != llvm::Triple::UnknownOS ||
684 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment) {
685 if (os == llvm::Triple::OSType::AMDHSA)
686 return std::make_unique<SPIRV64AMDGCNTargetInfo>(Triple, Opts);
687 return nullptr;
688 }
689 return std::make_unique<SPIRV64TargetInfo>(Triple, Opts);
690 }
691 case llvm::Triple::wasm32:
692 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
693 Triple.getVendor() != llvm::Triple::UnknownVendor ||
694 !Triple.isOSBinFormatWasm())
695 return nullptr;
696 switch (os) {
697 case llvm::Triple::WASI:
698 return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple,
699 Opts);
700 case llvm::Triple::Emscripten:
701 return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(
702 Triple, Opts);
703 case llvm::Triple::UnknownOS:
704 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(
705 Triple, Opts);
706 default:
707 return nullptr;
708 }
709 case llvm::Triple::wasm64:
710 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
711 Triple.getVendor() != llvm::Triple::UnknownVendor ||
712 !Triple.isOSBinFormatWasm())
713 return nullptr;
714 switch (os) {
715 case llvm::Triple::WASI:
716 return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple,
717 Opts);
718 case llvm::Triple::Emscripten:
719 return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(
720 Triple, Opts);
721 case llvm::Triple::UnknownOS:
722 return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(
723 Triple, Opts);
724 default:
725 return nullptr;
726 }
727
728 case llvm::Triple::dxil:
729 return std::make_unique<DirectXTargetInfo>(Triple, Opts);
730
731 case llvm::Triple::ve:
732 return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts);
733
734 case llvm::Triple::csky:
735 switch (os) {
736 case llvm::Triple::Linux:
737 return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts);
738 default:
739 return std::make_unique<CSKYTargetInfo>(Triple, Opts);
740 }
741 case llvm::Triple::loongarch32:
742 switch (os) {
743 case llvm::Triple::Linux:
744 return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,
745 Opts);
746 default:
747 return std::make_unique<LoongArch32TargetInfo>(Triple, Opts);
748 }
749 case llvm::Triple::loongarch64:
750 switch (os) {
751 case llvm::Triple::Linux:
752 return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,
753 Opts);
754 case llvm::Triple::FreeBSD:
755 return std::make_unique<FreeBSDTargetInfo<LoongArch64TargetInfo>>(Triple,
756 Opts);
757 default:
758 return std::make_unique<LoongArch64TargetInfo>(Triple, Opts);
759 }
760
761 case llvm::Triple::xtensa:
762 return std::make_unique<XtensaTargetInfo>(Triple, Opts);
763 }
764}
765} // namespace targets
766} // namespace clang
767
768using namespace clang::targets;
769/// CreateTargetInfo - Return the target info object for the specified target
770/// options.
771TargetInfo *
772TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
773 const std::shared_ptr<TargetOptions> &Opts) {
774 llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple));
775
776 // Construct the target
777 std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts);
778 if (!Target) {
779 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
780 return nullptr;
781 }
782 Target->TargetOpts = Opts;
783
784 // Set the target CPU if specified.
785 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
786 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
787 SmallVector<StringRef, 32> ValidList;
788 Target->fillValidCPUList(ValidList);
789 if (!ValidList.empty())
790 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
791 return nullptr;
792 }
793
794 // Check the TuneCPU name if specified.
795 if (!Opts->TuneCPU.empty() &&
796 !Target->isValidTuneCPUName(Opts->TuneCPU)) {
797 Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;
798 SmallVector<StringRef, 32> ValidList;
799 Target->fillValidTuneCPUList(ValidList);
800 if (!ValidList.empty())
801 Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
802 return nullptr;
803 }
804
805 // Set the target ABI if specified.
806 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
807 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
808 return nullptr;
809 }
810
811 // Set the fp math unit.
812 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
813 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
814 return nullptr;
815 }
816
817 // Compute the default target features, we need the target to handle this
818 // because features may have dependencies on one another.
819 llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) {
820 if (Target->isReadOnlyFeature(Name.substr(1))) {
821 Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;
822 return true;
823 }
824 return false;
825 });
826 if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,
827 Opts->FeaturesAsWritten))
828 return nullptr;
829
830 // Add the features to the compile options.
831 Opts->Features.clear();
832 for (const auto &F : Opts->FeatureMap)
833 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
834 // Sort here, so we handle the features in a predictable order. (This matters
835 // when we're dealing with features that overlap.)
836 llvm::sort(Opts->Features);
837
838 if (!Target->handleTargetFeatures(Opts->Features, Diags))
839 return nullptr;
840
841 Target->setSupportedOpenCLOpts();
842 Target->setCommandLineOpenCLOpts();
843 Target->setMaxAtomicWidth();
844
845 if (!Opts->DarwinTargetVariantTriple.empty())
846 Target->DarwinTargetVariantTriple =
847 llvm::Triple(Opts->DarwinTargetVariantTriple);
848
849 if (!Target->validateTarget(Diags))
850 return nullptr;
851
852 Target->CheckFixedPointBits();
853
854 return Target.release();
855}
856/// validateOpenCLTarget - Check that OpenCL target has valid
857/// options setting based on OpenCL version.
858bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
859 DiagnosticsEngine &Diags) const {
860 const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
861
862 auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
863 if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
864 !hasFeatureEnabled(OpenCLFeaturesMap, Name))
865 Diags.Report(diag::warn_opencl_unsupported_core_feature)
866 << Name << Opts.OpenCLCPlusPlus
867 << Opts.getOpenCLVersionTuple().getAsString();
868 };
869#define OPENCL_GENERIC_EXTENSION(Ext, ...) \
870 diagnoseNotSupportedCore(#Ext, __VA_ARGS__);
871#include "clang/Basic/OpenCLExtensions.def"
872
873 // Validate that feature macros are set properly for OpenCL C 3.0.
874 // In other cases assume that target is always valid.
875 if (Opts.getOpenCLCompatibleVersion() < 300)
876 return true;
877
878 return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) &&
879 OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags);
880}
Diagnostic.h
Defines the Diagnostic-related interfaces.
Target
llvm::MachO::Target Target
Definition: MachO.h:51
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:231
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1493
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:499
clang::LangOptions::getOpenCLVersionTuple
VersionTuple getOpenCLVersionTuple() const
Return the OpenCL C or C++ version as a VersionTuple.
Definition: LangOptions.cpp:56
clang::LangOptions::getOpenCLCompatibleVersion
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Definition: LangOptions.cpp:63
clang::OpenCLOptions::diagnoseUnsupportedFeatureDependencies
static bool diagnoseUnsupportedFeatureDependencies(const TargetInfo &TI, DiagnosticsEngine &Diags)
Definition: OpenCLOptions.cpp:122
clang::OpenCLOptions::diagnoseFeatureExtensionDifferences
static bool diagnoseFeatureExtensionDifferences(const TargetInfo &TI, DiagnosticsEngine &Diags)
Definition: OpenCLOptions.cpp:139
clang::OpenCLOptions::isOpenCLOptionCoreIn
static bool isOpenCLOptionCoreIn(const LangOptions &LO, Args &&... args)
Definition: OpenCLOptions.h:190
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:220
clang::TargetInfo::hasFeatureEnabled
virtual bool hasFeatureEnabled(const llvm::StringMap< bool > &Features, StringRef Name) const
Check if target has a given feature enabled.
Definition: TargetInfo.h:1385
clang::TargetInfo::CreateTargetInfo
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:772
clang::TargetInfo::validateOpenCLTarget
virtual bool validateOpenCLTarget(const LangOptions &Opts, DiagnosticsEngine &Diags) const
Check that OpenCL target has valid options setting based on OpenCL version.
Definition: Targets.cpp:858
clang::TargetInfo::getSupportedOpenCLOpts
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1779
clang::TargetOptions
Options for controlling the target.
Definition: TargetOptions.h:26
clang::targets::defineCPUMacros
LLVM_LIBRARY_VISIBILITY void defineCPUMacros(clang::MacroBuilder &Builder, llvm::StringRef CPUName, bool Tuning=true)
clang::targets::addCygMingDefines
LLVM_LIBRARY_VISIBILITY void addCygMingDefines(const clang::LangOptions &Opts, clang::MacroBuilder &Builder)
Definition: Targets.cpp:83
clang::targets::DefineStd
LLVM_LIBRARY_VISIBILITY void DefineStd(clang::MacroBuilder &Builder, llvm::StringRef MacroName, const clang::LangOptions &Opts)
Define a macro name and standard variants.
clang::targets::AllocateTarget
std::unique_ptr< clang::TargetInfo > AllocateTarget(const llvm::Triple &Triple, const clang::TargetOptions &Opts)
Definition: Targets.cpp:112
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition: CalledOnceCheck.h:17
Generated on Mon Jun 30 2025 00:12:16 for clang by doxygen 1.9.6