clang  10.0.0svn
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/Hexagon.h"
23 #include "Targets/Lanai.h"
24 #include "Targets/Le64.h"
25 #include "Targets/MSP430.h"
26 #include "Targets/Mips.h"
27 #include "Targets/NVPTX.h"
28 #include "Targets/OSTargets.h"
29 #include "Targets/PNaCl.h"
30 #include "Targets/PPC.h"
31 #include "Targets/RISCV.h"
32 #include "Targets/SPIR.h"
33 #include "Targets/Sparc.h"
34 #include "Targets/SystemZ.h"
35 #include "Targets/TCE.h"
36 #include "Targets/WebAssembly.h"
37 #include "Targets/X86.h"
38 #include "Targets/XCore.h"
39 #include "clang/Basic/Diagnostic.h"
40 #include "llvm/ADT/StringExtras.h"
41 #include "llvm/ADT/Triple.h"
42 
43 using namespace clang;
44 
45 namespace clang {
46 namespace targets {
47 //===----------------------------------------------------------------------===//
48 // Common code shared among targets.
49 //===----------------------------------------------------------------------===//
50 
51 /// DefineStd - Define a macro name and standard variants. For example if
52 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
53 /// when in GNU mode.
54 void DefineStd(MacroBuilder &Builder, StringRef MacroName,
55  const LangOptions &Opts) {
56  assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
57 
58  // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
59  // in the user's namespace.
60  if (Opts.GNUMode)
61  Builder.defineMacro(MacroName);
62 
63  // Define __unix.
64  Builder.defineMacro("__" + MacroName);
65 
66  // Define __unix__.
67  Builder.defineMacro("__" + MacroName + "__");
68 }
69 
70 void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning) {
71  Builder.defineMacro("__" + CPUName);
72  Builder.defineMacro("__" + CPUName + "__");
73  if (Tuning)
74  Builder.defineMacro("__tune_" + CPUName + "__");
75 }
76 
77 void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
78  // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
79  // supports __declspec natively under -fms-extensions, but we define a no-op
80  // __declspec macro anyway for pre-processor compatibility.
81  if (Opts.MicrosoftExt)
82  Builder.defineMacro("__declspec", "__declspec");
83  else
84  Builder.defineMacro("__declspec(a)", "__attribute__((a))");
85 
86  if (!Opts.MicrosoftExt) {
87  // Provide macros for all the calling convention keywords. Provide both
88  // single and double underscore prefixed variants. These are available on
89  // x64 as well as x86, even though they have no effect.
90  const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
91  for (const char *CC : CCs) {
92  std::string GCCSpelling = "__attribute__((__";
93  GCCSpelling += CC;
94  GCCSpelling += "__))";
95  Builder.defineMacro(Twine("_") + CC, GCCSpelling);
96  Builder.defineMacro(Twine("__") + CC, GCCSpelling);
97  }
98  }
99 }
100 
101 //===----------------------------------------------------------------------===//
102 // Driver code
103 //===----------------------------------------------------------------------===//
104 
105 TargetInfo *AllocateTarget(const llvm::Triple &Triple,
106  const TargetOptions &Opts) {
107  llvm::Triple::OSType os = Triple.getOS();
108 
109  switch (Triple.getArch()) {
110  default:
111  return nullptr;
112 
113  case llvm::Triple::arc:
114  return new ARCTargetInfo(Triple, Opts);
115 
116  case llvm::Triple::xcore:
117  return new XCoreTargetInfo(Triple, Opts);
118 
119  case llvm::Triple::hexagon:
120  return new HexagonTargetInfo(Triple, Opts);
121 
122  case llvm::Triple::lanai:
123  return new LanaiTargetInfo(Triple, Opts);
124 
125  case llvm::Triple::aarch64:
126  if (Triple.isOSDarwin())
127  return new DarwinAArch64TargetInfo(Triple, Opts);
128 
129  switch (os) {
130  case llvm::Triple::CloudABI:
131  return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
132  case llvm::Triple::FreeBSD:
133  return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
134  case llvm::Triple::Fuchsia:
135  return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
136  case llvm::Triple::Linux:
137  return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
138  case llvm::Triple::NetBSD:
139  return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
140  case llvm::Triple::OpenBSD:
141  return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
142  case llvm::Triple::Win32:
143  switch (Triple.getEnvironment()) {
144  case llvm::Triple::GNU:
145  return new MinGWARM64TargetInfo(Triple, Opts);
146  case llvm::Triple::MSVC:
147  default: // Assume MSVC for unknown environments
148  return new MicrosoftARM64TargetInfo(Triple, Opts);
149  }
150  default:
151  return new AArch64leTargetInfo(Triple, Opts);
152  }
153 
154  case llvm::Triple::aarch64_be:
155  switch (os) {
156  case llvm::Triple::FreeBSD:
157  return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
158  case llvm::Triple::Fuchsia:
159  return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
160  case llvm::Triple::Linux:
161  return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
162  case llvm::Triple::NetBSD:
163  return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
164  default:
165  return new AArch64beTargetInfo(Triple, Opts);
166  }
167 
168  case llvm::Triple::arm:
169  case llvm::Triple::thumb:
170  if (Triple.isOSBinFormatMachO())
171  return new DarwinARMTargetInfo(Triple, Opts);
172 
173  switch (os) {
174  case llvm::Triple::CloudABI:
175  return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
176  case llvm::Triple::Linux:
177  return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
178  case llvm::Triple::FreeBSD:
179  return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
180  case llvm::Triple::NetBSD:
181  return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
182  case llvm::Triple::OpenBSD:
183  return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
184  case llvm::Triple::RTEMS:
185  return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
186  case llvm::Triple::NaCl:
187  return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
188  case llvm::Triple::Win32:
189  switch (Triple.getEnvironment()) {
190  case llvm::Triple::Cygnus:
191  return new CygwinARMTargetInfo(Triple, Opts);
192  case llvm::Triple::GNU:
193  return new MinGWARMTargetInfo(Triple, Opts);
194  case llvm::Triple::Itanium:
195  return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
196  case llvm::Triple::MSVC:
197  default: // Assume MSVC for unknown environments
198  return new MicrosoftARMleTargetInfo(Triple, Opts);
199  }
200  default:
201  return new ARMleTargetInfo(Triple, Opts);
202  }
203 
204  case llvm::Triple::armeb:
205  case llvm::Triple::thumbeb:
206  if (Triple.isOSDarwin())
207  return new DarwinARMTargetInfo(Triple, Opts);
208 
209  switch (os) {
210  case llvm::Triple::Linux:
211  return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
212  case llvm::Triple::FreeBSD:
213  return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
214  case llvm::Triple::NetBSD:
215  return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
216  case llvm::Triple::OpenBSD:
217  return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
218  case llvm::Triple::RTEMS:
219  return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
220  case llvm::Triple::NaCl:
221  return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
222  default:
223  return new ARMbeTargetInfo(Triple, Opts);
224  }
225 
226  case llvm::Triple::avr:
227  return new AVRTargetInfo(Triple, Opts);
228  case llvm::Triple::bpfeb:
229  case llvm::Triple::bpfel:
230  return new BPFTargetInfo(Triple, Opts);
231 
232  case llvm::Triple::msp430:
233  return new MSP430TargetInfo(Triple, Opts);
234 
235  case llvm::Triple::mips:
236  switch (os) {
237  case llvm::Triple::Linux:
238  return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
239  case llvm::Triple::RTEMS:
240  return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
241  case llvm::Triple::FreeBSD:
242  return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
243  case llvm::Triple::NetBSD:
244  return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
245  default:
246  return new MipsTargetInfo(Triple, Opts);
247  }
248 
249  case llvm::Triple::mipsel:
250  switch (os) {
251  case llvm::Triple::Linux:
252  return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
253  case llvm::Triple::RTEMS:
254  return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
255  case llvm::Triple::FreeBSD:
256  return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
257  case llvm::Triple::NetBSD:
258  return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
259  case llvm::Triple::NaCl:
260  return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
261  default:
262  return new MipsTargetInfo(Triple, Opts);
263  }
264 
265  case llvm::Triple::mips64:
266  switch (os) {
267  case llvm::Triple::Linux:
268  return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
269  case llvm::Triple::RTEMS:
270  return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
271  case llvm::Triple::FreeBSD:
272  return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
273  case llvm::Triple::NetBSD:
274  return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
275  case llvm::Triple::OpenBSD:
276  return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
277  default:
278  return new MipsTargetInfo(Triple, Opts);
279  }
280 
281  case llvm::Triple::mips64el:
282  switch (os) {
283  case llvm::Triple::Linux:
284  return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
285  case llvm::Triple::RTEMS:
286  return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
287  case llvm::Triple::FreeBSD:
288  return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
289  case llvm::Triple::NetBSD:
290  return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
291  case llvm::Triple::OpenBSD:
292  return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
293  default:
294  return new MipsTargetInfo(Triple, Opts);
295  }
296 
297  case llvm::Triple::le32:
298  switch (os) {
299  case llvm::Triple::NaCl:
300  return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
301  default:
302  return nullptr;
303  }
304 
305  case llvm::Triple::le64:
306  return new Le64TargetInfo(Triple, Opts);
307 
308  case llvm::Triple::ppc:
309  if (Triple.isOSDarwin())
310  return new DarwinPPC32TargetInfo(Triple, Opts);
311  switch (os) {
312  case llvm::Triple::Linux:
313  return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
314  case llvm::Triple::FreeBSD:
315  return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
316  case llvm::Triple::NetBSD:
317  return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
318  case llvm::Triple::OpenBSD:
319  return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
320  case llvm::Triple::RTEMS:
321  return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
322  case llvm::Triple::AIX:
323  return new AIXPPC32TargetInfo(Triple, Opts);
324  default:
325  return new PPC32TargetInfo(Triple, Opts);
326  }
327 
328  case llvm::Triple::ppc64:
329  if (Triple.isOSDarwin())
330  return new DarwinPPC64TargetInfo(Triple, Opts);
331  switch (os) {
332  case llvm::Triple::Linux:
333  return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
334  case llvm::Triple::Lv2:
335  return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
336  case llvm::Triple::FreeBSD:
337  return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
338  case llvm::Triple::NetBSD:
339  return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
340  case llvm::Triple::AIX:
341  return new AIXPPC64TargetInfo(Triple, Opts);
342  default:
343  return new PPC64TargetInfo(Triple, Opts);
344  }
345 
346  case llvm::Triple::ppc64le:
347  switch (os) {
348  case llvm::Triple::Linux:
349  return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
350  case llvm::Triple::NetBSD:
351  return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
352  default:
353  return new PPC64TargetInfo(Triple, Opts);
354  }
355 
356  case llvm::Triple::nvptx:
357  return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
358  case llvm::Triple::nvptx64:
359  return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
360 
361  case llvm::Triple::amdgcn:
362  case llvm::Triple::r600:
363  return new AMDGPUTargetInfo(Triple, Opts);
364 
365  case llvm::Triple::riscv32:
366  // TODO: add cases for NetBSD, RTEMS once tested.
367  switch (os) {
368  case llvm::Triple::FreeBSD:
369  return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts);
370  case llvm::Triple::Linux:
371  return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts);
372  default:
373  return new RISCV32TargetInfo(Triple, Opts);
374  }
375 
376  case llvm::Triple::riscv64:
377  // TODO: add cases for NetBSD, RTEMS once tested.
378  switch (os) {
379  case llvm::Triple::FreeBSD:
380  return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
381  case llvm::Triple::Linux:
382  return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
383  default:
384  return new RISCV64TargetInfo(Triple, Opts);
385  }
386 
387  case llvm::Triple::sparc:
388  switch (os) {
389  case llvm::Triple::Linux:
390  return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
391  case llvm::Triple::Solaris:
392  return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
393  case llvm::Triple::NetBSD:
394  return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
395  case llvm::Triple::OpenBSD:
396  return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
397  case llvm::Triple::RTEMS:
398  return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
399  default:
400  return new SparcV8TargetInfo(Triple, Opts);
401  }
402 
403  // The 'sparcel' architecture copies all the above cases except for Solaris.
404  case llvm::Triple::sparcel:
405  switch (os) {
406  case llvm::Triple::Linux:
407  return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
408  case llvm::Triple::NetBSD:
409  return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
410  case llvm::Triple::OpenBSD:
411  return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
412  case llvm::Triple::RTEMS:
413  return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
414  default:
415  return new SparcV8elTargetInfo(Triple, Opts);
416  }
417 
418  case llvm::Triple::sparcv9:
419  switch (os) {
420  case llvm::Triple::Linux:
421  return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
422  case llvm::Triple::Solaris:
423  return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
424  case llvm::Triple::NetBSD:
425  return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
426  case llvm::Triple::OpenBSD:
427  return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
428  case llvm::Triple::FreeBSD:
429  return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
430  default:
431  return new SparcV9TargetInfo(Triple, Opts);
432  }
433 
434  case llvm::Triple::systemz:
435  switch (os) {
436  case llvm::Triple::Linux:
437  return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
438  default:
439  return new SystemZTargetInfo(Triple, Opts);
440  }
441 
442  case llvm::Triple::tce:
443  return new TCETargetInfo(Triple, Opts);
444 
445  case llvm::Triple::tcele:
446  return new TCELETargetInfo(Triple, Opts);
447 
448  case llvm::Triple::x86:
449  if (Triple.isOSDarwin())
450  return new DarwinI386TargetInfo(Triple, Opts);
451 
452  switch (os) {
453  case llvm::Triple::Ananas:
454  return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
455  case llvm::Triple::CloudABI:
456  return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
457  case llvm::Triple::Linux: {
458  switch (Triple.getEnvironment()) {
459  default:
460  return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
461  case llvm::Triple::Android:
462  return new AndroidX86_32TargetInfo(Triple, Opts);
463  }
464  }
465  case llvm::Triple::DragonFly:
466  return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
467  case llvm::Triple::NetBSD:
468  return new NetBSDI386TargetInfo(Triple, Opts);
469  case llvm::Triple::OpenBSD:
470  return new OpenBSDI386TargetInfo(Triple, Opts);
471  case llvm::Triple::FreeBSD:
472  return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
473  case llvm::Triple::KFreeBSD:
474  return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
475  case llvm::Triple::Minix:
476  return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
477  case llvm::Triple::Solaris:
478  return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
479  case llvm::Triple::Win32: {
480  switch (Triple.getEnvironment()) {
481  case llvm::Triple::Cygnus:
482  return new CygwinX86_32TargetInfo(Triple, Opts);
483  case llvm::Triple::GNU:
484  return new MinGWX86_32TargetInfo(Triple, Opts);
485  case llvm::Triple::Itanium:
486  case llvm::Triple::MSVC:
487  default: // Assume MSVC for unknown environments
488  return new MicrosoftX86_32TargetInfo(Triple, Opts);
489  }
490  }
491  case llvm::Triple::Haiku:
492  return new HaikuX86_32TargetInfo(Triple, Opts);
493  case llvm::Triple::RTEMS:
494  return new RTEMSX86_32TargetInfo(Triple, Opts);
495  case llvm::Triple::NaCl:
496  return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
497  case llvm::Triple::ELFIAMCU:
498  return new MCUX86_32TargetInfo(Triple, Opts);
499  case llvm::Triple::Hurd:
500  return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts);
501  default:
502  return new X86_32TargetInfo(Triple, Opts);
503  }
504 
505  case llvm::Triple::x86_64:
506  if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
507  return new DarwinX86_64TargetInfo(Triple, Opts);
508 
509  switch (os) {
510  case llvm::Triple::Ananas:
511  return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
512  case llvm::Triple::CloudABI:
513  return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
514  case llvm::Triple::Linux: {
515  switch (Triple.getEnvironment()) {
516  default:
517  return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
518  case llvm::Triple::Android:
519  return new AndroidX86_64TargetInfo(Triple, Opts);
520  }
521  }
522  case llvm::Triple::DragonFly:
523  return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
524  case llvm::Triple::NetBSD:
525  return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
526  case llvm::Triple::OpenBSD:
527  return new OpenBSDX86_64TargetInfo(Triple, Opts);
528  case llvm::Triple::FreeBSD:
529  return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
530  case llvm::Triple::Fuchsia:
531  return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
532  case llvm::Triple::KFreeBSD:
533  return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
534  case llvm::Triple::Solaris:
535  return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
536  case llvm::Triple::Win32: {
537  switch (Triple.getEnvironment()) {
538  case llvm::Triple::Cygnus:
539  return new CygwinX86_64TargetInfo(Triple, Opts);
540  case llvm::Triple::GNU:
541  return new MinGWX86_64TargetInfo(Triple, Opts);
542  case llvm::Triple::MSVC:
543  default: // Assume MSVC for unknown environments
544  return new MicrosoftX86_64TargetInfo(Triple, Opts);
545  }
546  }
547  case llvm::Triple::Haiku:
548  return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
549  case llvm::Triple::NaCl:
550  return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
551  case llvm::Triple::PS4:
552  return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
553  default:
554  return new X86_64TargetInfo(Triple, Opts);
555  }
556 
557  case llvm::Triple::spir: {
558  if (Triple.getOS() != llvm::Triple::UnknownOS ||
559  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
560  return nullptr;
561  return new SPIR32TargetInfo(Triple, Opts);
562  }
563  case llvm::Triple::spir64: {
564  if (Triple.getOS() != llvm::Triple::UnknownOS ||
565  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
566  return nullptr;
567  return new SPIR64TargetInfo(Triple, Opts);
568  }
569  case llvm::Triple::wasm32:
570  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
571  Triple.getVendor() != llvm::Triple::UnknownVendor ||
572  !Triple.isOSBinFormatWasm())
573  return nullptr;
574  switch (Triple.getOS()) {
575  case llvm::Triple::WASI:
576  return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
577  case llvm::Triple::Emscripten:
578  return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
579  case llvm::Triple::UnknownOS:
580  return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
581  default:
582  return nullptr;
583  }
584  case llvm::Triple::wasm64:
585  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
586  Triple.getVendor() != llvm::Triple::UnknownVendor ||
587  !Triple.isOSBinFormatWasm())
588  return nullptr;
589  switch (Triple.getOS()) {
590  case llvm::Triple::WASI:
591  return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
592  case llvm::Triple::Emscripten:
593  return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
594  case llvm::Triple::UnknownOS:
595  return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
596  default:
597  return nullptr;
598  }
599 
600  case llvm::Triple::renderscript32:
601  return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
602  case llvm::Triple::renderscript64:
603  return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
604  }
605 }
606 } // namespace targets
607 } // namespace clang
608 
609 using namespace clang::targets;
610 /// CreateTargetInfo - Return the target info object for the specified target
611 /// options.
612 TargetInfo *
614  const std::shared_ptr<TargetOptions> &Opts) {
615  llvm::Triple Triple(Opts->Triple);
616 
617  // Construct the target
618  std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
619  if (!Target) {
620  Diags.Report(diag::err_target_unknown_triple) << Triple.str();
621  return nullptr;
622  }
623  Target->TargetOpts = Opts;
624 
625  // Set the target CPU if specified.
626  if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
627  Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
628  SmallVector<StringRef, 32> ValidList;
629  Target->fillValidCPUList(ValidList);
630  if (!ValidList.empty())
631  Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
632  return nullptr;
633  }
634 
635  // Set the target ABI if specified.
636  if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
637  Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
638  return nullptr;
639  }
640 
641  // Set the fp math unit.
642  if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
643  Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
644  return nullptr;
645  }
646 
647  // Compute the default target features, we need the target to handle this
648  // because features may have dependencies on one another.
649  llvm::StringMap<bool> Features;
650  if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
651  Opts->FeaturesAsWritten))
652  return nullptr;
653 
654  // Add the features to the compile options.
655  Opts->Features.clear();
656  for (const auto &F : Features)
657  Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
658  // Sort here, so we handle the features in a predictable order. (This matters
659  // when we're dealing with features that overlap.)
660  llvm::sort(Opts->Features);
661 
662  if (!Target->handleTargetFeatures(Opts->Features, Diags))
663  return nullptr;
664 
665  Target->setSupportedOpenCLOpts();
666  Target->setOpenCLExtensionOpts();
667  Target->setMaxAtomicWidth();
668 
669  if (!Target->validateTarget(Diags))
670  return nullptr;
671 
672  Target->CheckFixedPointBits();
673 
674  return Target.release();
675 }
void DefineStd(MacroBuilder &Builder, StringRef MacroName, const LangOptions &Opts)
DefineStd - Define a macro name and standard variants.
Definition: Targets.cpp:54
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1290
Options for controlling the target.
Definition: TargetOptions.h:26
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
Defines the Diagnostic-related interfaces.
Exposes information about the current target.
Definition: TargetInfo.h:161
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:613
TargetInfo * AllocateTarget(const llvm::Triple &Triple, const TargetOptions &Opts)
Definition: Targets.cpp:105
void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder)
Definition: Targets.cpp:77
Dataflow Directional Tag Classes.
void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName, bool Tuning)
Definition: Targets.cpp:70
void defineMacro(const Twine &Name, const Twine &Value="1")
Append a #define line for macro of the form "\#define Name Value\n".
Definition: MacroBuilder.h:29