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