clang  9.0.0
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 FreeBSD, NetBSD, RTEMS once tested.
367  if (os == llvm::Triple::Linux)
368  return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts);
369  return new RISCV32TargetInfo(Triple, Opts);
370  case llvm::Triple::riscv64:
371  // TODO: add cases for FreeBSD, NetBSD, RTEMS once tested.
372  if (os == llvm::Triple::Linux)
373  return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
374  return new RISCV64TargetInfo(Triple, Opts);
375 
376  case llvm::Triple::sparc:
377  switch (os) {
378  case llvm::Triple::Linux:
379  return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
380  case llvm::Triple::Solaris:
381  return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
382  case llvm::Triple::NetBSD:
383  return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
384  case llvm::Triple::OpenBSD:
385  return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
386  case llvm::Triple::RTEMS:
387  return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
388  default:
389  return new SparcV8TargetInfo(Triple, Opts);
390  }
391 
392  // The 'sparcel' architecture copies all the above cases except for Solaris.
393  case llvm::Triple::sparcel:
394  switch (os) {
395  case llvm::Triple::Linux:
396  return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
397  case llvm::Triple::NetBSD:
398  return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
399  case llvm::Triple::OpenBSD:
400  return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
401  case llvm::Triple::RTEMS:
402  return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
403  default:
404  return new SparcV8elTargetInfo(Triple, Opts);
405  }
406 
407  case llvm::Triple::sparcv9:
408  switch (os) {
409  case llvm::Triple::Linux:
410  return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
411  case llvm::Triple::Solaris:
412  return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
413  case llvm::Triple::NetBSD:
414  return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
415  case llvm::Triple::OpenBSD:
416  return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
417  case llvm::Triple::FreeBSD:
418  return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
419  default:
420  return new SparcV9TargetInfo(Triple, Opts);
421  }
422 
423  case llvm::Triple::systemz:
424  switch (os) {
425  case llvm::Triple::Linux:
426  return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
427  default:
428  return new SystemZTargetInfo(Triple, Opts);
429  }
430 
431  case llvm::Triple::tce:
432  return new TCETargetInfo(Triple, Opts);
433 
434  case llvm::Triple::tcele:
435  return new TCELETargetInfo(Triple, Opts);
436 
437  case llvm::Triple::x86:
438  if (Triple.isOSDarwin())
439  return new DarwinI386TargetInfo(Triple, Opts);
440 
441  switch (os) {
442  case llvm::Triple::Ananas:
443  return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
444  case llvm::Triple::CloudABI:
445  return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
446  case llvm::Triple::Linux: {
447  switch (Triple.getEnvironment()) {
448  default:
449  return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
450  case llvm::Triple::Android:
451  return new AndroidX86_32TargetInfo(Triple, Opts);
452  }
453  }
454  case llvm::Triple::DragonFly:
455  return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
456  case llvm::Triple::NetBSD:
457  return new NetBSDI386TargetInfo(Triple, Opts);
458  case llvm::Triple::OpenBSD:
459  return new OpenBSDI386TargetInfo(Triple, Opts);
460  case llvm::Triple::FreeBSD:
461  return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
462  case llvm::Triple::KFreeBSD:
463  return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
464  case llvm::Triple::Minix:
465  return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
466  case llvm::Triple::Solaris:
467  return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
468  case llvm::Triple::Win32: {
469  switch (Triple.getEnvironment()) {
470  case llvm::Triple::Cygnus:
471  return new CygwinX86_32TargetInfo(Triple, Opts);
472  case llvm::Triple::GNU:
473  return new MinGWX86_32TargetInfo(Triple, Opts);
474  case llvm::Triple::Itanium:
475  case llvm::Triple::MSVC:
476  default: // Assume MSVC for unknown environments
477  return new MicrosoftX86_32TargetInfo(Triple, Opts);
478  }
479  }
480  case llvm::Triple::Haiku:
481  return new HaikuX86_32TargetInfo(Triple, Opts);
482  case llvm::Triple::RTEMS:
483  return new RTEMSX86_32TargetInfo(Triple, Opts);
484  case llvm::Triple::NaCl:
485  return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
486  case llvm::Triple::ELFIAMCU:
487  return new MCUX86_32TargetInfo(Triple, Opts);
488  case llvm::Triple::Hurd:
489  return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts);
490  default:
491  return new X86_32TargetInfo(Triple, Opts);
492  }
493 
494  case llvm::Triple::x86_64:
495  if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
496  return new DarwinX86_64TargetInfo(Triple, Opts);
497 
498  switch (os) {
499  case llvm::Triple::Ananas:
500  return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
501  case llvm::Triple::CloudABI:
502  return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
503  case llvm::Triple::Linux: {
504  switch (Triple.getEnvironment()) {
505  default:
506  return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
507  case llvm::Triple::Android:
508  return new AndroidX86_64TargetInfo(Triple, Opts);
509  }
510  }
511  case llvm::Triple::DragonFly:
512  return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
513  case llvm::Triple::NetBSD:
514  return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
515  case llvm::Triple::OpenBSD:
516  return new OpenBSDX86_64TargetInfo(Triple, Opts);
517  case llvm::Triple::FreeBSD:
518  return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
519  case llvm::Triple::Fuchsia:
520  return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
521  case llvm::Triple::KFreeBSD:
522  return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
523  case llvm::Triple::Solaris:
524  return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
525  case llvm::Triple::Win32: {
526  switch (Triple.getEnvironment()) {
527  case llvm::Triple::Cygnus:
528  return new CygwinX86_64TargetInfo(Triple, Opts);
529  case llvm::Triple::GNU:
530  return new MinGWX86_64TargetInfo(Triple, Opts);
531  case llvm::Triple::MSVC:
532  default: // Assume MSVC for unknown environments
533  return new MicrosoftX86_64TargetInfo(Triple, Opts);
534  }
535  }
536  case llvm::Triple::Haiku:
537  return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
538  case llvm::Triple::NaCl:
539  return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
540  case llvm::Triple::PS4:
541  return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
542  default:
543  return new X86_64TargetInfo(Triple, Opts);
544  }
545 
546  case llvm::Triple::spir: {
547  if (Triple.getOS() != llvm::Triple::UnknownOS ||
548  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
549  return nullptr;
550  return new SPIR32TargetInfo(Triple, Opts);
551  }
552  case llvm::Triple::spir64: {
553  if (Triple.getOS() != llvm::Triple::UnknownOS ||
554  Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
555  return nullptr;
556  return new SPIR64TargetInfo(Triple, Opts);
557  }
558  case llvm::Triple::wasm32:
559  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
560  Triple.getVendor() != llvm::Triple::UnknownVendor ||
561  !Triple.isOSBinFormatWasm())
562  return nullptr;
563  switch (Triple.getOS()) {
564  case llvm::Triple::WASI:
565  return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
566  case llvm::Triple::Emscripten:
567  return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
568  case llvm::Triple::UnknownOS:
569  return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
570  default:
571  return nullptr;
572  }
573  case llvm::Triple::wasm64:
574  if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
575  Triple.getVendor() != llvm::Triple::UnknownVendor ||
576  !Triple.isOSBinFormatWasm())
577  return nullptr;
578  switch (Triple.getOS()) {
579  case llvm::Triple::WASI:
580  return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
581  case llvm::Triple::Emscripten:
582  return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
583  case llvm::Triple::UnknownOS:
584  return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
585  default:
586  return nullptr;
587  }
588 
589  case llvm::Triple::renderscript32:
590  return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
591  case llvm::Triple::renderscript64:
592  return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
593  }
594 }
595 } // namespace targets
596 } // namespace clang
597 
598 using namespace clang::targets;
599 /// CreateTargetInfo - Return the target info object for the specified target
600 /// options.
601 TargetInfo *
603  const std::shared_ptr<TargetOptions> &Opts) {
604  llvm::Triple Triple(Opts->Triple);
605 
606  // Construct the target
607  std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
608  if (!Target) {
609  Diags.Report(diag::err_target_unknown_triple) << Triple.str();
610  return nullptr;
611  }
612  Target->TargetOpts = Opts;
613 
614  // Set the target CPU if specified.
615  if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
616  Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
617  SmallVector<StringRef, 32> ValidList;
618  Target->fillValidCPUList(ValidList);
619  if (!ValidList.empty())
620  Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
621  return nullptr;
622  }
623 
624  // Set the target ABI if specified.
625  if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
626  Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
627  return nullptr;
628  }
629 
630  // Set the fp math unit.
631  if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
632  Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
633  return nullptr;
634  }
635 
636  // Compute the default target features, we need the target to handle this
637  // because features may have dependencies on one another.
638  llvm::StringMap<bool> Features;
639  if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
640  Opts->FeaturesAsWritten))
641  return nullptr;
642 
643  // Add the features to the compile options.
644  Opts->Features.clear();
645  for (const auto &F : Features)
646  Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
647  // Sort here, so we handle the features in a predictable order. (This matters
648  // when we're dealing with features that overlap.)
649  llvm::sort(Opts->Features);
650 
651  if (!Target->handleTargetFeatures(Opts->Features, Diags))
652  return nullptr;
653 
654  Target->setSupportedOpenCLOpts();
655  Target->setOpenCLExtensionOpts();
656  Target->setMaxAtomicWidth();
657 
658  if (!Target->validateTarget(Diags))
659  return nullptr;
660 
661  Target->CheckFixedPointBits();
662 
663  return Target.release();
664 }
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:1297
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:602
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