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