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