xref: /openbsd-src/gnu/llvm/clang/lib/Basic/Targets.cpp (revision 46035553bfdd96e63c94e32da0210227ec2e3cf1)
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_32:
126     if (Triple.isOSDarwin())
127       return new DarwinAArch64TargetInfo(Triple, Opts);
128 
129     return nullptr;
130   case llvm::Triple::aarch64:
131     if (Triple.isOSDarwin())
132       return new DarwinAArch64TargetInfo(Triple, Opts);
133 
134     switch (os) {
135     case llvm::Triple::CloudABI:
136       return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
137     case llvm::Triple::FreeBSD:
138       return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
139     case llvm::Triple::Fuchsia:
140       return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
141     case llvm::Triple::Linux:
142       return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
143     case llvm::Triple::NetBSD:
144       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
145     case llvm::Triple::OpenBSD:
146       return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
147     case llvm::Triple::Win32:
148       switch (Triple.getEnvironment()) {
149       case llvm::Triple::GNU:
150         return new MinGWARM64TargetInfo(Triple, Opts);
151       case llvm::Triple::MSVC:
152       default: // Assume MSVC for unknown environments
153         return new MicrosoftARM64TargetInfo(Triple, Opts);
154       }
155     default:
156       return new AArch64leTargetInfo(Triple, Opts);
157     }
158 
159   case llvm::Triple::aarch64_be:
160     switch (os) {
161     case llvm::Triple::FreeBSD:
162       return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
163     case llvm::Triple::Fuchsia:
164       return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
165     case llvm::Triple::Linux:
166       return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
167     case llvm::Triple::NetBSD:
168       return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
169     default:
170       return new AArch64beTargetInfo(Triple, Opts);
171     }
172 
173   case llvm::Triple::arm:
174   case llvm::Triple::thumb:
175     if (Triple.isOSBinFormatMachO())
176       return new DarwinARMTargetInfo(Triple, Opts);
177 
178     switch (os) {
179     case llvm::Triple::CloudABI:
180       return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
181     case llvm::Triple::Linux:
182       return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
183     case llvm::Triple::FreeBSD:
184       return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
185     case llvm::Triple::NetBSD:
186       return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
187     case llvm::Triple::OpenBSD:
188       return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
189     case llvm::Triple::RTEMS:
190       return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
191     case llvm::Triple::NaCl:
192       return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
193     case llvm::Triple::Win32:
194       switch (Triple.getEnvironment()) {
195       case llvm::Triple::Cygnus:
196         return new CygwinARMTargetInfo(Triple, Opts);
197       case llvm::Triple::GNU:
198         return new MinGWARMTargetInfo(Triple, Opts);
199       case llvm::Triple::Itanium:
200         return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
201       case llvm::Triple::MSVC:
202       default: // Assume MSVC for unknown environments
203         return new MicrosoftARMleTargetInfo(Triple, Opts);
204       }
205     default:
206       return new ARMleTargetInfo(Triple, Opts);
207     }
208 
209   case llvm::Triple::armeb:
210   case llvm::Triple::thumbeb:
211     if (Triple.isOSDarwin())
212       return new DarwinARMTargetInfo(Triple, Opts);
213 
214     switch (os) {
215     case llvm::Triple::Linux:
216       return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
217     case llvm::Triple::FreeBSD:
218       return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
219     case llvm::Triple::NetBSD:
220       return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
221     case llvm::Triple::OpenBSD:
222       return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
223     case llvm::Triple::RTEMS:
224       return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
225     case llvm::Triple::NaCl:
226       return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
227     default:
228       return new ARMbeTargetInfo(Triple, Opts);
229     }
230 
231   case llvm::Triple::avr:
232     return new AVRTargetInfo(Triple, Opts);
233   case llvm::Triple::bpfeb:
234   case llvm::Triple::bpfel:
235     return new BPFTargetInfo(Triple, Opts);
236 
237   case llvm::Triple::msp430:
238     return new MSP430TargetInfo(Triple, Opts);
239 
240   case llvm::Triple::mips:
241     switch (os) {
242     case llvm::Triple::Linux:
243       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
244     case llvm::Triple::RTEMS:
245       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
246     case llvm::Triple::FreeBSD:
247       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
248     case llvm::Triple::NetBSD:
249       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
250     default:
251       return new MipsTargetInfo(Triple, Opts);
252     }
253 
254   case llvm::Triple::mipsel:
255     switch (os) {
256     case llvm::Triple::Linux:
257       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
258     case llvm::Triple::RTEMS:
259       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
260     case llvm::Triple::FreeBSD:
261       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
262     case llvm::Triple::NetBSD:
263       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
264     case llvm::Triple::NaCl:
265       return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
266     default:
267       return new MipsTargetInfo(Triple, Opts);
268     }
269 
270   case llvm::Triple::mips64:
271     switch (os) {
272     case llvm::Triple::Linux:
273       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
274     case llvm::Triple::RTEMS:
275       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
276     case llvm::Triple::FreeBSD:
277       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
278     case llvm::Triple::NetBSD:
279       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
280     case llvm::Triple::OpenBSD:
281       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
282     default:
283       return new MipsTargetInfo(Triple, Opts);
284     }
285 
286   case llvm::Triple::mips64el:
287     switch (os) {
288     case llvm::Triple::Linux:
289       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
290     case llvm::Triple::RTEMS:
291       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
292     case llvm::Triple::FreeBSD:
293       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
294     case llvm::Triple::NetBSD:
295       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
296     case llvm::Triple::OpenBSD:
297       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
298     default:
299       return new MipsTargetInfo(Triple, Opts);
300     }
301 
302   case llvm::Triple::le32:
303     switch (os) {
304     case llvm::Triple::NaCl:
305       return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
306     default:
307       return nullptr;
308     }
309 
310   case llvm::Triple::le64:
311     return new Le64TargetInfo(Triple, Opts);
312 
313   case llvm::Triple::ppc:
314     if (Triple.isOSDarwin())
315       return new DarwinPPC32TargetInfo(Triple, Opts);
316     switch (os) {
317     case llvm::Triple::Linux:
318       return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
319     case llvm::Triple::FreeBSD:
320       return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
321     case llvm::Triple::NetBSD:
322       return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
323     case llvm::Triple::OpenBSD:
324       return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
325     case llvm::Triple::RTEMS:
326       return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
327     case llvm::Triple::AIX:
328       return new AIXPPC32TargetInfo(Triple, Opts);
329     default:
330       return new PPC32TargetInfo(Triple, Opts);
331     }
332 
333   case llvm::Triple::ppc64:
334     if (Triple.isOSDarwin())
335       return new DarwinPPC64TargetInfo(Triple, Opts);
336     switch (os) {
337     case llvm::Triple::Linux:
338       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
339     case llvm::Triple::Lv2:
340       return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
341     case llvm::Triple::FreeBSD:
342       return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
343     case llvm::Triple::NetBSD:
344       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
345     case llvm::Triple::OpenBSD:
346       return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
347     case llvm::Triple::AIX:
348       return new AIXPPC64TargetInfo(Triple, Opts);
349     default:
350       return new PPC64TargetInfo(Triple, Opts);
351     }
352 
353   case llvm::Triple::ppc64le:
354     switch (os) {
355     case llvm::Triple::Linux:
356       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
357     case llvm::Triple::NetBSD:
358       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
359     case llvm::Triple::OpenBSD:
360       return new OpenBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
361     default:
362       return new PPC64TargetInfo(Triple, Opts);
363     }
364 
365   case llvm::Triple::nvptx:
366     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
367   case llvm::Triple::nvptx64:
368     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
369 
370   case llvm::Triple::amdgcn:
371   case llvm::Triple::r600:
372     return new AMDGPUTargetInfo(Triple, Opts);
373 
374   case llvm::Triple::riscv32:
375     // TODO: add cases for NetBSD, RTEMS once tested.
376     switch (os) {
377     case llvm::Triple::FreeBSD:
378       return new FreeBSDTargetInfo<RISCV32TargetInfo>(Triple, Opts);
379     case llvm::Triple::Linux:
380       return new LinuxTargetInfo<RISCV32TargetInfo>(Triple, Opts);
381     default:
382       return new RISCV32TargetInfo(Triple, Opts);
383     }
384 
385   case llvm::Triple::riscv64:
386     // TODO: add cases for NetBSD, RTEMS once tested.
387     switch (os) {
388     case llvm::Triple::FreeBSD:
389       return new FreeBSDTargetInfo<RISCV64TargetInfo>(Triple, Opts);
390     case llvm::Triple::Fuchsia:
391       return new FuchsiaTargetInfo<RISCV64TargetInfo>(Triple, Opts);
392     case llvm::Triple::Linux:
393       return new LinuxTargetInfo<RISCV64TargetInfo>(Triple, Opts);
394     default:
395       return new RISCV64TargetInfo(Triple, Opts);
396     }
397 
398   case llvm::Triple::sparc:
399     switch (os) {
400     case llvm::Triple::Linux:
401       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
402     case llvm::Triple::Solaris:
403       return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
404     case llvm::Triple::NetBSD:
405       return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
406     case llvm::Triple::OpenBSD:
407       return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
408     case llvm::Triple::RTEMS:
409       return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
410     default:
411       return new SparcV8TargetInfo(Triple, Opts);
412     }
413 
414   // The 'sparcel' architecture copies all the above cases except for Solaris.
415   case llvm::Triple::sparcel:
416     switch (os) {
417     case llvm::Triple::Linux:
418       return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
419     case llvm::Triple::NetBSD:
420       return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
421     case llvm::Triple::OpenBSD:
422       return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
423     case llvm::Triple::RTEMS:
424       return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
425     default:
426       return new SparcV8elTargetInfo(Triple, Opts);
427     }
428 
429   case llvm::Triple::sparcv9:
430     switch (os) {
431     case llvm::Triple::Linux:
432       return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
433     case llvm::Triple::Solaris:
434       return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
435     case llvm::Triple::NetBSD:
436       return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
437     case llvm::Triple::OpenBSD:
438       return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
439     case llvm::Triple::FreeBSD:
440       return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
441     default:
442       return new SparcV9TargetInfo(Triple, Opts);
443     }
444 
445   case llvm::Triple::systemz:
446     switch (os) {
447     case llvm::Triple::Linux:
448       return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
449     default:
450       return new SystemZTargetInfo(Triple, Opts);
451     }
452 
453   case llvm::Triple::tce:
454     return new TCETargetInfo(Triple, Opts);
455 
456   case llvm::Triple::tcele:
457     return new TCELETargetInfo(Triple, Opts);
458 
459   case llvm::Triple::x86:
460     if (Triple.isOSDarwin())
461       return new DarwinI386TargetInfo(Triple, Opts);
462 
463     switch (os) {
464     case llvm::Triple::Ananas:
465       return new AnanasTargetInfo<X86_32TargetInfo>(Triple, Opts);
466     case llvm::Triple::CloudABI:
467       return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
468     case llvm::Triple::Linux: {
469       switch (Triple.getEnvironment()) {
470       default:
471         return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
472       case llvm::Triple::Android:
473         return new AndroidX86_32TargetInfo(Triple, Opts);
474       }
475     }
476     case llvm::Triple::DragonFly:
477       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
478     case llvm::Triple::NetBSD:
479       return new NetBSDI386TargetInfo(Triple, Opts);
480     case llvm::Triple::OpenBSD:
481       return new OpenBSDI386TargetInfo(Triple, Opts);
482     case llvm::Triple::FreeBSD:
483       return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
484     case llvm::Triple::KFreeBSD:
485       return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
486     case llvm::Triple::Minix:
487       return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
488     case llvm::Triple::Solaris:
489       return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
490     case llvm::Triple::Win32: {
491       switch (Triple.getEnvironment()) {
492       case llvm::Triple::Cygnus:
493         return new CygwinX86_32TargetInfo(Triple, Opts);
494       case llvm::Triple::GNU:
495         return new MinGWX86_32TargetInfo(Triple, Opts);
496       case llvm::Triple::Itanium:
497       case llvm::Triple::MSVC:
498       default: // Assume MSVC for unknown environments
499         return new MicrosoftX86_32TargetInfo(Triple, Opts);
500       }
501     }
502     case llvm::Triple::Haiku:
503       return new HaikuX86_32TargetInfo(Triple, Opts);
504     case llvm::Triple::RTEMS:
505       return new RTEMSX86_32TargetInfo(Triple, Opts);
506     case llvm::Triple::NaCl:
507       return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
508     case llvm::Triple::ELFIAMCU:
509       return new MCUX86_32TargetInfo(Triple, Opts);
510     case llvm::Triple::Hurd:
511       return new HurdTargetInfo<X86_32TargetInfo>(Triple, Opts);
512     default:
513       return new X86_32TargetInfo(Triple, Opts);
514     }
515 
516   case llvm::Triple::x86_64:
517     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
518       return new DarwinX86_64TargetInfo(Triple, Opts);
519 
520     switch (os) {
521     case llvm::Triple::Ananas:
522       return new AnanasTargetInfo<X86_64TargetInfo>(Triple, Opts);
523     case llvm::Triple::CloudABI:
524       return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
525     case llvm::Triple::Linux: {
526       switch (Triple.getEnvironment()) {
527       default:
528         return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
529       case llvm::Triple::Android:
530         return new AndroidX86_64TargetInfo(Triple, Opts);
531       }
532     }
533     case llvm::Triple::DragonFly:
534       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
535     case llvm::Triple::NetBSD:
536       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
537     case llvm::Triple::OpenBSD:
538       return new OpenBSDX86_64TargetInfo(Triple, Opts);
539     case llvm::Triple::FreeBSD:
540       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
541     case llvm::Triple::Fuchsia:
542       return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
543     case llvm::Triple::KFreeBSD:
544       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
545     case llvm::Triple::Solaris:
546       return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
547     case llvm::Triple::Win32: {
548       switch (Triple.getEnvironment()) {
549       case llvm::Triple::Cygnus:
550         return new CygwinX86_64TargetInfo(Triple, Opts);
551       case llvm::Triple::GNU:
552         return new MinGWX86_64TargetInfo(Triple, Opts);
553       case llvm::Triple::MSVC:
554       default: // Assume MSVC for unknown environments
555         return new MicrosoftX86_64TargetInfo(Triple, Opts);
556       }
557     }
558     case llvm::Triple::Haiku:
559       return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
560     case llvm::Triple::NaCl:
561       return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
562     case llvm::Triple::PS4:
563       return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
564     default:
565       return new X86_64TargetInfo(Triple, Opts);
566     }
567 
568   case llvm::Triple::spir: {
569     if (Triple.getOS() != llvm::Triple::UnknownOS ||
570         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
571       return nullptr;
572     return new SPIR32TargetInfo(Triple, Opts);
573   }
574   case llvm::Triple::spir64: {
575     if (Triple.getOS() != llvm::Triple::UnknownOS ||
576         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
577       return nullptr;
578     return new SPIR64TargetInfo(Triple, Opts);
579   }
580   case llvm::Triple::wasm32:
581     if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
582         Triple.getVendor() != llvm::Triple::UnknownVendor ||
583         !Triple.isOSBinFormatWasm())
584       return nullptr;
585     switch (Triple.getOS()) {
586       case llvm::Triple::WASI:
587         return new WASITargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
588       case llvm::Triple::Emscripten:
589         return new EmscriptenTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
590       case llvm::Triple::UnknownOS:
591         return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
592       default:
593         return nullptr;
594     }
595   case llvm::Triple::wasm64:
596     if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
597         Triple.getVendor() != llvm::Triple::UnknownVendor ||
598         !Triple.isOSBinFormatWasm())
599       return nullptr;
600     switch (Triple.getOS()) {
601       case llvm::Triple::WASI:
602         return new WASITargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
603       case llvm::Triple::Emscripten:
604         return new EmscriptenTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
605       case llvm::Triple::UnknownOS:
606         return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
607       default:
608         return nullptr;
609     }
610 
611   case llvm::Triple::renderscript32:
612     return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
613   case llvm::Triple::renderscript64:
614     return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
615   }
616 }
617 } // namespace targets
618 } // namespace clang
619 
620 using namespace clang::targets;
621 /// CreateTargetInfo - Return the target info object for the specified target
622 /// options.
623 TargetInfo *
624 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
625                              const std::shared_ptr<TargetOptions> &Opts) {
626   llvm::Triple Triple(Opts->Triple);
627 
628   // Construct the target
629   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
630   if (!Target) {
631     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
632     return nullptr;
633   }
634   Target->TargetOpts = Opts;
635 
636   // Set the target CPU if specified.
637   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
638     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
639     SmallVector<StringRef, 32> ValidList;
640     Target->fillValidCPUList(ValidList);
641     if (!ValidList.empty())
642       Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
643     return nullptr;
644   }
645 
646   // Set the target ABI if specified.
647   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
648     Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
649     return nullptr;
650   }
651 
652   // Set the fp math unit.
653   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
654     Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
655     return nullptr;
656   }
657 
658   // Compute the default target features, we need the target to handle this
659   // because features may have dependencies on one another.
660   llvm::StringMap<bool> Features;
661   if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
662                               Opts->FeaturesAsWritten))
663     return nullptr;
664 
665   // Add the features to the compile options.
666   Opts->Features.clear();
667   for (const auto &F : Features)
668     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
669   // Sort here, so we handle the features in a predictable order. (This matters
670   // when we're dealing with features that overlap.)
671   llvm::sort(Opts->Features);
672 
673   if (!Target->handleTargetFeatures(Opts->Features, Diags))
674     return nullptr;
675 
676   Target->setSupportedOpenCLOpts();
677   Target->setOpenCLExtensionOpts();
678   Target->setMaxAtomicWidth();
679 
680   if (!Target->validateTarget(Diags))
681     return nullptr;
682 
683   Target->CheckFixedPointBits();
684 
685   return Target.release();
686 }
687