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