clang  19.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"
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 
49 using namespace clang;
50 
51 namespace clang {
52 namespace 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.
60 void 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 
76 void 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 
83 void 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 
112 std::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  default:
302  return std::make_unique<MipsTargetInfo>(Triple, Opts);
303  }
304 
305  case llvm::Triple::mips64:
306  switch (os) {
307  case llvm::Triple::Linux:
308  return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
309  case llvm::Triple::RTEMS:
310  return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
311  case llvm::Triple::FreeBSD:
312  return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
313  case llvm::Triple::NetBSD:
314  return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
315  case llvm::Triple::OpenBSD:
316  return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
317  default:
318  return std::make_unique<MipsTargetInfo>(Triple, Opts);
319  }
320 
321  case llvm::Triple::mips64el:
322  switch (os) {
323  case llvm::Triple::Linux:
324  return std::make_unique<LinuxTargetInfo<MipsTargetInfo>>(Triple, Opts);
325  case llvm::Triple::RTEMS:
326  return std::make_unique<RTEMSTargetInfo<MipsTargetInfo>>(Triple, Opts);
327  case llvm::Triple::FreeBSD:
328  return std::make_unique<FreeBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
329  case llvm::Triple::NetBSD:
330  return std::make_unique<NetBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
331  case llvm::Triple::OpenBSD:
332  return std::make_unique<OpenBSDTargetInfo<MipsTargetInfo>>(Triple, Opts);
333  default:
334  return std::make_unique<MipsTargetInfo>(Triple, Opts);
335  }
336 
337  case llvm::Triple::m68k:
338  switch (os) {
339  case llvm::Triple::Linux:
340  return std::make_unique<LinuxTargetInfo<M68kTargetInfo>>(Triple, Opts);
341  case llvm::Triple::NetBSD:
342  return std::make_unique<NetBSDTargetInfo<M68kTargetInfo>>(Triple, Opts);
343  default:
344  return std::make_unique<M68kTargetInfo>(Triple, Opts);
345  }
346 
347  case llvm::Triple::le32:
348  switch (os) {
349  case llvm::Triple::NaCl:
350  return std::make_unique<NaClTargetInfo<PNaClTargetInfo>>(Triple, Opts);
351  default:
352  return nullptr;
353  }
354 
355  case llvm::Triple::le64:
356  return std::make_unique<Le64TargetInfo>(Triple, Opts);
357 
358  case llvm::Triple::ppc:
359  switch (os) {
360  case llvm::Triple::Linux:
361  return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
362  case llvm::Triple::FreeBSD:
363  return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
364  case llvm::Triple::NetBSD:
365  return std::make_unique<NetBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
366  case llvm::Triple::OpenBSD:
367  return std::make_unique<OpenBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
368  case llvm::Triple::RTEMS:
369  return std::make_unique<RTEMSTargetInfo<PPC32TargetInfo>>(Triple, Opts);
370  case llvm::Triple::AIX:
371  return std::make_unique<AIXPPC32TargetInfo>(Triple, Opts);
372  default:
373  return std::make_unique<PPC32TargetInfo>(Triple, Opts);
374  }
375 
376  case llvm::Triple::ppcle:
377  switch (os) {
378  case llvm::Triple::Linux:
379  return std::make_unique<LinuxTargetInfo<PPC32TargetInfo>>(Triple, Opts);
380  case llvm::Triple::FreeBSD:
381  return std::make_unique<FreeBSDTargetInfo<PPC32TargetInfo>>(Triple, Opts);
382  default:
383  return std::make_unique<PPC32TargetInfo>(Triple, Opts);
384  }
385 
386  case llvm::Triple::ppc64:
387  switch (os) {
388  case llvm::Triple::Linux:
389  return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
390  case llvm::Triple::Lv2:
391  return std::make_unique<PS3PPUTargetInfo<PPC64TargetInfo>>(Triple, Opts);
392  case llvm::Triple::FreeBSD:
393  return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
394  case llvm::Triple::NetBSD:
395  return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
396  case llvm::Triple::OpenBSD:
397  return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
398  case llvm::Triple::AIX:
399  return std::make_unique<AIXPPC64TargetInfo>(Triple, Opts);
400  default:
401  return std::make_unique<PPC64TargetInfo>(Triple, Opts);
402  }
403 
404  case llvm::Triple::ppc64le:
405  switch (os) {
406  case llvm::Triple::Linux:
407  return std::make_unique<LinuxTargetInfo<PPC64TargetInfo>>(Triple, Opts);
408  case llvm::Triple::FreeBSD:
409  return std::make_unique<FreeBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
410  case llvm::Triple::NetBSD:
411  return std::make_unique<NetBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
412  case llvm::Triple::OpenBSD:
413  return std::make_unique<OpenBSDTargetInfo<PPC64TargetInfo>>(Triple, Opts);
414  default:
415  return std::make_unique<PPC64TargetInfo>(Triple, Opts);
416  }
417 
418  case llvm::Triple::nvptx:
419  return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
420  /*TargetPointerWidth=*/32);
421  case llvm::Triple::nvptx64:
422  return std::make_unique<NVPTXTargetInfo>(Triple, Opts,
423  /*TargetPointerWidth=*/64);
424 
425  case llvm::Triple::amdgcn:
426  case llvm::Triple::r600:
427  return std::make_unique<AMDGPUTargetInfo>(Triple, Opts);
428 
429  case llvm::Triple::riscv32:
430  switch (os) {
431  case llvm::Triple::NetBSD:
432  return std::make_unique<NetBSDTargetInfo<RISCV32TargetInfo>>(Triple,
433  Opts);
434  case llvm::Triple::Linux:
435  return std::make_unique<LinuxTargetInfo<RISCV32TargetInfo>>(Triple, Opts);
436  default:
437  return std::make_unique<RISCV32TargetInfo>(Triple, Opts);
438  }
439 
440  case llvm::Triple::riscv64:
441  switch (os) {
442  case llvm::Triple::FreeBSD:
443  return std::make_unique<FreeBSDTargetInfo<RISCV64TargetInfo>>(Triple,
444  Opts);
445  case llvm::Triple::NetBSD:
446  return std::make_unique<NetBSDTargetInfo<RISCV64TargetInfo>>(Triple,
447  Opts);
448  case llvm::Triple::OpenBSD:
449  return std::make_unique<OpenBSDTargetInfo<RISCV64TargetInfo>>(Triple,
450  Opts);
451  case llvm::Triple::Fuchsia:
452  return std::make_unique<FuchsiaTargetInfo<RISCV64TargetInfo>>(Triple,
453  Opts);
454  case llvm::Triple::Haiku:
455  return std::make_unique<HaikuTargetInfo<RISCV64TargetInfo>>(Triple,
456  Opts);
457  case llvm::Triple::Linux:
458  switch (Triple.getEnvironment()) {
459  default:
460  return std::make_unique<LinuxTargetInfo<RISCV64TargetInfo>>(Triple,
461  Opts);
462  case llvm::Triple::OpenHOS:
463  return std::make_unique<OHOSTargetInfo<RISCV64TargetInfo>>(Triple,
464  Opts);
465  }
466  default:
467  return std::make_unique<RISCV64TargetInfo>(Triple, Opts);
468  }
469 
470  case llvm::Triple::sparc:
471  switch (os) {
472  case llvm::Triple::Linux:
473  return std::make_unique<LinuxTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
474  case llvm::Triple::Solaris:
475  return std::make_unique<SolarisTargetInfo<SparcV8TargetInfo>>(Triple,
476  Opts);
477  case llvm::Triple::NetBSD:
478  return std::make_unique<NetBSDTargetInfo<SparcV8TargetInfo>>(Triple,
479  Opts);
480  case llvm::Triple::RTEMS:
481  return std::make_unique<RTEMSTargetInfo<SparcV8TargetInfo>>(Triple, Opts);
482  default:
483  return std::make_unique<SparcV8TargetInfo>(Triple, Opts);
484  }
485 
486  case llvm::Triple::sparcel:
487  switch (os) {
488  case llvm::Triple::Linux:
489  return std::make_unique<LinuxTargetInfo<SparcV8elTargetInfo>>(Triple,
490  Opts);
491  case llvm::Triple::RTEMS:
492  return std::make_unique<RTEMSTargetInfo<SparcV8elTargetInfo>>(Triple,
493  Opts);
494  default:
495  return std::make_unique<SparcV8elTargetInfo>(Triple, Opts);
496  }
497 
498  case llvm::Triple::sparcv9:
499  switch (os) {
500  case llvm::Triple::Linux:
501  return std::make_unique<LinuxTargetInfo<SparcV9TargetInfo>>(Triple, Opts);
502  case llvm::Triple::Solaris:
503  return std::make_unique<SolarisTargetInfo<SparcV9TargetInfo>>(Triple,
504  Opts);
505  case llvm::Triple::NetBSD:
506  return std::make_unique<NetBSDTargetInfo<SparcV9TargetInfo>>(Triple,
507  Opts);
508  case llvm::Triple::OpenBSD:
509  return std::make_unique<OpenBSDTargetInfo<SparcV9TargetInfo>>(Triple,
510  Opts);
511  case llvm::Triple::FreeBSD:
512  return std::make_unique<FreeBSDTargetInfo<SparcV9TargetInfo>>(Triple,
513  Opts);
514  default:
515  return std::make_unique<SparcV9TargetInfo>(Triple, Opts);
516  }
517 
518  case llvm::Triple::systemz:
519  switch (os) {
520  case llvm::Triple::Linux:
521  return std::make_unique<LinuxTargetInfo<SystemZTargetInfo>>(Triple, Opts);
522  case llvm::Triple::ZOS:
523  return std::make_unique<ZOSTargetInfo<SystemZTargetInfo>>(Triple, Opts);
524  default:
525  return std::make_unique<SystemZTargetInfo>(Triple, Opts);
526  }
527 
528  case llvm::Triple::tce:
529  return std::make_unique<TCETargetInfo>(Triple, Opts);
530 
531  case llvm::Triple::tcele:
532  return std::make_unique<TCELETargetInfo>(Triple, Opts);
533 
534  case llvm::Triple::x86:
535  if (Triple.isOSDarwin())
536  return std::make_unique<DarwinI386TargetInfo>(Triple, Opts);
537 
538  switch (os) {
539  case llvm::Triple::Linux: {
540  switch (Triple.getEnvironment()) {
541  default:
542  return std::make_unique<LinuxTargetInfo<X86_32TargetInfo>>(Triple,
543  Opts);
544  case llvm::Triple::Android:
545  return std::make_unique<AndroidX86_32TargetInfo>(Triple, Opts);
546  }
547  }
548  case llvm::Triple::DragonFly:
549  return std::make_unique<DragonFlyBSDTargetInfo<X86_32TargetInfo>>(Triple,
550  Opts);
551  case llvm::Triple::NetBSD:
552  return std::make_unique<NetBSDI386TargetInfo>(Triple, Opts);
553  case llvm::Triple::OpenBSD:
554  return std::make_unique<OpenBSDI386TargetInfo>(Triple, Opts);
555  case llvm::Triple::FreeBSD:
556  return std::make_unique<FreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
557  Opts);
558  case llvm::Triple::Fuchsia:
559  return std::make_unique<FuchsiaTargetInfo<X86_32TargetInfo>>(Triple,
560  Opts);
561  case llvm::Triple::KFreeBSD:
562  return std::make_unique<KFreeBSDTargetInfo<X86_32TargetInfo>>(Triple,
563  Opts);
564  case llvm::Triple::Solaris:
565  return std::make_unique<SolarisTargetInfo<X86_32TargetInfo>>(Triple,
566  Opts);
567  case llvm::Triple::Win32: {
568  switch (Triple.getEnvironment()) {
569  case llvm::Triple::Cygnus:
570  return std::make_unique<CygwinX86_32TargetInfo>(Triple, Opts);
571  case llvm::Triple::GNU:
572  return std::make_unique<MinGWX86_32TargetInfo>(Triple, Opts);
573  case llvm::Triple::Itanium:
574  case llvm::Triple::MSVC:
575  default: // Assume MSVC for unknown environments
576  return std::make_unique<MicrosoftX86_32TargetInfo>(Triple, Opts);
577  }
578  }
579  case llvm::Triple::Haiku:
580  return std::make_unique<HaikuX86_32TargetInfo>(Triple, Opts);
581  case llvm::Triple::RTEMS:
582  return std::make_unique<RTEMSX86_32TargetInfo>(Triple, Opts);
583  case llvm::Triple::NaCl:
584  return std::make_unique<NaClTargetInfo<X86_32TargetInfo>>(Triple, Opts);
585  case llvm::Triple::ELFIAMCU:
586  return std::make_unique<MCUX86_32TargetInfo>(Triple, Opts);
587  case llvm::Triple::Hurd:
588  return std::make_unique<HurdTargetInfo<X86_32TargetInfo>>(Triple, Opts);
589  default:
590  return std::make_unique<X86_32TargetInfo>(Triple, Opts);
591  }
592 
593  case llvm::Triple::x86_64:
594  if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
595  return std::make_unique<DarwinX86_64TargetInfo>(Triple, Opts);
596 
597  switch (os) {
598  case llvm::Triple::Linux: {
599  switch (Triple.getEnvironment()) {
600  default:
601  return std::make_unique<LinuxTargetInfo<X86_64TargetInfo>>(Triple,
602  Opts);
603  case llvm::Triple::Android:
604  return std::make_unique<AndroidX86_64TargetInfo>(Triple, Opts);
605  case llvm::Triple::OpenHOS:
606  return std::make_unique<OHOSX86_64TargetInfo>(Triple, Opts);
607  }
608  }
609  case llvm::Triple::DragonFly:
610  return std::make_unique<DragonFlyBSDTargetInfo<X86_64TargetInfo>>(Triple,
611  Opts);
612  case llvm::Triple::NetBSD:
613  return std::make_unique<NetBSDTargetInfo<X86_64TargetInfo>>(Triple, Opts);
614  case llvm::Triple::OpenBSD:
615  return std::make_unique<OpenBSDX86_64TargetInfo>(Triple, Opts);
616  case llvm::Triple::FreeBSD:
617  return std::make_unique<FreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
618  Opts);
619  case llvm::Triple::Fuchsia:
620  return std::make_unique<FuchsiaTargetInfo<X86_64TargetInfo>>(Triple,
621  Opts);
622  case llvm::Triple::KFreeBSD:
623  return std::make_unique<KFreeBSDTargetInfo<X86_64TargetInfo>>(Triple,
624  Opts);
625  case llvm::Triple::Solaris:
626  return std::make_unique<SolarisTargetInfo<X86_64TargetInfo>>(Triple,
627  Opts);
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  llvm::Triple HT(Opts.HostTriple);
655  switch (HT.getOS()) {
656  case llvm::Triple::Win32:
657  switch (HT.getEnvironment()) {
658  default: // Assume MSVC for unknown environments
659  case llvm::Triple::MSVC:
660  assert(HT.getArch() == llvm::Triple::x86 &&
661  "Unsupported host architecture");
662  return std::make_unique<MicrosoftX86_32SPIRTargetInfo>(Triple, Opts);
663  }
664  case llvm::Triple::Linux:
665  return std::make_unique<LinuxTargetInfo<SPIR32TargetInfo>>(Triple, Opts);
666  default:
667  return std::make_unique<SPIR32TargetInfo>(Triple, Opts);
668  }
669  }
670 
671  case llvm::Triple::spir64: {
672  llvm::Triple HT(Opts.HostTriple);
673  bool IsFPGASubArch = Triple.getSubArch() == llvm::Triple::SPIRSubArch_fpga;
674 
675  switch (HT.getOS()) {
676  case llvm::Triple::Win32:
677  switch (HT.getEnvironment()) {
678  default: // Assume MSVC for unknown environments
679  case llvm::Triple::MSVC:
680  assert(HT.getArch() == llvm::Triple::x86_64 &&
681  "Unsupported host architecture");
682  return std::make_unique<MicrosoftX86_64_SPIR64TargetInfo>(Triple, Opts);
683  }
684  case llvm::Triple::Linux:
685  if (IsFPGASubArch)
686  return std::make_unique<LinuxTargetInfo<SPIR64FPGATargetInfo>>(Triple, Opts);
687  return std::make_unique<LinuxTargetInfo<SPIR64TargetInfo>>(Triple, Opts);
688  default:
689  if (IsFPGASubArch)
690  return std::make_unique<SPIR64FPGATargetInfo>(Triple, Opts);
691  return std::make_unique<SPIR64TargetInfo>(Triple, Opts);
692  }
693  }
694  case llvm::Triple::spirv: {
695  return std::make_unique<SPIRVTargetInfo>(Triple, Opts);
696  }
697  case llvm::Triple::spirv32: {
698  if (os != llvm::Triple::UnknownOS ||
699  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
700  return nullptr;
701  llvm::Triple HT(Opts.HostTriple);
702  switch (HT.getOS()) {
703  case llvm::Triple::Win32:
704  switch (HT.getEnvironment()) {
705  default: // Assume MSVC for unknown environments
706  case llvm::Triple::MSVC:
707  assert(HT.getArch() == llvm::Triple::x86 &&
708  "Unsupported host architecture");
709  return std::make_unique<MicrosoftX86_32SPIRV32TargetInfo>(Triple, Opts);
710  }
711  default:
712  return std::make_unique<SPIRV32TargetInfo>(Triple, Opts);
713  }
714  }
715  case llvm::Triple::spirv64: {
716  if (os != llvm::Triple::UnknownOS ||
717  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
718  return nullptr;
719  llvm::Triple HT(Opts.HostTriple);
720  switch (HT.getOS()) {
721  case llvm::Triple::Win32:
722  switch (HT.getEnvironment()) {
723  default: // Assume MSVC for unknown environments
724  case llvm::Triple::MSVC:
725  assert(HT.getArch() == llvm::Triple::x86_64 &&
726  "Unsupported host architecture");
727  return std::make_unique<MicrosoftX86_64_SPIRV64TargetInfo>(Triple,
728  Opts);
729  }
730  default:
731  return std::make_unique<SPIRV64TargetInfo>(Triple, Opts);
732  }
733  }
734  case llvm::Triple::wasm32:
735  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
736  Triple.getVendor() != llvm::Triple::UnknownVendor ||
737  !Triple.isOSBinFormatWasm())
738  return nullptr;
739  switch (os) {
740  case llvm::Triple::WASI:
741  return std::make_unique<WASITargetInfo<WebAssembly32TargetInfo>>(Triple,
742  Opts);
743  case llvm::Triple::Emscripten:
744  return std::make_unique<EmscriptenTargetInfo<WebAssembly32TargetInfo>>(
745  Triple, Opts);
746  case llvm::Triple::UnknownOS:
747  return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>>(
748  Triple, Opts);
749  default:
750  return nullptr;
751  }
752  case llvm::Triple::wasm64:
753  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
754  Triple.getVendor() != llvm::Triple::UnknownVendor ||
755  !Triple.isOSBinFormatWasm())
756  return nullptr;
757  switch (os) {
758  case llvm::Triple::WASI:
759  return std::make_unique<WASITargetInfo<WebAssembly64TargetInfo>>(Triple,
760  Opts);
761  case llvm::Triple::Emscripten:
762  return std::make_unique<EmscriptenTargetInfo<WebAssembly64TargetInfo>>(
763  Triple, Opts);
764  case llvm::Triple::UnknownOS:
765  return std::make_unique<WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>>(
766  Triple, Opts);
767  default:
768  return nullptr;
769  }
770 
771  case llvm::Triple::dxil:
772  return std::make_unique<DirectXTargetInfo>(Triple, Opts);
773  case llvm::Triple::renderscript32:
774  return std::make_unique<LinuxTargetInfo<RenderScript32TargetInfo>>(Triple,
775  Opts);
776  case llvm::Triple::renderscript64:
777  return std::make_unique<LinuxTargetInfo<RenderScript64TargetInfo>>(Triple,
778  Opts);
779 
780  case llvm::Triple::ve:
781  return std::make_unique<LinuxTargetInfo<VETargetInfo>>(Triple, Opts);
782 
783  case llvm::Triple::csky:
784  switch (os) {
785  case llvm::Triple::Linux:
786  return std::make_unique<LinuxTargetInfo<CSKYTargetInfo>>(Triple, Opts);
787  default:
788  return std::make_unique<CSKYTargetInfo>(Triple, Opts);
789  }
790  case llvm::Triple::loongarch32:
791  switch (os) {
792  case llvm::Triple::Linux:
793  return std::make_unique<LinuxTargetInfo<LoongArch32TargetInfo>>(Triple,
794  Opts);
795  default:
796  return std::make_unique<LoongArch32TargetInfo>(Triple, Opts);
797  }
798  case llvm::Triple::loongarch64:
799  switch (os) {
800  case llvm::Triple::Linux:
801  return std::make_unique<LinuxTargetInfo<LoongArch64TargetInfo>>(Triple,
802  Opts);
803  default:
804  return std::make_unique<LoongArch64TargetInfo>(Triple, Opts);
805  }
806  }
807 }
808 } // namespace targets
809 } // namespace clang
810 
811 using namespace clang::targets;
812 /// CreateTargetInfo - Return the target info object for the specified target
813 /// options.
814 TargetInfo *
815 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
816  const std::shared_ptr<TargetOptions> &Opts) {
817  llvm::Triple Triple(llvm::Triple::normalize(Opts->Triple));
818 
819  // Construct the target
820  std::unique_ptr<TargetInfo> Target = AllocateTarget(Triple, *Opts);
821  if (!Target) {
822  Diags.Report(diag::err_target_unknown_triple) << Triple.str();
823  return nullptr;
824  }
825  Target->TargetOpts = Opts;
826 
827  // Set the target CPU if specified.
828  if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
829  Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
830  SmallVector<StringRef, 32> ValidList;
831  Target->fillValidCPUList(ValidList);
832  if (!ValidList.empty())
833  Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
834  return nullptr;
835  }
836 
837  // Check the TuneCPU name if specified.
838  if (!Opts->TuneCPU.empty() &&
839  !Target->isValidTuneCPUName(Opts->TuneCPU)) {
840  Diags.Report(diag::err_target_unknown_cpu) << Opts->TuneCPU;
841  SmallVector<StringRef, 32> ValidList;
842  Target->fillValidTuneCPUList(ValidList);
843  if (!ValidList.empty())
844  Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
845  return nullptr;
846  }
847 
848  // Set the target ABI if specified.
849  if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
850  Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
851  return nullptr;
852  }
853 
854  // Set the fp math unit.
855  if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
856  Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
857  return nullptr;
858  }
859 
860  // Compute the default target features, we need the target to handle this
861  // because features may have dependencies on one another.
862  llvm::erase_if(Opts->FeaturesAsWritten, [&](StringRef Name) {
863  if (Target->isReadOnlyFeature(Name.substr(1))) {
864  Diags.Report(diag::warn_fe_backend_readonly_feature_flag) << Name;
865  return true;
866  }
867  return false;
868  });
869  if (!Target->initFeatureMap(Opts->FeatureMap, Diags, Opts->CPU,
870  Opts->FeaturesAsWritten))
871  return nullptr;
872 
873  // Add the features to the compile options.
874  Opts->Features.clear();
875  for (const auto &F : Opts->FeatureMap)
876  Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
877  // Sort here, so we handle the features in a predictable order. (This matters
878  // when we're dealing with features that overlap.)
879  llvm::sort(Opts->Features);
880 
881  if (!Target->handleTargetFeatures(Opts->Features, Diags))
882  return nullptr;
883 
884  Target->setSupportedOpenCLOpts();
885  Target->setCommandLineOpenCLOpts();
886  Target->setMaxAtomicWidth();
887 
888  if (!Opts->DarwinTargetVariantTriple.empty())
889  Target->DarwinTargetVariantTriple =
890  llvm::Triple(Opts->DarwinTargetVariantTriple);
891 
892  if (!Target->validateTarget(Diags))
893  return nullptr;
894 
895  Target->CheckFixedPointBits();
896 
897  return Target.release();
898 }
899 /// validateOpenCLTarget - Check that OpenCL target has valid
900 /// options setting based on OpenCL version.
901 bool TargetInfo::validateOpenCLTarget(const LangOptions &Opts,
902  DiagnosticsEngine &Diags) const {
903  const llvm::StringMap<bool> &OpenCLFeaturesMap = getSupportedOpenCLOpts();
904 
905  auto diagnoseNotSupportedCore = [&](llvm::StringRef Name, auto... OptArgs) {
906  if (OpenCLOptions::isOpenCLOptionCoreIn(Opts, OptArgs...) &&
907  !hasFeatureEnabled(OpenCLFeaturesMap, Name))
908  Diags.Report(diag::warn_opencl_unsupported_core_feature)
909  << Name << Opts.OpenCLCPlusPlus
910  << Opts.getOpenCLVersionTuple().getAsString();
911  };
912 #define OPENCL_GENERIC_EXTENSION(Ext, ...) \
913  diagnoseNotSupportedCore(#Ext, __VA_ARGS__);
914 #include "clang/Basic/OpenCLExtensions.def"
915 
916  // Validate that feature macros are set properly for OpenCL C 3.0.
917  // In other cases assume that target is always valid.
918  if (Opts.getOpenCLCompatibleVersion() < 300)
919  return true;
920 
921  return OpenCLOptions::diagnoseUnsupportedFeatureDependencies(*this, Diags) &&
922  OpenCLOptions::diagnoseFeatureExtensionDifferences(*this, Diags);
923 }
AIX
clang::driver::toolchains::AIX AIX
Definition: AIX.cpp:22
Diagnostic.h
Defines the Diagnostic-related interfaces.
Target
llvm::MachO::Target Target
Definition: MachO.h:50
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:193
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1553
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:482
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:218
clang::TargetInfo::getSupportedOpenCLOpts
llvm::StringMap< bool > & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
Definition: TargetInfo.h:1750
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:1379
clang::TargetInfo::CreateTargetInfo
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:815
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:901
clang::TargetOptions
Options for controlling the target.
Definition: TargetOptions.h:26
clang::TargetOptions::HostTriple
std::string HostTriple
When compiling for the device side, contains the triple used to compile for the host.
Definition: TargetOptions.h:33
clang::targets::defineCPUMacros
void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning)
Definition: Targets.cpp:76
clang::targets::DefineStd
void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
Definition: Targets.cpp:60
clang::targets::AllocateTarget
std::unique_ptr< TargetInfo > AllocateTarget(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: Targets.cpp:112
clang::targets::addCygMingDefines
void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder)
Definition: Targets.cpp:83
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition: CalledOnceCheck.h:17
normalize
float __ovld __cnfn normalize(float)
Returns a vector in the same direction as p but with a length of 1.
Generated on Fri Jun 28 2024 01:36:51 for clang by doxygen 1.9.1