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