1 //===--- Targets.cpp - Implement -arch option and targets -----------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements construction of a TargetInfo object from a
11 // target triple.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Basic/TargetInfo.h"
16 #include "clang/Basic/Builtins.h"
17 #include "clang/Basic/Diagnostic.h"
18 #include "clang/Basic/LangOptions.h"
19 #include "clang/Basic/MacroBuilder.h"
20 #include "clang/Basic/TargetBuiltins.h"
21 #include "clang/Basic/TargetOptions.h"
22 #include "llvm/ADT/APFloat.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/ADT/Triple.h"
28 #include "llvm/IR/Type.h"
29 #include "llvm/MC/MCSectionMachO.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include <algorithm>
32 #include <memory>
33 using namespace clang;
34 
35 //===----------------------------------------------------------------------===//
36 //  Common code shared among targets.
37 //===----------------------------------------------------------------------===//
38 
39 /// DefineStd - Define a macro name and standard variants.  For example if
40 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
41 /// when in GNU mode.
42 static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
43                       const LangOptions &Opts) {
44   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
45 
46   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
47   // in the user's namespace.
48   if (Opts.GNUMode)
49     Builder.defineMacro(MacroName);
50 
51   // Define __unix.
52   Builder.defineMacro("__" + MacroName);
53 
54   // Define __unix__.
55   Builder.defineMacro("__" + MacroName + "__");
56 }
57 
58 static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
59                             bool Tuning = true) {
60   Builder.defineMacro("__" + CPUName);
61   Builder.defineMacro("__" + CPUName + "__");
62   if (Tuning)
63     Builder.defineMacro("__tune_" + CPUName + "__");
64 }
65 
66 //===----------------------------------------------------------------------===//
67 // Defines specific to certain operating systems.
68 //===----------------------------------------------------------------------===//
69 
70 namespace {
71 template<typename TgtInfo>
72 class OSTargetInfo : public TgtInfo {
73 protected:
74   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
75                             MacroBuilder &Builder) const=0;
76 public:
77   OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
78   void getTargetDefines(const LangOptions &Opts,
79                         MacroBuilder &Builder) const override {
80     TgtInfo::getTargetDefines(Opts, Builder);
81     getOSDefines(Opts, TgtInfo::getTriple(), Builder);
82   }
83 
84 };
85 } // end anonymous namespace
86 
87 
88 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
89                              const llvm::Triple &Triple,
90                              StringRef &PlatformName,
91                              VersionTuple &PlatformMinVersion) {
92   Builder.defineMacro("__APPLE_CC__", "6000");
93   Builder.defineMacro("__APPLE__");
94   Builder.defineMacro("OBJC_NEW_PROPERTIES");
95   // AddressSanitizer doesn't play well with source fortification, which is on
96   // by default on Darwin.
97   if (Opts.Sanitize.has(SanitizerKind::Address))
98     Builder.defineMacro("_FORTIFY_SOURCE", "0");
99 
100   if (!Opts.ObjCAutoRefCount) {
101     // __weak is always defined, for use in blocks and with objc pointers.
102     Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
103 
104     // Darwin defines __strong even in C mode (just to nothing).
105     if (Opts.getGC() != LangOptions::NonGC)
106       Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
107     else
108       Builder.defineMacro("__strong", "");
109 
110     // __unsafe_unretained is defined to nothing in non-ARC mode. We even
111     // allow this in C, since one might have block pointers in structs that
112     // are used in pure C code and in Objective-C ARC.
113     Builder.defineMacro("__unsafe_unretained", "");
114   }
115 
116   if (Opts.Static)
117     Builder.defineMacro("__STATIC__");
118   else
119     Builder.defineMacro("__DYNAMIC__");
120 
121   if (Opts.POSIXThreads)
122     Builder.defineMacro("_REENTRANT");
123 
124   // Get the platform type and version number from the triple.
125   unsigned Maj, Min, Rev;
126   if (Triple.isMacOSX()) {
127     Triple.getMacOSXVersion(Maj, Min, Rev);
128     PlatformName = "macosx";
129   } else {
130     Triple.getOSVersion(Maj, Min, Rev);
131     PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
132   }
133 
134   // If -target arch-pc-win32-macho option specified, we're
135   // generating code for Win32 ABI. No need to emit
136   // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
137   if (PlatformName == "win32") {
138     PlatformMinVersion = VersionTuple(Maj, Min, Rev);
139     return;
140   }
141 
142   // Set the appropriate OS version define.
143   if (Triple.isiOS()) {
144     assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
145     char Str[6];
146     Str[0] = '0' + Maj;
147     Str[1] = '0' + (Min / 10);
148     Str[2] = '0' + (Min % 10);
149     Str[3] = '0' + (Rev / 10);
150     Str[4] = '0' + (Rev % 10);
151     Str[5] = '\0';
152     Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
153                         Str);
154   } else if (Triple.isMacOSX()) {
155     // Note that the Driver allows versions which aren't representable in the
156     // define (because we only get a single digit for the minor and micro
157     // revision numbers). So, we limit them to the maximum representable
158     // version.
159     assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
160     char Str[7];
161     if (Maj < 10 || (Maj == 10 && Min < 10)) {
162       Str[0] = '0' + (Maj / 10);
163       Str[1] = '0' + (Maj % 10);
164       Str[2] = '0' + std::min(Min, 9U);
165       Str[3] = '0' + std::min(Rev, 9U);
166       Str[4] = '\0';
167     } else {
168       // Handle versions > 10.9.
169       Str[0] = '0' + (Maj / 10);
170       Str[1] = '0' + (Maj % 10);
171       Str[2] = '0' + (Min / 10);
172       Str[3] = '0' + (Min % 10);
173       Str[4] = '0' + (Rev / 10);
174       Str[5] = '0' + (Rev % 10);
175       Str[6] = '\0';
176     }
177     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
178   }
179 
180   // Tell users about the kernel if there is one.
181   if (Triple.isOSDarwin())
182     Builder.defineMacro("__MACH__");
183 
184   PlatformMinVersion = VersionTuple(Maj, Min, Rev);
185 }
186 
187 namespace {
188 template<typename Target>
189 class DarwinTargetInfo : public OSTargetInfo<Target> {
190 protected:
191   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
192                     MacroBuilder &Builder) const override {
193     getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
194                      this->PlatformMinVersion);
195   }
196 
197 public:
198   DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
199     this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
200     this->MCountName = "\01mcount";
201   }
202 
203   std::string isValidSectionSpecifier(StringRef SR) const override {
204     // Let MCSectionMachO validate this.
205     StringRef Segment, Section;
206     unsigned TAA, StubSize;
207     bool HasTAA;
208     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
209                                                        TAA, HasTAA, StubSize);
210   }
211 
212   const char *getStaticInitSectionSpecifier() const override {
213     // FIXME: We should return 0 when building kexts.
214     return "__TEXT,__StaticInit,regular,pure_instructions";
215   }
216 
217   /// Darwin does not support protected visibility.  Darwin's "default"
218   /// is very similar to ELF's "protected";  Darwin requires a "weak"
219   /// attribute on declarations that can be dynamically replaced.
220   bool hasProtectedVisibility() const override {
221     return false;
222   }
223 };
224 
225 
226 // DragonFlyBSD Target
227 template<typename Target>
228 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
229 protected:
230   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
231                     MacroBuilder &Builder) const override {
232     // DragonFly defines; list based off of gcc output
233     Builder.defineMacro("__DragonFly__");
234     Builder.defineMacro("__DragonFly_cc_version", "100001");
235     Builder.defineMacro("__ELF__");
236     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
237     Builder.defineMacro("__tune_i386__");
238     DefineStd(Builder, "unix", Opts);
239   }
240 public:
241   DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
242       : OSTargetInfo<Target>(Triple) {
243     this->UserLabelPrefix = "";
244 
245     switch (Triple.getArch()) {
246     default:
247     case llvm::Triple::x86:
248     case llvm::Triple::x86_64:
249       this->MCountName = ".mcount";
250       break;
251     }
252   }
253 };
254 
255 // FreeBSD Target
256 template<typename Target>
257 class FreeBSDTargetInfo : public OSTargetInfo<Target> {
258 protected:
259   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
260                     MacroBuilder &Builder) const override {
261     // FreeBSD defines; list based off of gcc output
262 
263     unsigned Release = Triple.getOSMajorVersion();
264     if (Release == 0U)
265       Release = 8;
266 
267     Builder.defineMacro("__FreeBSD__", Twine(Release));
268     Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
269     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
270     DefineStd(Builder, "unix", Opts);
271     Builder.defineMacro("__ELF__");
272 
273     // On FreeBSD, wchar_t contains the number of the code point as
274     // used by the character set of the locale. These character sets are
275     // not necessarily a superset of ASCII.
276     Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
277   }
278 public:
279   FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
280     this->UserLabelPrefix = "";
281 
282     switch (Triple.getArch()) {
283     default:
284     case llvm::Triple::x86:
285     case llvm::Triple::x86_64:
286       this->MCountName = ".mcount";
287       break;
288     case llvm::Triple::mips:
289     case llvm::Triple::mipsel:
290     case llvm::Triple::ppc:
291     case llvm::Triple::ppc64:
292     case llvm::Triple::ppc64le:
293       this->MCountName = "_mcount";
294       break;
295     case llvm::Triple::arm:
296       this->MCountName = "__mcount";
297       break;
298     }
299   }
300 };
301 
302 // GNU/kFreeBSD Target
303 template<typename Target>
304 class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
305 protected:
306   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
307                     MacroBuilder &Builder) const override {
308     // GNU/kFreeBSD defines; list based off of gcc output
309 
310     DefineStd(Builder, "unix", Opts);
311     Builder.defineMacro("__FreeBSD_kernel__");
312     Builder.defineMacro("__GLIBC__");
313     Builder.defineMacro("__ELF__");
314     if (Opts.POSIXThreads)
315       Builder.defineMacro("_REENTRANT");
316     if (Opts.CPlusPlus)
317       Builder.defineMacro("_GNU_SOURCE");
318   }
319 public:
320   KFreeBSDTargetInfo(const llvm::Triple &Triple)
321       : OSTargetInfo<Target>(Triple) {
322     this->UserLabelPrefix = "";
323   }
324 };
325 
326 // Minix Target
327 template<typename Target>
328 class MinixTargetInfo : public OSTargetInfo<Target> {
329 protected:
330   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
331                     MacroBuilder &Builder) const override {
332     // Minix defines
333 
334     Builder.defineMacro("__minix", "3");
335     Builder.defineMacro("_EM_WSIZE", "4");
336     Builder.defineMacro("_EM_PSIZE", "4");
337     Builder.defineMacro("_EM_SSIZE", "2");
338     Builder.defineMacro("_EM_LSIZE", "4");
339     Builder.defineMacro("_EM_FSIZE", "4");
340     Builder.defineMacro("_EM_DSIZE", "8");
341     Builder.defineMacro("__ELF__");
342     DefineStd(Builder, "unix", Opts);
343   }
344 public:
345   MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
346     this->UserLabelPrefix = "";
347   }
348 };
349 
350 // Linux target
351 template<typename Target>
352 class LinuxTargetInfo : public OSTargetInfo<Target> {
353 protected:
354   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
355                     MacroBuilder &Builder) const override {
356     // Linux defines; list based off of gcc output
357     DefineStd(Builder, "unix", Opts);
358     DefineStd(Builder, "linux", Opts);
359     Builder.defineMacro("__gnu_linux__");
360     Builder.defineMacro("__ELF__");
361     if (Triple.getEnvironment() == llvm::Triple::Android)
362       Builder.defineMacro("__ANDROID__", "1");
363     if (Opts.POSIXThreads)
364       Builder.defineMacro("_REENTRANT");
365     if (Opts.CPlusPlus)
366       Builder.defineMacro("_GNU_SOURCE");
367   }
368 public:
369   LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
370     this->UserLabelPrefix = "";
371     this->WIntType = TargetInfo::UnsignedInt;
372 
373     switch (Triple.getArch()) {
374     default:
375       break;
376     case llvm::Triple::ppc:
377     case llvm::Triple::ppc64:
378     case llvm::Triple::ppc64le:
379       this->MCountName = "_mcount";
380       break;
381     }
382   }
383 
384   const char *getStaticInitSectionSpecifier() const override {
385     return ".text.startup";
386   }
387 };
388 
389 // NetBSD Target
390 template<typename Target>
391 class NetBSDTargetInfo : public OSTargetInfo<Target> {
392 protected:
393   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
394                     MacroBuilder &Builder) const override {
395     // NetBSD defines; list based off of gcc output
396     Builder.defineMacro("__NetBSD__");
397     Builder.defineMacro("__unix__");
398     Builder.defineMacro("__ELF__");
399     if (Opts.POSIXThreads)
400       Builder.defineMacro("_POSIX_THREADS");
401 
402     switch (Triple.getArch()) {
403     default:
404       break;
405     case llvm::Triple::arm:
406     case llvm::Triple::armeb:
407     case llvm::Triple::thumb:
408     case llvm::Triple::thumbeb:
409       Builder.defineMacro("__ARM_DWARF_EH__");
410       break;
411     }
412   }
413 public:
414   NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
415     this->UserLabelPrefix = "";
416   }
417 };
418 
419 // OpenBSD Target
420 template<typename Target>
421 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
422 protected:
423   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
424                     MacroBuilder &Builder) const override {
425     // OpenBSD defines; list based off of gcc output
426 
427     Builder.defineMacro("__OpenBSD__");
428     DefineStd(Builder, "unix", Opts);
429     Builder.defineMacro("__ELF__");
430     if (Opts.POSIXThreads)
431       Builder.defineMacro("_REENTRANT");
432   }
433 public:
434   OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
435     this->UserLabelPrefix = "";
436     this->TLSSupported = false;
437 
438       switch (Triple.getArch()) {
439         default:
440         case llvm::Triple::x86:
441         case llvm::Triple::x86_64:
442         case llvm::Triple::arm:
443         case llvm::Triple::sparc:
444           this->MCountName = "__mcount";
445           break;
446         case llvm::Triple::mips64:
447         case llvm::Triple::mips64el:
448         case llvm::Triple::ppc:
449         case llvm::Triple::sparcv9:
450           this->MCountName = "_mcount";
451           break;
452       }
453   }
454 };
455 
456 // Bitrig Target
457 template<typename Target>
458 class BitrigTargetInfo : public OSTargetInfo<Target> {
459 protected:
460   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
461                     MacroBuilder &Builder) const override {
462     // Bitrig defines; list based off of gcc output
463 
464     Builder.defineMacro("__Bitrig__");
465     DefineStd(Builder, "unix", Opts);
466     Builder.defineMacro("__ELF__");
467     if (Opts.POSIXThreads)
468       Builder.defineMacro("_REENTRANT");
469   }
470 public:
471   BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
472     this->UserLabelPrefix = "";
473     this->MCountName = "__mcount";
474   }
475 };
476 
477 // PSP Target
478 template<typename Target>
479 class PSPTargetInfo : public OSTargetInfo<Target> {
480 protected:
481   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
482                     MacroBuilder &Builder) const override {
483     // PSP defines; list based on the output of the pspdev gcc toolchain.
484     Builder.defineMacro("PSP");
485     Builder.defineMacro("_PSP");
486     Builder.defineMacro("__psp__");
487     Builder.defineMacro("__ELF__");
488   }
489 public:
490   PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
491     this->UserLabelPrefix = "";
492   }
493 };
494 
495 // PS3 PPU Target
496 template<typename Target>
497 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
498 protected:
499   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
500                     MacroBuilder &Builder) const override {
501     // PS3 PPU defines.
502     Builder.defineMacro("__PPC__");
503     Builder.defineMacro("__PPU__");
504     Builder.defineMacro("__CELLOS_LV2__");
505     Builder.defineMacro("__ELF__");
506     Builder.defineMacro("__LP32__");
507     Builder.defineMacro("_ARCH_PPC64");
508     Builder.defineMacro("__powerpc64__");
509   }
510 public:
511   PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
512     this->UserLabelPrefix = "";
513     this->LongWidth = this->LongAlign = 32;
514     this->PointerWidth = this->PointerAlign = 32;
515     this->IntMaxType = TargetInfo::SignedLongLong;
516     this->Int64Type = TargetInfo::SignedLongLong;
517     this->SizeType = TargetInfo::UnsignedInt;
518     this->DescriptionString = "E-m:e-p:32:32-i64:64-n32:64";
519   }
520 };
521 
522 // Solaris target
523 template<typename Target>
524 class SolarisTargetInfo : public OSTargetInfo<Target> {
525 protected:
526   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
527                     MacroBuilder &Builder) const override {
528     DefineStd(Builder, "sun", Opts);
529     DefineStd(Builder, "unix", Opts);
530     Builder.defineMacro("__ELF__");
531     Builder.defineMacro("__svr4__");
532     Builder.defineMacro("__SVR4");
533     // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
534     // newer, but to 500 for everything else.  feature_test.h has a check to
535     // ensure that you are not using C99 with an old version of X/Open or C89
536     // with a new version.
537     if (Opts.C99)
538       Builder.defineMacro("_XOPEN_SOURCE", "600");
539     else
540       Builder.defineMacro("_XOPEN_SOURCE", "500");
541     if (Opts.CPlusPlus)
542       Builder.defineMacro("__C99FEATURES__");
543     Builder.defineMacro("_LARGEFILE_SOURCE");
544     Builder.defineMacro("_LARGEFILE64_SOURCE");
545     Builder.defineMacro("__EXTENSIONS__");
546     Builder.defineMacro("_REENTRANT");
547   }
548 public:
549   SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
550     this->UserLabelPrefix = "";
551     this->WCharType = this->SignedInt;
552     // FIXME: WIntType should be SignedLong
553   }
554 };
555 
556 // Windows target
557 template<typename Target>
558 class WindowsTargetInfo : public OSTargetInfo<Target> {
559 protected:
560   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
561                     MacroBuilder &Builder) const override {
562     Builder.defineMacro("_WIN32");
563   }
564   void getVisualStudioDefines(const LangOptions &Opts,
565                               MacroBuilder &Builder) const {
566     if (Opts.CPlusPlus) {
567       if (Opts.RTTIData)
568         Builder.defineMacro("_CPPRTTI");
569 
570       if (Opts.Exceptions)
571         Builder.defineMacro("_CPPUNWIND");
572     }
573 
574     if (!Opts.CharIsSigned)
575       Builder.defineMacro("_CHAR_UNSIGNED");
576 
577     // FIXME: POSIXThreads isn't exactly the option this should be defined for,
578     //        but it works for now.
579     if (Opts.POSIXThreads)
580       Builder.defineMacro("_MT");
581 
582     if (Opts.MSCompatibilityVersion) {
583       Builder.defineMacro("_MSC_VER",
584                           Twine(Opts.MSCompatibilityVersion / 100000));
585       Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
586       // FIXME We cannot encode the revision information into 32-bits
587       Builder.defineMacro("_MSC_BUILD", Twine(1));
588     }
589 
590     if (Opts.MicrosoftExt) {
591       Builder.defineMacro("_MSC_EXTENSIONS");
592 
593       if (Opts.CPlusPlus11) {
594         Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
595         Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
596         Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
597       }
598     }
599 
600     Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
601   }
602 
603 public:
604   WindowsTargetInfo(const llvm::Triple &Triple)
605       : OSTargetInfo<Target>(Triple) {}
606 };
607 
608 template <typename Target>
609 class NaClTargetInfo : public OSTargetInfo<Target> {
610 protected:
611   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
612                     MacroBuilder &Builder) const override {
613     if (Opts.POSIXThreads)
614       Builder.defineMacro("_REENTRANT");
615     if (Opts.CPlusPlus)
616       Builder.defineMacro("_GNU_SOURCE");
617 
618     DefineStd(Builder, "unix", Opts);
619     Builder.defineMacro("__ELF__");
620     Builder.defineMacro("__native_client__");
621   }
622 
623 public:
624   NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
625     this->UserLabelPrefix = "";
626     this->LongAlign = 32;
627     this->LongWidth = 32;
628     this->PointerAlign = 32;
629     this->PointerWidth = 32;
630     this->IntMaxType = TargetInfo::SignedLongLong;
631     this->Int64Type = TargetInfo::SignedLongLong;
632     this->DoubleAlign = 64;
633     this->LongDoubleWidth = 64;
634     this->LongDoubleAlign = 64;
635     this->LongLongWidth = 64;
636     this->LongLongAlign = 64;
637     this->SizeType = TargetInfo::UnsignedInt;
638     this->PtrDiffType = TargetInfo::SignedInt;
639     this->IntPtrType = TargetInfo::SignedInt;
640     // RegParmMax is inherited from the underlying architecture
641     this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
642     if (Triple.getArch() == llvm::Triple::arm) {
643       this->DescriptionString =
644           "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128";
645     } else if (Triple.getArch() == llvm::Triple::x86) {
646       this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
647     } else if (Triple.getArch() == llvm::Triple::x86_64) {
648       this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
649     } else if (Triple.getArch() == llvm::Triple::mipsel) {
650       // Handled on mips' setDescriptionString.
651     } else {
652       assert(Triple.getArch() == llvm::Triple::le32);
653       this->DescriptionString = "e-p:32:32-i64:64";
654     }
655   }
656   typename Target::CallingConvCheckResult checkCallingConvention(
657       CallingConv CC) const override {
658     return CC == CC_PnaclCall ? Target::CCCR_OK :
659         Target::checkCallingConvention(CC);
660   }
661 };
662 } // end anonymous namespace.
663 
664 //===----------------------------------------------------------------------===//
665 // Specific target implementations.
666 //===----------------------------------------------------------------------===//
667 
668 namespace {
669 // PPC abstract base class
670 class PPCTargetInfo : public TargetInfo {
671   static const Builtin::Info BuiltinInfo[];
672   static const char * const GCCRegNames[];
673   static const TargetInfo::GCCRegAlias GCCRegAliases[];
674   std::string CPU;
675 
676   // Target cpu features.
677   bool HasVSX;
678   bool HasP8Vector;
679 
680 protected:
681   std::string ABI;
682 
683 public:
684   PPCTargetInfo(const llvm::Triple &Triple)
685     : TargetInfo(Triple), HasVSX(false), HasP8Vector(false) {
686     BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
687     LongDoubleWidth = LongDoubleAlign = 128;
688     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
689   }
690 
691   /// \brief Flags for architecture specific defines.
692   typedef enum {
693     ArchDefineNone  = 0,
694     ArchDefineName  = 1 << 0, // <name> is substituted for arch name.
695     ArchDefinePpcgr = 1 << 1,
696     ArchDefinePpcsq = 1 << 2,
697     ArchDefine440   = 1 << 3,
698     ArchDefine603   = 1 << 4,
699     ArchDefine604   = 1 << 5,
700     ArchDefinePwr4  = 1 << 6,
701     ArchDefinePwr5  = 1 << 7,
702     ArchDefinePwr5x = 1 << 8,
703     ArchDefinePwr6  = 1 << 9,
704     ArchDefinePwr6x = 1 << 10,
705     ArchDefinePwr7  = 1 << 11,
706     ArchDefinePwr8  = 1 << 12,
707     ArchDefineA2    = 1 << 13,
708     ArchDefineA2q   = 1 << 14
709   } ArchDefineTypes;
710 
711   // Note: GCC recognizes the following additional cpus:
712   //  401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
713   //  821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
714   //  titan, rs64.
715   bool setCPU(const std::string &Name) override {
716     bool CPUKnown = llvm::StringSwitch<bool>(Name)
717       .Case("generic", true)
718       .Case("440", true)
719       .Case("450", true)
720       .Case("601", true)
721       .Case("602", true)
722       .Case("603", true)
723       .Case("603e", true)
724       .Case("603ev", true)
725       .Case("604", true)
726       .Case("604e", true)
727       .Case("620", true)
728       .Case("630", true)
729       .Case("g3", true)
730       .Case("7400", true)
731       .Case("g4", true)
732       .Case("7450", true)
733       .Case("g4+", true)
734       .Case("750", true)
735       .Case("970", true)
736       .Case("g5", true)
737       .Case("a2", true)
738       .Case("a2q", true)
739       .Case("e500mc", true)
740       .Case("e5500", true)
741       .Case("power3", true)
742       .Case("pwr3", true)
743       .Case("power4", true)
744       .Case("pwr4", true)
745       .Case("power5", true)
746       .Case("pwr5", true)
747       .Case("power5x", true)
748       .Case("pwr5x", true)
749       .Case("power6", true)
750       .Case("pwr6", true)
751       .Case("power6x", true)
752       .Case("pwr6x", true)
753       .Case("power7", true)
754       .Case("pwr7", true)
755       .Case("power8", true)
756       .Case("pwr8", true)
757       .Case("powerpc", true)
758       .Case("ppc", true)
759       .Case("powerpc64", true)
760       .Case("ppc64", true)
761       .Case("powerpc64le", true)
762       .Case("ppc64le", true)
763       .Default(false);
764 
765     if (CPUKnown)
766       CPU = Name;
767 
768     return CPUKnown;
769   }
770 
771 
772   StringRef getABI() const override { return ABI; }
773 
774   void getTargetBuiltins(const Builtin::Info *&Records,
775                          unsigned &NumRecords) const override {
776     Records = BuiltinInfo;
777     NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
778   }
779 
780   bool isCLZForZeroUndef() const override { return false; }
781 
782   void getTargetDefines(const LangOptions &Opts,
783                         MacroBuilder &Builder) const override;
784 
785   void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
786 
787   bool handleTargetFeatures(std::vector<std::string> &Features,
788                             DiagnosticsEngine &Diags) override;
789   bool hasFeature(StringRef Feature) const override;
790 
791   void getGCCRegNames(const char * const *&Names,
792                       unsigned &NumNames) const override;
793   void getGCCRegAliases(const GCCRegAlias *&Aliases,
794                         unsigned &NumAliases) const override;
795   bool validateAsmConstraint(const char *&Name,
796                              TargetInfo::ConstraintInfo &Info) const override {
797     switch (*Name) {
798     default: return false;
799     case 'O': // Zero
800       break;
801     case 'b': // Base register
802     case 'f': // Floating point register
803       Info.setAllowsRegister();
804       break;
805     // FIXME: The following are added to allow parsing.
806     // I just took a guess at what the actions should be.
807     // Also, is more specific checking needed?  I.e. specific registers?
808     case 'd': // Floating point register (containing 64-bit value)
809     case 'v': // Altivec vector register
810       Info.setAllowsRegister();
811       break;
812     case 'w':
813       switch (Name[1]) {
814         case 'd':// VSX vector register to hold vector double data
815         case 'f':// VSX vector register to hold vector float data
816         case 's':// VSX vector register to hold scalar float data
817         case 'a':// Any VSX register
818         case 'c':// An individual CR bit
819           break;
820         default:
821           return false;
822       }
823       Info.setAllowsRegister();
824       Name++; // Skip over 'w'.
825       break;
826     case 'h': // `MQ', `CTR', or `LINK' register
827     case 'q': // `MQ' register
828     case 'c': // `CTR' register
829     case 'l': // `LINK' register
830     case 'x': // `CR' register (condition register) number 0
831     case 'y': // `CR' register (condition register)
832     case 'z': // `XER[CA]' carry bit (part of the XER register)
833       Info.setAllowsRegister();
834       break;
835     case 'I': // Signed 16-bit constant
836     case 'J': // Unsigned 16-bit constant shifted left 16 bits
837               //  (use `L' instead for SImode constants)
838     case 'K': // Unsigned 16-bit constant
839     case 'L': // Signed 16-bit constant shifted left 16 bits
840     case 'M': // Constant larger than 31
841     case 'N': // Exact power of 2
842     case 'P': // Constant whose negation is a signed 16-bit constant
843     case 'G': // Floating point constant that can be loaded into a
844               // register with one instruction per word
845     case 'H': // Integer/Floating point constant that can be loaded
846               // into a register using three instructions
847       break;
848     case 'm': // Memory operand. Note that on PowerPC targets, m can
849               // include addresses that update the base register. It
850               // is therefore only safe to use `m' in an asm statement
851               // if that asm statement accesses the operand exactly once.
852               // The asm statement must also use `%U<opno>' as a
853               // placeholder for the "update" flag in the corresponding
854               // load or store instruction. For example:
855               // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
856               // is correct but:
857               // asm ("st %1,%0" : "=m" (mem) : "r" (val));
858               // is not. Use es rather than m if you don't want the base
859               // register to be updated.
860     case 'e':
861       if (Name[1] != 's')
862           return false;
863               // es: A "stable" memory operand; that is, one which does not
864               // include any automodification of the base register. Unlike
865               // `m', this constraint can be used in asm statements that
866               // might access the operand several times, or that might not
867               // access it at all.
868       Info.setAllowsMemory();
869       Name++; // Skip over 'e'.
870       break;
871     case 'Q': // Memory operand that is an offset from a register (it is
872               // usually better to use `m' or `es' in asm statements)
873     case 'Z': // Memory operand that is an indexed or indirect from a
874               // register (it is usually better to use `m' or `es' in
875               // asm statements)
876       Info.setAllowsMemory();
877       Info.setAllowsRegister();
878       break;
879     case 'R': // AIX TOC entry
880     case 'a': // Address operand that is an indexed or indirect from a
881               // register (`p' is preferable for asm statements)
882     case 'S': // Constant suitable as a 64-bit mask operand
883     case 'T': // Constant suitable as a 32-bit mask operand
884     case 'U': // System V Release 4 small data area reference
885     case 't': // AND masks that can be performed by two rldic{l, r}
886               // instructions
887     case 'W': // Vector constant that does not require memory
888     case 'j': // Vector constant that is all zeros.
889       break;
890     // End FIXME.
891     }
892     return true;
893   }
894   std::string convertConstraint(const char *&Constraint) const override {
895     std::string R;
896     switch (*Constraint) {
897     case 'e':
898     case 'w':
899       // Two-character constraint; add "^" hint for later parsing.
900       R = std::string("^") + std::string(Constraint, 2);
901       Constraint++;
902       break;
903     default:
904       return TargetInfo::convertConstraint(Constraint);
905     }
906     return R;
907   }
908   const char *getClobbers() const override {
909     return "";
910   }
911   int getEHDataRegisterNumber(unsigned RegNo) const override {
912     if (RegNo == 0) return 3;
913     if (RegNo == 1) return 4;
914     return -1;
915   }
916 };
917 
918 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
919 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
920 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
921                                               ALL_LANGUAGES },
922 #include "clang/Basic/BuiltinsPPC.def"
923 };
924 
925 /// handleTargetFeatures - Perform initialization based on the user
926 /// configured set of features.
927 bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
928                                          DiagnosticsEngine &Diags) {
929   for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
930     // Ignore disabled features.
931     if (Features[i][0] == '-')
932       continue;
933 
934     StringRef Feature = StringRef(Features[i]).substr(1);
935 
936     if (Feature == "vsx") {
937       HasVSX = true;
938       continue;
939     }
940 
941     if (Feature == "power8-vector") {
942       HasP8Vector = true;
943       continue;
944     }
945 
946     // TODO: Finish this list and add an assert that we've handled them
947     // all.
948   }
949 
950   return true;
951 }
952 
953 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
954 /// #defines that are not tied to a specific subtarget.
955 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
956                                      MacroBuilder &Builder) const {
957   // Target identification.
958   Builder.defineMacro("__ppc__");
959   Builder.defineMacro("__PPC__");
960   Builder.defineMacro("_ARCH_PPC");
961   Builder.defineMacro("__powerpc__");
962   Builder.defineMacro("__POWERPC__");
963   if (PointerWidth == 64) {
964     Builder.defineMacro("_ARCH_PPC64");
965     Builder.defineMacro("__powerpc64__");
966     Builder.defineMacro("__ppc64__");
967     Builder.defineMacro("__PPC64__");
968   }
969 
970   // Target properties.
971   if (getTriple().getArch() == llvm::Triple::ppc64le) {
972     Builder.defineMacro("_LITTLE_ENDIAN");
973   } else {
974     if (getTriple().getOS() != llvm::Triple::NetBSD &&
975         getTriple().getOS() != llvm::Triple::OpenBSD)
976       Builder.defineMacro("_BIG_ENDIAN");
977   }
978 
979   // ABI options.
980   if (ABI == "elfv1")
981     Builder.defineMacro("_CALL_ELF", "1");
982   if (ABI == "elfv2")
983     Builder.defineMacro("_CALL_ELF", "2");
984 
985   // Subtarget options.
986   Builder.defineMacro("__NATURAL_ALIGNMENT__");
987   Builder.defineMacro("__REGISTER_PREFIX__", "");
988 
989   // FIXME: Should be controlled by command line option.
990   if (LongDoubleWidth == 128)
991     Builder.defineMacro("__LONG_DOUBLE_128__");
992 
993   if (Opts.AltiVec) {
994     Builder.defineMacro("__VEC__", "10206");
995     Builder.defineMacro("__ALTIVEC__");
996   }
997 
998   // CPU identification.
999   ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1000     .Case("440",   ArchDefineName)
1001     .Case("450",   ArchDefineName | ArchDefine440)
1002     .Case("601",   ArchDefineName)
1003     .Case("602",   ArchDefineName | ArchDefinePpcgr)
1004     .Case("603",   ArchDefineName | ArchDefinePpcgr)
1005     .Case("603e",  ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1006     .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1007     .Case("604",   ArchDefineName | ArchDefinePpcgr)
1008     .Case("604e",  ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1009     .Case("620",   ArchDefineName | ArchDefinePpcgr)
1010     .Case("630",   ArchDefineName | ArchDefinePpcgr)
1011     .Case("7400",  ArchDefineName | ArchDefinePpcgr)
1012     .Case("7450",  ArchDefineName | ArchDefinePpcgr)
1013     .Case("750",   ArchDefineName | ArchDefinePpcgr)
1014     .Case("970",   ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1015                      | ArchDefinePpcsq)
1016     .Case("a2",    ArchDefineA2)
1017     .Case("a2q",   ArchDefineName | ArchDefineA2 | ArchDefineA2q)
1018     .Case("pwr3",  ArchDefinePpcgr)
1019     .Case("pwr4",  ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1020     .Case("pwr5",  ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1021                      | ArchDefinePpcsq)
1022     .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1023                      | ArchDefinePpcgr | ArchDefinePpcsq)
1024     .Case("pwr6",  ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1025                      | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1026     .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1027                      | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1028                      | ArchDefinePpcsq)
1029     .Case("pwr7",  ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1030                      | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1031                      | ArchDefinePpcgr | ArchDefinePpcsq)
1032     .Case("pwr8",  ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1033                      | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1034                      | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1035     .Case("power3",  ArchDefinePpcgr)
1036     .Case("power4",  ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1037     .Case("power5",  ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1038                        | ArchDefinePpcsq)
1039     .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1040                        | ArchDefinePpcgr | ArchDefinePpcsq)
1041     .Case("power6",  ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1042                        | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1043     .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1044                        | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1045                        | ArchDefinePpcsq)
1046     .Case("power7",  ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1047                        | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1048                        | ArchDefinePpcgr | ArchDefinePpcsq)
1049     .Case("power8",  ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1050                        | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1051                        | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1052     .Default(ArchDefineNone);
1053 
1054   if (defs & ArchDefineName)
1055     Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1056   if (defs & ArchDefinePpcgr)
1057     Builder.defineMacro("_ARCH_PPCGR");
1058   if (defs & ArchDefinePpcsq)
1059     Builder.defineMacro("_ARCH_PPCSQ");
1060   if (defs & ArchDefine440)
1061     Builder.defineMacro("_ARCH_440");
1062   if (defs & ArchDefine603)
1063     Builder.defineMacro("_ARCH_603");
1064   if (defs & ArchDefine604)
1065     Builder.defineMacro("_ARCH_604");
1066   if (defs & ArchDefinePwr4)
1067     Builder.defineMacro("_ARCH_PWR4");
1068   if (defs & ArchDefinePwr5)
1069     Builder.defineMacro("_ARCH_PWR5");
1070   if (defs & ArchDefinePwr5x)
1071     Builder.defineMacro("_ARCH_PWR5X");
1072   if (defs & ArchDefinePwr6)
1073     Builder.defineMacro("_ARCH_PWR6");
1074   if (defs & ArchDefinePwr6x)
1075     Builder.defineMacro("_ARCH_PWR6X");
1076   if (defs & ArchDefinePwr7)
1077     Builder.defineMacro("_ARCH_PWR7");
1078   if (defs & ArchDefinePwr8)
1079     Builder.defineMacro("_ARCH_PWR8");
1080   if (defs & ArchDefineA2)
1081     Builder.defineMacro("_ARCH_A2");
1082   if (defs & ArchDefineA2q) {
1083     Builder.defineMacro("_ARCH_A2Q");
1084     Builder.defineMacro("_ARCH_QP");
1085   }
1086 
1087   if (getTriple().getVendor() == llvm::Triple::BGQ) {
1088     Builder.defineMacro("__bg__");
1089     Builder.defineMacro("__THW_BLUEGENE__");
1090     Builder.defineMacro("__bgq__");
1091     Builder.defineMacro("__TOS_BGQ__");
1092   }
1093 
1094   if (HasVSX)
1095     Builder.defineMacro("__VSX__");
1096   if (HasP8Vector)
1097     Builder.defineMacro("__POWER8_VECTOR__");
1098 
1099   // FIXME: The following are not yet generated here by Clang, but are
1100   //        generated by GCC:
1101   //
1102   //   _SOFT_FLOAT_
1103   //   __RECIP_PRECISION__
1104   //   __APPLE_ALTIVEC__
1105   //   __RECIP__
1106   //   __RECIPF__
1107   //   __RSQRTE__
1108   //   __RSQRTEF__
1109   //   _SOFT_DOUBLE_
1110   //   __NO_LWSYNC__
1111   //   __HAVE_BSWAP__
1112   //   __LONGDOUBLE128
1113   //   __CMODEL_MEDIUM__
1114   //   __CMODEL_LARGE__
1115   //   _CALL_SYSV
1116   //   _CALL_DARWIN
1117   //   __NO_FPRS__
1118 }
1119 
1120 void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1121   Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1122     .Case("7400", true)
1123     .Case("g4", true)
1124     .Case("7450", true)
1125     .Case("g4+", true)
1126     .Case("970", true)
1127     .Case("g5", true)
1128     .Case("pwr6", true)
1129     .Case("pwr7", true)
1130     .Case("pwr8", true)
1131     .Case("ppc64", true)
1132     .Case("ppc64le", true)
1133     .Default(false);
1134 
1135   Features["qpx"] = (CPU == "a2q");
1136 
1137   if (!ABI.empty())
1138     Features[ABI] = true;
1139 }
1140 
1141 bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1142   return llvm::StringSwitch<bool>(Feature)
1143     .Case("powerpc", true)
1144     .Case("vsx", HasVSX)
1145     .Case("power8-vector", HasP8Vector)
1146     .Default(false);
1147 }
1148 
1149 const char * const PPCTargetInfo::GCCRegNames[] = {
1150   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1151   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1152   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1153   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1154   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1155   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1156   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1157   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
1158   "mq", "lr", "ctr", "ap",
1159   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
1160   "xer",
1161   "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1162   "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1163   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1164   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
1165   "vrsave", "vscr",
1166   "spe_acc", "spefscr",
1167   "sfp"
1168 };
1169 
1170 void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
1171                                    unsigned &NumNames) const {
1172   Names = GCCRegNames;
1173   NumNames = llvm::array_lengthof(GCCRegNames);
1174 }
1175 
1176 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1177   // While some of these aliases do map to different registers
1178   // they still share the same register name.
1179   { { "0" }, "r0" },
1180   { { "1"}, "r1" },
1181   { { "2" }, "r2" },
1182   { { "3" }, "r3" },
1183   { { "4" }, "r4" },
1184   { { "5" }, "r5" },
1185   { { "6" }, "r6" },
1186   { { "7" }, "r7" },
1187   { { "8" }, "r8" },
1188   { { "9" }, "r9" },
1189   { { "10" }, "r10" },
1190   { { "11" }, "r11" },
1191   { { "12" }, "r12" },
1192   { { "13" }, "r13" },
1193   { { "14" }, "r14" },
1194   { { "15" }, "r15" },
1195   { { "16" }, "r16" },
1196   { { "17" }, "r17" },
1197   { { "18" }, "r18" },
1198   { { "19" }, "r19" },
1199   { { "20" }, "r20" },
1200   { { "21" }, "r21" },
1201   { { "22" }, "r22" },
1202   { { "23" }, "r23" },
1203   { { "24" }, "r24" },
1204   { { "25" }, "r25" },
1205   { { "26" }, "r26" },
1206   { { "27" }, "r27" },
1207   { { "28" }, "r28" },
1208   { { "29" }, "r29" },
1209   { { "30" }, "r30" },
1210   { { "31" }, "r31" },
1211   { { "fr0" }, "f0" },
1212   { { "fr1" }, "f1" },
1213   { { "fr2" }, "f2" },
1214   { { "fr3" }, "f3" },
1215   { { "fr4" }, "f4" },
1216   { { "fr5" }, "f5" },
1217   { { "fr6" }, "f6" },
1218   { { "fr7" }, "f7" },
1219   { { "fr8" }, "f8" },
1220   { { "fr9" }, "f9" },
1221   { { "fr10" }, "f10" },
1222   { { "fr11" }, "f11" },
1223   { { "fr12" }, "f12" },
1224   { { "fr13" }, "f13" },
1225   { { "fr14" }, "f14" },
1226   { { "fr15" }, "f15" },
1227   { { "fr16" }, "f16" },
1228   { { "fr17" }, "f17" },
1229   { { "fr18" }, "f18" },
1230   { { "fr19" }, "f19" },
1231   { { "fr20" }, "f20" },
1232   { { "fr21" }, "f21" },
1233   { { "fr22" }, "f22" },
1234   { { "fr23" }, "f23" },
1235   { { "fr24" }, "f24" },
1236   { { "fr25" }, "f25" },
1237   { { "fr26" }, "f26" },
1238   { { "fr27" }, "f27" },
1239   { { "fr28" }, "f28" },
1240   { { "fr29" }, "f29" },
1241   { { "fr30" }, "f30" },
1242   { { "fr31" }, "f31" },
1243   { { "cc" }, "cr0" },
1244 };
1245 
1246 void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1247                                      unsigned &NumAliases) const {
1248   Aliases = GCCRegAliases;
1249   NumAliases = llvm::array_lengthof(GCCRegAliases);
1250 }
1251 } // end anonymous namespace.
1252 
1253 namespace {
1254 class PPC32TargetInfo : public PPCTargetInfo {
1255 public:
1256   PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
1257     DescriptionString = "E-m:e-p:32:32-i64:64-n32";
1258 
1259     switch (getTriple().getOS()) {
1260     case llvm::Triple::Linux:
1261     case llvm::Triple::FreeBSD:
1262     case llvm::Triple::NetBSD:
1263       SizeType = UnsignedInt;
1264       PtrDiffType = SignedInt;
1265       IntPtrType = SignedInt;
1266       break;
1267     default:
1268       break;
1269     }
1270 
1271     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1272       LongDoubleWidth = LongDoubleAlign = 64;
1273       LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1274     }
1275 
1276     // PPC32 supports atomics up to 4 bytes.
1277     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
1278   }
1279 
1280   BuiltinVaListKind getBuiltinVaListKind() const override {
1281     // This is the ELF definition, and is overridden by the Darwin sub-target
1282     return TargetInfo::PowerABIBuiltinVaList;
1283   }
1284 };
1285 } // end anonymous namespace.
1286 
1287 // Note: ABI differences may eventually require us to have a separate
1288 // TargetInfo for little endian.
1289 namespace {
1290 class PPC64TargetInfo : public PPCTargetInfo {
1291 public:
1292   PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
1293     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1294     IntMaxType = SignedLong;
1295     Int64Type = SignedLong;
1296 
1297     if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1298       DescriptionString = "e-m:e-i64:64-n32:64";
1299       ABI = "elfv2";
1300     } else {
1301       DescriptionString = "E-m:e-i64:64-n32:64";
1302       ABI = "elfv1";
1303     }
1304 
1305     switch (getTriple().getOS()) {
1306     case llvm::Triple::FreeBSD:
1307       LongDoubleWidth = LongDoubleAlign = 64;
1308       LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1309       break;
1310     case llvm::Triple::NetBSD:
1311       IntMaxType = SignedLongLong;
1312       Int64Type = SignedLongLong;
1313       break;
1314     default:
1315       break;
1316     }
1317 
1318     // PPC64 supports atomics up to 8 bytes.
1319     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
1320   }
1321   BuiltinVaListKind getBuiltinVaListKind() const override {
1322     return TargetInfo::CharPtrBuiltinVaList;
1323   }
1324   // PPC64 Linux-specifc ABI options.
1325   bool setABI(const std::string &Name) override {
1326     if (Name == "elfv1" || Name == "elfv2") {
1327       ABI = Name;
1328       return true;
1329     }
1330     return false;
1331   }
1332 };
1333 } // end anonymous namespace.
1334 
1335 
1336 namespace {
1337 class DarwinPPC32TargetInfo :
1338   public DarwinTargetInfo<PPC32TargetInfo> {
1339 public:
1340   DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1341       : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
1342     HasAlignMac68kSupport = true;
1343     BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
1344     PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
1345     LongLongAlign = 32;
1346     SuitableAlign = 128;
1347     DescriptionString = "E-m:o-p:32:32-f64:32:64-n32";
1348   }
1349   BuiltinVaListKind getBuiltinVaListKind() const override {
1350     return TargetInfo::CharPtrBuiltinVaList;
1351   }
1352 };
1353 
1354 class DarwinPPC64TargetInfo :
1355   public DarwinTargetInfo<PPC64TargetInfo> {
1356 public:
1357   DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1358       : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
1359     HasAlignMac68kSupport = true;
1360     SuitableAlign = 128;
1361     DescriptionString = "E-m:o-i64:64-n32:64";
1362   }
1363 };
1364 } // end anonymous namespace.
1365 
1366 namespace {
1367   static const unsigned NVPTXAddrSpaceMap[] = {
1368     1,    // opencl_global
1369     3,    // opencl_local
1370     4,    // opencl_constant
1371     1,    // cuda_device
1372     4,    // cuda_constant
1373     3,    // cuda_shared
1374   };
1375   class NVPTXTargetInfo : public TargetInfo {
1376     static const char * const GCCRegNames[];
1377     static const Builtin::Info BuiltinInfo[];
1378   public:
1379     NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
1380       BigEndian = false;
1381       TLSSupported = false;
1382       LongWidth = LongAlign = 64;
1383       AddrSpaceMap = &NVPTXAddrSpaceMap;
1384       UseAddrSpaceMapMangling = true;
1385       // Define available target features
1386       // These must be defined in sorted order!
1387       NoAsmVariants = true;
1388     }
1389     void getTargetDefines(const LangOptions &Opts,
1390                           MacroBuilder &Builder) const override {
1391       Builder.defineMacro("__PTX__");
1392       Builder.defineMacro("__NVPTX__");
1393     }
1394     void getTargetBuiltins(const Builtin::Info *&Records,
1395                            unsigned &NumRecords) const override {
1396       Records = BuiltinInfo;
1397       NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
1398     }
1399     bool hasFeature(StringRef Feature) const override {
1400       return Feature == "ptx" || Feature == "nvptx";
1401     }
1402 
1403     void getGCCRegNames(const char * const *&Names,
1404                         unsigned &NumNames) const override;
1405     void getGCCRegAliases(const GCCRegAlias *&Aliases,
1406                                   unsigned &NumAliases) const override {
1407       // No aliases.
1408       Aliases = nullptr;
1409       NumAliases = 0;
1410     }
1411     bool
1412     validateAsmConstraint(const char *&Name,
1413                           TargetInfo::ConstraintInfo &Info) const override {
1414       switch (*Name) {
1415       default: return false;
1416       case 'c':
1417       case 'h':
1418       case 'r':
1419       case 'l':
1420       case 'f':
1421       case 'd':
1422         Info.setAllowsRegister();
1423         return true;
1424       }
1425     }
1426     const char *getClobbers() const override {
1427       // FIXME: Is this really right?
1428       return "";
1429     }
1430     BuiltinVaListKind getBuiltinVaListKind() const override {
1431       // FIXME: implement
1432       return TargetInfo::CharPtrBuiltinVaList;
1433     }
1434     bool setCPU(const std::string &Name) override {
1435       bool Valid = llvm::StringSwitch<bool>(Name)
1436         .Case("sm_20", true)
1437         .Case("sm_21", true)
1438         .Case("sm_30", true)
1439         .Case("sm_35", true)
1440         .Default(false);
1441 
1442       return Valid;
1443     }
1444   };
1445 
1446   const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1447 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1448 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1449                                               ALL_LANGUAGES },
1450 #include "clang/Basic/BuiltinsNVPTX.def"
1451   };
1452 
1453   const char * const NVPTXTargetInfo::GCCRegNames[] = {
1454     "r0"
1455   };
1456 
1457   void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1458                                      unsigned &NumNames) const {
1459     Names = GCCRegNames;
1460     NumNames = llvm::array_lengthof(GCCRegNames);
1461   }
1462 
1463   class NVPTX32TargetInfo : public NVPTXTargetInfo {
1464   public:
1465     NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
1466       PointerWidth = PointerAlign = 32;
1467       SizeType     = PtrDiffType = TargetInfo::UnsignedInt;
1468       IntPtrType = TargetInfo::SignedInt;
1469       DescriptionString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
1470   }
1471   };
1472 
1473   class NVPTX64TargetInfo : public NVPTXTargetInfo {
1474   public:
1475     NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
1476       PointerWidth = PointerAlign = 64;
1477       SizeType     = PtrDiffType = TargetInfo::UnsignedLongLong;
1478       IntPtrType = TargetInfo::SignedLongLong;
1479       DescriptionString = "e-i64:64-v16:16-v32:32-n16:32:64";
1480   }
1481   };
1482 }
1483 
1484 namespace {
1485 
1486 static const unsigned R600AddrSpaceMap[] = {
1487   1,    // opencl_global
1488   3,    // opencl_local
1489   2,    // opencl_constant
1490   1,    // cuda_device
1491   2,    // cuda_constant
1492   3     // cuda_shared
1493 };
1494 
1495 // If you edit the description strings, make sure you update
1496 // getPointerWidthV().
1497 
1498 static const char *DescriptionStringR600 =
1499   "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1500   "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1501 
1502 static const char *DescriptionStringR600DoubleOps =
1503   "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1504   "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1505 
1506 static const char *DescriptionStringSI =
1507   "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64"
1508   "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1509   "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
1510 
1511 class R600TargetInfo : public TargetInfo {
1512   static const Builtin::Info BuiltinInfo[];
1513 
1514   /// \brief The GPU profiles supported by the R600 target.
1515   enum GPUKind {
1516     GK_NONE,
1517     GK_R600,
1518     GK_R600_DOUBLE_OPS,
1519     GK_R700,
1520     GK_R700_DOUBLE_OPS,
1521     GK_EVERGREEN,
1522     GK_EVERGREEN_DOUBLE_OPS,
1523     GK_NORTHERN_ISLANDS,
1524     GK_CAYMAN,
1525     GK_SOUTHERN_ISLANDS,
1526     GK_SEA_ISLANDS
1527   } GPU;
1528 
1529 public:
1530   R600TargetInfo(const llvm::Triple &Triple)
1531       : TargetInfo(Triple), GPU(GK_R600) {
1532     DescriptionString = DescriptionStringR600;
1533     AddrSpaceMap = &R600AddrSpaceMap;
1534     UseAddrSpaceMapMangling = true;
1535   }
1536 
1537   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
1538     if (GPU <= GK_CAYMAN)
1539       return 32;
1540 
1541     switch(AddrSpace) {
1542       default:
1543         return 64;
1544       case 0:
1545       case 3:
1546       case 5:
1547         return 32;
1548     }
1549   }
1550 
1551   const char * getClobbers() const override {
1552     return "";
1553   }
1554 
1555   void getGCCRegNames(const char * const *&Names,
1556                       unsigned &numNames) const override {
1557     Names = nullptr;
1558     numNames = 0;
1559   }
1560 
1561   void getGCCRegAliases(const GCCRegAlias *&Aliases,
1562                         unsigned &NumAliases) const override {
1563     Aliases = nullptr;
1564     NumAliases = 0;
1565   }
1566 
1567   bool validateAsmConstraint(const char *&Name,
1568                              TargetInfo::ConstraintInfo &info) const override {
1569     return true;
1570   }
1571 
1572   void getTargetBuiltins(const Builtin::Info *&Records,
1573                          unsigned &NumRecords) const override {
1574     Records = BuiltinInfo;
1575     NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin;
1576   }
1577 
1578   void getTargetDefines(const LangOptions &Opts,
1579                         MacroBuilder &Builder) const override {
1580     Builder.defineMacro("__R600__");
1581   }
1582 
1583   BuiltinVaListKind getBuiltinVaListKind() const override {
1584     return TargetInfo::CharPtrBuiltinVaList;
1585   }
1586 
1587   bool setCPU(const std::string &Name) override {
1588     GPU = llvm::StringSwitch<GPUKind>(Name)
1589       .Case("r600" ,    GK_R600)
1590       .Case("rv610",    GK_R600)
1591       .Case("rv620",    GK_R600)
1592       .Case("rv630",    GK_R600)
1593       .Case("rv635",    GK_R600)
1594       .Case("rs780",    GK_R600)
1595       .Case("rs880",    GK_R600)
1596       .Case("rv670",    GK_R600_DOUBLE_OPS)
1597       .Case("rv710",    GK_R700)
1598       .Case("rv730",    GK_R700)
1599       .Case("rv740",    GK_R700_DOUBLE_OPS)
1600       .Case("rv770",    GK_R700_DOUBLE_OPS)
1601       .Case("palm",     GK_EVERGREEN)
1602       .Case("cedar",    GK_EVERGREEN)
1603       .Case("sumo",     GK_EVERGREEN)
1604       .Case("sumo2",    GK_EVERGREEN)
1605       .Case("redwood",  GK_EVERGREEN)
1606       .Case("juniper",  GK_EVERGREEN)
1607       .Case("hemlock",  GK_EVERGREEN_DOUBLE_OPS)
1608       .Case("cypress",  GK_EVERGREEN_DOUBLE_OPS)
1609       .Case("barts",    GK_NORTHERN_ISLANDS)
1610       .Case("turks",    GK_NORTHERN_ISLANDS)
1611       .Case("caicos",   GK_NORTHERN_ISLANDS)
1612       .Case("cayman",   GK_CAYMAN)
1613       .Case("aruba",    GK_CAYMAN)
1614       .Case("tahiti",   GK_SOUTHERN_ISLANDS)
1615       .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1616       .Case("verde",    GK_SOUTHERN_ISLANDS)
1617       .Case("oland",    GK_SOUTHERN_ISLANDS)
1618       .Case("hainan",   GK_SOUTHERN_ISLANDS)
1619       .Case("bonaire",  GK_SEA_ISLANDS)
1620       .Case("kabini",   GK_SEA_ISLANDS)
1621       .Case("kaveri",   GK_SEA_ISLANDS)
1622       .Case("hawaii",   GK_SEA_ISLANDS)
1623       .Case("mullins",  GK_SEA_ISLANDS)
1624       .Default(GK_NONE);
1625 
1626     if (GPU == GK_NONE) {
1627       return false;
1628     }
1629 
1630     // Set the correct data layout
1631     switch (GPU) {
1632     case GK_NONE:
1633     case GK_R600:
1634     case GK_R700:
1635     case GK_EVERGREEN:
1636     case GK_NORTHERN_ISLANDS:
1637       DescriptionString = DescriptionStringR600;
1638       break;
1639     case GK_R600_DOUBLE_OPS:
1640     case GK_R700_DOUBLE_OPS:
1641     case GK_EVERGREEN_DOUBLE_OPS:
1642     case GK_CAYMAN:
1643       DescriptionString = DescriptionStringR600DoubleOps;
1644       break;
1645     case GK_SOUTHERN_ISLANDS:
1646     case GK_SEA_ISLANDS:
1647       DescriptionString = DescriptionStringSI;
1648       break;
1649     }
1650 
1651     return true;
1652   }
1653 };
1654 
1655 const Builtin::Info R600TargetInfo::BuiltinInfo[] = {
1656 #define BUILTIN(ID, TYPE, ATTRS)                \
1657   { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1658 #include "clang/Basic/BuiltinsR600.def"
1659 };
1660 
1661 } // end anonymous namespace
1662 
1663 namespace {
1664 // Namespace for x86 abstract base class
1665 const Builtin::Info BuiltinInfo[] = {
1666 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1667 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1668                                               ALL_LANGUAGES },
1669 #include "clang/Basic/BuiltinsX86.def"
1670 };
1671 
1672 static const char* const GCCRegNames[] = {
1673   "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1674   "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
1675   "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
1676   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1677   "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1678   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1679   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
1680   "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1681   "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
1682 };
1683 
1684 const TargetInfo::AddlRegName AddlRegNames[] = {
1685   { { "al", "ah", "eax", "rax" }, 0 },
1686   { { "bl", "bh", "ebx", "rbx" }, 3 },
1687   { { "cl", "ch", "ecx", "rcx" }, 2 },
1688   { { "dl", "dh", "edx", "rdx" }, 1 },
1689   { { "esi", "rsi" }, 4 },
1690   { { "edi", "rdi" }, 5 },
1691   { { "esp", "rsp" }, 7 },
1692   { { "ebp", "rbp" }, 6 },
1693 };
1694 
1695 // X86 target abstract base class; x86-32 and x86-64 are very close, so
1696 // most of the implementation can be shared.
1697 class X86TargetInfo : public TargetInfo {
1698   enum X86SSEEnum {
1699     NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
1700   } SSELevel;
1701   enum MMX3DNowEnum {
1702     NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1703   } MMX3DNowLevel;
1704   enum XOPEnum {
1705     NoXOP,
1706     SSE4A,
1707     FMA4,
1708     XOP
1709   } XOPLevel;
1710 
1711   bool HasAES;
1712   bool HasPCLMUL;
1713   bool HasLZCNT;
1714   bool HasRDRND;
1715   bool HasFSGSBASE;
1716   bool HasBMI;
1717   bool HasBMI2;
1718   bool HasPOPCNT;
1719   bool HasRTM;
1720   bool HasPRFCHW;
1721   bool HasRDSEED;
1722   bool HasADX;
1723   bool HasTBM;
1724   bool HasFMA;
1725   bool HasF16C;
1726   bool HasAVX512CD, HasAVX512ER, HasAVX512PF, HasAVX512DQ, HasAVX512BW,
1727       HasAVX512VL;
1728   bool HasSHA;
1729   bool HasCX16;
1730 
1731   /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1732   ///
1733   /// Each enumeration represents a particular CPU supported by Clang. These
1734   /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1735   enum CPUKind {
1736     CK_Generic,
1737 
1738     /// \name i386
1739     /// i386-generation processors.
1740     //@{
1741     CK_i386,
1742     //@}
1743 
1744     /// \name i486
1745     /// i486-generation processors.
1746     //@{
1747     CK_i486,
1748     CK_WinChipC6,
1749     CK_WinChip2,
1750     CK_C3,
1751     //@}
1752 
1753     /// \name i586
1754     /// i586-generation processors, P5 microarchitecture based.
1755     //@{
1756     CK_i586,
1757     CK_Pentium,
1758     CK_PentiumMMX,
1759     //@}
1760 
1761     /// \name i686
1762     /// i686-generation processors, P6 / Pentium M microarchitecture based.
1763     //@{
1764     CK_i686,
1765     CK_PentiumPro,
1766     CK_Pentium2,
1767     CK_Pentium3,
1768     CK_Pentium3M,
1769     CK_PentiumM,
1770     CK_C3_2,
1771 
1772     /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1773     /// Clang however has some logic to suport this.
1774     // FIXME: Warn, deprecate, and potentially remove this.
1775     CK_Yonah,
1776     //@}
1777 
1778     /// \name Netburst
1779     /// Netburst microarchitecture based processors.
1780     //@{
1781     CK_Pentium4,
1782     CK_Pentium4M,
1783     CK_Prescott,
1784     CK_Nocona,
1785     //@}
1786 
1787     /// \name Core
1788     /// Core microarchitecture based processors.
1789     //@{
1790     CK_Core2,
1791 
1792     /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1793     /// codename which GCC no longer accepts as an option to -march, but Clang
1794     /// has some logic for recognizing it.
1795     // FIXME: Warn, deprecate, and potentially remove this.
1796     CK_Penryn,
1797     //@}
1798 
1799     /// \name Atom
1800     /// Atom processors
1801     //@{
1802     CK_Atom,
1803     CK_Silvermont,
1804     //@}
1805 
1806     /// \name Nehalem
1807     /// Nehalem microarchitecture based processors.
1808     //@{
1809     CK_Corei7,
1810     CK_Corei7AVX,
1811     CK_CoreAVXi,
1812     CK_CoreAVX2,
1813     CK_Broadwell,
1814     //@}
1815 
1816     /// \name Knights Landing
1817     /// Knights Landing processor.
1818     CK_KNL,
1819 
1820     /// \name Skylake Server
1821     /// Skylake server processor.
1822     CK_SKX,
1823 
1824     /// \name K6
1825     /// K6 architecture processors.
1826     //@{
1827     CK_K6,
1828     CK_K6_2,
1829     CK_K6_3,
1830     //@}
1831 
1832     /// \name K7
1833     /// K7 architecture processors.
1834     //@{
1835     CK_Athlon,
1836     CK_AthlonThunderbird,
1837     CK_Athlon4,
1838     CK_AthlonXP,
1839     CK_AthlonMP,
1840     //@}
1841 
1842     /// \name K8
1843     /// K8 architecture processors.
1844     //@{
1845     CK_Athlon64,
1846     CK_Athlon64SSE3,
1847     CK_AthlonFX,
1848     CK_K8,
1849     CK_K8SSE3,
1850     CK_Opteron,
1851     CK_OpteronSSE3,
1852     CK_AMDFAM10,
1853     //@}
1854 
1855     /// \name Bobcat
1856     /// Bobcat architecture processors.
1857     //@{
1858     CK_BTVER1,
1859     CK_BTVER2,
1860     //@}
1861 
1862     /// \name Bulldozer
1863     /// Bulldozer architecture processors.
1864     //@{
1865     CK_BDVER1,
1866     CK_BDVER2,
1867     CK_BDVER3,
1868     CK_BDVER4,
1869     //@}
1870 
1871     /// This specification is deprecated and will be removed in the future.
1872     /// Users should prefer \see CK_K8.
1873     // FIXME: Warn on this when the CPU is set to it.
1874     //@{
1875     CK_x86_64,
1876     //@}
1877 
1878     /// \name Geode
1879     /// Geode processors.
1880     //@{
1881     CK_Geode
1882     //@}
1883   } CPU;
1884 
1885   enum FPMathKind {
1886     FP_Default,
1887     FP_SSE,
1888     FP_387
1889   } FPMath;
1890 
1891 public:
1892   X86TargetInfo(const llvm::Triple &Triple)
1893       : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
1894         XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
1895         HasRDRND(false), HasFSGSBASE(false), HasBMI(false), HasBMI2(false),
1896         HasPOPCNT(false), HasRTM(false), HasPRFCHW(false), HasRDSEED(false),
1897         HasADX(false), HasTBM(false), HasFMA(false), HasF16C(false),
1898         HasAVX512CD(false), HasAVX512ER(false), HasAVX512PF(false),
1899         HasAVX512DQ(false), HasAVX512BW(false), HasAVX512VL(false),
1900         HasSHA(false), HasCX16(false), CPU(CK_Generic), FPMath(FP_Default) {
1901     BigEndian = false;
1902     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
1903   }
1904   unsigned getFloatEvalMethod() const override {
1905     // X87 evaluates with 80 bits "long double" precision.
1906     return SSELevel == NoSSE ? 2 : 0;
1907   }
1908   void getTargetBuiltins(const Builtin::Info *&Records,
1909                                  unsigned &NumRecords) const override {
1910     Records = BuiltinInfo;
1911     NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
1912   }
1913   void getGCCRegNames(const char * const *&Names,
1914                       unsigned &NumNames) const override {
1915     Names = GCCRegNames;
1916     NumNames = llvm::array_lengthof(GCCRegNames);
1917   }
1918   void getGCCRegAliases(const GCCRegAlias *&Aliases,
1919                         unsigned &NumAliases) const override {
1920     Aliases = nullptr;
1921     NumAliases = 0;
1922   }
1923   void getGCCAddlRegNames(const AddlRegName *&Names,
1924                           unsigned &NumNames) const override {
1925     Names = AddlRegNames;
1926     NumNames = llvm::array_lengthof(AddlRegNames);
1927   }
1928   bool validateAsmConstraint(const char *&Name,
1929                              TargetInfo::ConstraintInfo &info) const override;
1930 
1931   bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
1932 
1933   bool validateInputSize(StringRef Constraint, unsigned Size) const override;
1934 
1935   virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
1936 
1937   std::string convertConstraint(const char *&Constraint) const override;
1938   const char *getClobbers() const override {
1939     return "~{dirflag},~{fpsr},~{flags}";
1940   }
1941   void getTargetDefines(const LangOptions &Opts,
1942                         MacroBuilder &Builder) const override;
1943   static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
1944                           bool Enabled);
1945   static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
1946                           bool Enabled);
1947   static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
1948                           bool Enabled);
1949   void setFeatureEnabled(llvm::StringMap<bool> &Features,
1950                          StringRef Name, bool Enabled) const override {
1951     setFeatureEnabledImpl(Features, Name, Enabled);
1952   }
1953   // This exists purely to cut down on the number of virtual calls in
1954   // getDefaultFeatures which calls this repeatedly.
1955   static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
1956                                     StringRef Name, bool Enabled);
1957   void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
1958   bool hasFeature(StringRef Feature) const override;
1959   bool handleTargetFeatures(std::vector<std::string> &Features,
1960                             DiagnosticsEngine &Diags) override;
1961   StringRef getABI() const override {
1962     if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
1963       return "avx";
1964     else if (getTriple().getArch() == llvm::Triple::x86 &&
1965              MMX3DNowLevel == NoMMX3DNow)
1966       return "no-mmx";
1967     return "";
1968   }
1969   bool setCPU(const std::string &Name) override {
1970     CPU = llvm::StringSwitch<CPUKind>(Name)
1971       .Case("i386", CK_i386)
1972       .Case("i486", CK_i486)
1973       .Case("winchip-c6", CK_WinChipC6)
1974       .Case("winchip2", CK_WinChip2)
1975       .Case("c3", CK_C3)
1976       .Case("i586", CK_i586)
1977       .Case("pentium", CK_Pentium)
1978       .Case("pentium-mmx", CK_PentiumMMX)
1979       .Case("i686", CK_i686)
1980       .Case("pentiumpro", CK_PentiumPro)
1981       .Case("pentium2", CK_Pentium2)
1982       .Case("pentium3", CK_Pentium3)
1983       .Case("pentium3m", CK_Pentium3M)
1984       .Case("pentium-m", CK_PentiumM)
1985       .Case("c3-2", CK_C3_2)
1986       .Case("yonah", CK_Yonah)
1987       .Case("pentium4", CK_Pentium4)
1988       .Case("pentium4m", CK_Pentium4M)
1989       .Case("prescott", CK_Prescott)
1990       .Case("nocona", CK_Nocona)
1991       .Case("core2", CK_Core2)
1992       .Case("penryn", CK_Penryn)
1993       .Case("atom", CK_Atom)
1994       .Case("slm", CK_Silvermont)
1995       .Case("corei7", CK_Corei7)
1996       .Case("corei7-avx", CK_Corei7AVX)
1997       .Case("core-avx-i", CK_CoreAVXi)
1998       .Case("core-avx2", CK_CoreAVX2)
1999       .Case("broadwell", CK_Broadwell)
2000       .Case("knl", CK_KNL)
2001       .Case("skx", CK_SKX)
2002       .Case("k6", CK_K6)
2003       .Case("k6-2", CK_K6_2)
2004       .Case("k6-3", CK_K6_3)
2005       .Case("athlon", CK_Athlon)
2006       .Case("athlon-tbird", CK_AthlonThunderbird)
2007       .Case("athlon-4", CK_Athlon4)
2008       .Case("athlon-xp", CK_AthlonXP)
2009       .Case("athlon-mp", CK_AthlonMP)
2010       .Case("athlon64", CK_Athlon64)
2011       .Case("athlon64-sse3", CK_Athlon64SSE3)
2012       .Case("athlon-fx", CK_AthlonFX)
2013       .Case("k8", CK_K8)
2014       .Case("k8-sse3", CK_K8SSE3)
2015       .Case("opteron", CK_Opteron)
2016       .Case("opteron-sse3", CK_OpteronSSE3)
2017       .Case("amdfam10", CK_AMDFAM10)
2018       .Case("btver1", CK_BTVER1)
2019       .Case("btver2", CK_BTVER2)
2020       .Case("bdver1", CK_BDVER1)
2021       .Case("bdver2", CK_BDVER2)
2022       .Case("bdver3", CK_BDVER3)
2023       .Case("bdver4", CK_BDVER4)
2024       .Case("x86-64", CK_x86_64)
2025       .Case("geode", CK_Geode)
2026       .Default(CK_Generic);
2027 
2028     // Perform any per-CPU checks necessary to determine if this CPU is
2029     // acceptable.
2030     // FIXME: This results in terrible diagnostics. Clang just says the CPU is
2031     // invalid without explaining *why*.
2032     switch (CPU) {
2033     case CK_Generic:
2034       // No processor selected!
2035       return false;
2036 
2037     case CK_i386:
2038     case CK_i486:
2039     case CK_WinChipC6:
2040     case CK_WinChip2:
2041     case CK_C3:
2042     case CK_i586:
2043     case CK_Pentium:
2044     case CK_PentiumMMX:
2045     case CK_i686:
2046     case CK_PentiumPro:
2047     case CK_Pentium2:
2048     case CK_Pentium3:
2049     case CK_Pentium3M:
2050     case CK_PentiumM:
2051     case CK_Yonah:
2052     case CK_C3_2:
2053     case CK_Pentium4:
2054     case CK_Pentium4M:
2055     case CK_Prescott:
2056     case CK_K6:
2057     case CK_K6_2:
2058     case CK_K6_3:
2059     case CK_Athlon:
2060     case CK_AthlonThunderbird:
2061     case CK_Athlon4:
2062     case CK_AthlonXP:
2063     case CK_AthlonMP:
2064     case CK_Geode:
2065       // Only accept certain architectures when compiling in 32-bit mode.
2066       if (getTriple().getArch() != llvm::Triple::x86)
2067         return false;
2068 
2069       // Fallthrough
2070     case CK_Nocona:
2071     case CK_Core2:
2072     case CK_Penryn:
2073     case CK_Atom:
2074     case CK_Silvermont:
2075     case CK_Corei7:
2076     case CK_Corei7AVX:
2077     case CK_CoreAVXi:
2078     case CK_CoreAVX2:
2079     case CK_Broadwell:
2080     case CK_KNL:
2081     case CK_SKX:
2082     case CK_Athlon64:
2083     case CK_Athlon64SSE3:
2084     case CK_AthlonFX:
2085     case CK_K8:
2086     case CK_K8SSE3:
2087     case CK_Opteron:
2088     case CK_OpteronSSE3:
2089     case CK_AMDFAM10:
2090     case CK_BTVER1:
2091     case CK_BTVER2:
2092     case CK_BDVER1:
2093     case CK_BDVER2:
2094     case CK_BDVER3:
2095     case CK_BDVER4:
2096     case CK_x86_64:
2097       return true;
2098     }
2099     llvm_unreachable("Unhandled CPU kind");
2100   }
2101 
2102   bool setFPMath(StringRef Name) override;
2103 
2104   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
2105     // We accept all non-ARM calling conventions
2106     return (CC == CC_X86ThisCall ||
2107             CC == CC_X86FastCall ||
2108             CC == CC_X86StdCall ||
2109             CC == CC_X86VectorCall ||
2110             CC == CC_C ||
2111             CC == CC_X86Pascal ||
2112             CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
2113   }
2114 
2115   CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
2116     return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
2117   }
2118 };
2119 
2120 bool X86TargetInfo::setFPMath(StringRef Name) {
2121   if (Name == "387") {
2122     FPMath = FP_387;
2123     return true;
2124   }
2125   if (Name == "sse") {
2126     FPMath = FP_SSE;
2127     return true;
2128   }
2129   return false;
2130 }
2131 
2132 void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
2133   // FIXME: This *really* should not be here.
2134 
2135   // X86_64 always has SSE2.
2136   if (getTriple().getArch() == llvm::Triple::x86_64)
2137     setFeatureEnabledImpl(Features, "sse2", true);
2138 
2139   switch (CPU) {
2140   case CK_Generic:
2141   case CK_i386:
2142   case CK_i486:
2143   case CK_i586:
2144   case CK_Pentium:
2145   case CK_i686:
2146   case CK_PentiumPro:
2147     break;
2148   case CK_PentiumMMX:
2149   case CK_Pentium2:
2150   case CK_K6:
2151   case CK_WinChipC6:
2152     setFeatureEnabledImpl(Features, "mmx", true);
2153     break;
2154   case CK_Pentium3:
2155   case CK_Pentium3M:
2156   case CK_C3_2:
2157     setFeatureEnabledImpl(Features, "sse", true);
2158     break;
2159   case CK_PentiumM:
2160   case CK_Pentium4:
2161   case CK_Pentium4M:
2162   case CK_x86_64:
2163     setFeatureEnabledImpl(Features, "sse2", true);
2164     break;
2165   case CK_Yonah:
2166   case CK_Prescott:
2167   case CK_Nocona:
2168     setFeatureEnabledImpl(Features, "sse3", true);
2169     setFeatureEnabledImpl(Features, "cx16", true);
2170     break;
2171   case CK_Core2:
2172   case CK_Atom:
2173     setFeatureEnabledImpl(Features, "ssse3", true);
2174     setFeatureEnabledImpl(Features, "cx16", true);
2175     break;
2176   case CK_Penryn:
2177     setFeatureEnabledImpl(Features, "sse4.1", true);
2178     setFeatureEnabledImpl(Features, "cx16", true);
2179     break;
2180   case CK_SKX:
2181     setFeatureEnabledImpl(Features, "avx512f", true);
2182     setFeatureEnabledImpl(Features, "avx512cd", true);
2183     setFeatureEnabledImpl(Features, "avx512dq", true);
2184     setFeatureEnabledImpl(Features, "avx512bw", true);
2185     setFeatureEnabledImpl(Features, "avx512vl", true);
2186     // FALLTHROUGH
2187   case CK_Broadwell:
2188     setFeatureEnabledImpl(Features, "rdseed", true);
2189     setFeatureEnabledImpl(Features, "adx", true);
2190     // FALLTHROUGH
2191   case CK_CoreAVX2:
2192     setFeatureEnabledImpl(Features, "avx2", true);
2193     setFeatureEnabledImpl(Features, "lzcnt", true);
2194     setFeatureEnabledImpl(Features, "bmi", true);
2195     setFeatureEnabledImpl(Features, "bmi2", true);
2196     setFeatureEnabledImpl(Features, "rtm", true);
2197     setFeatureEnabledImpl(Features, "fma", true);
2198     // FALLTHROUGH
2199   case CK_CoreAVXi:
2200     setFeatureEnabledImpl(Features, "rdrnd", true);
2201     setFeatureEnabledImpl(Features, "f16c", true);
2202     setFeatureEnabledImpl(Features, "fsgsbase", true);
2203     // FALLTHROUGH
2204   case CK_Corei7AVX:
2205     setFeatureEnabledImpl(Features, "avx", true);
2206     // FALLTHROUGH
2207   case CK_Silvermont:
2208     setFeatureEnabledImpl(Features, "aes", true);
2209     setFeatureEnabledImpl(Features, "pclmul", true);
2210     // FALLTHROUGH
2211   case CK_Corei7:
2212     setFeatureEnabledImpl(Features, "sse4.2", true);
2213     setFeatureEnabledImpl(Features, "cx16", true);
2214     break;
2215   case CK_KNL:
2216     setFeatureEnabledImpl(Features, "avx512f", true);
2217     setFeatureEnabledImpl(Features, "avx512cd", true);
2218     setFeatureEnabledImpl(Features, "avx512er", true);
2219     setFeatureEnabledImpl(Features, "avx512pf", true);
2220     setFeatureEnabledImpl(Features, "rdseed", true);
2221     setFeatureEnabledImpl(Features, "adx", true);
2222     setFeatureEnabledImpl(Features, "lzcnt", true);
2223     setFeatureEnabledImpl(Features, "bmi", true);
2224     setFeatureEnabledImpl(Features, "bmi2", true);
2225     setFeatureEnabledImpl(Features, "rtm", true);
2226     setFeatureEnabledImpl(Features, "fma", true);
2227     setFeatureEnabledImpl(Features, "rdrnd", true);
2228     setFeatureEnabledImpl(Features, "f16c", true);
2229     setFeatureEnabledImpl(Features, "fsgsbase", true);
2230     setFeatureEnabledImpl(Features, "aes", true);
2231     setFeatureEnabledImpl(Features, "pclmul", true);
2232     setFeatureEnabledImpl(Features, "cx16", true);
2233     break;
2234   case CK_K6_2:
2235   case CK_K6_3:
2236   case CK_WinChip2:
2237   case CK_C3:
2238     setFeatureEnabledImpl(Features, "3dnow", true);
2239     break;
2240   case CK_Athlon:
2241   case CK_AthlonThunderbird:
2242   case CK_Geode:
2243     setFeatureEnabledImpl(Features, "3dnowa", true);
2244     break;
2245   case CK_Athlon4:
2246   case CK_AthlonXP:
2247   case CK_AthlonMP:
2248     setFeatureEnabledImpl(Features, "sse", true);
2249     setFeatureEnabledImpl(Features, "3dnowa", true);
2250     break;
2251   case CK_K8:
2252   case CK_Opteron:
2253   case CK_Athlon64:
2254   case CK_AthlonFX:
2255     setFeatureEnabledImpl(Features, "sse2", true);
2256     setFeatureEnabledImpl(Features, "3dnowa", true);
2257     break;
2258   case CK_AMDFAM10:
2259     setFeatureEnabledImpl(Features, "sse4a", true);
2260     setFeatureEnabledImpl(Features, "lzcnt", true);
2261     setFeatureEnabledImpl(Features, "popcnt", true);
2262     // FALLTHROUGH
2263   case CK_K8SSE3:
2264   case CK_OpteronSSE3:
2265   case CK_Athlon64SSE3:
2266     setFeatureEnabledImpl(Features, "sse3", true);
2267     setFeatureEnabledImpl(Features, "3dnowa", true);
2268     break;
2269   case CK_BTVER2:
2270     setFeatureEnabledImpl(Features, "avx", true);
2271     setFeatureEnabledImpl(Features, "aes", true);
2272     setFeatureEnabledImpl(Features, "pclmul", true);
2273     setFeatureEnabledImpl(Features, "bmi", true);
2274     setFeatureEnabledImpl(Features, "f16c", true);
2275     // FALLTHROUGH
2276   case CK_BTVER1:
2277     setFeatureEnabledImpl(Features, "ssse3", true);
2278     setFeatureEnabledImpl(Features, "sse4a", true);
2279     setFeatureEnabledImpl(Features, "lzcnt", true);
2280     setFeatureEnabledImpl(Features, "popcnt", true);
2281     setFeatureEnabledImpl(Features, "prfchw", true);
2282     setFeatureEnabledImpl(Features, "cx16", true);
2283     break;
2284   case CK_BDVER4:
2285     setFeatureEnabledImpl(Features, "avx2", true);
2286     setFeatureEnabledImpl(Features, "bmi2", true);
2287     // FALLTHROUGH
2288   case CK_BDVER3:
2289     setFeatureEnabledImpl(Features, "fsgsbase", true);
2290     // FALLTHROUGH
2291   case CK_BDVER2:
2292     setFeatureEnabledImpl(Features, "bmi", true);
2293     setFeatureEnabledImpl(Features, "fma", true);
2294     setFeatureEnabledImpl(Features, "f16c", true);
2295     setFeatureEnabledImpl(Features, "tbm", true);
2296     // FALLTHROUGH
2297   case CK_BDVER1:
2298     // xop implies avx, sse4a and fma4.
2299     setFeatureEnabledImpl(Features, "xop", true);
2300     setFeatureEnabledImpl(Features, "lzcnt", true);
2301     setFeatureEnabledImpl(Features, "aes", true);
2302     setFeatureEnabledImpl(Features, "pclmul", true);
2303     setFeatureEnabledImpl(Features, "prfchw", true);
2304     setFeatureEnabledImpl(Features, "cx16", true);
2305     break;
2306   }
2307 }
2308 
2309 void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
2310                                 X86SSEEnum Level, bool Enabled) {
2311   if (Enabled) {
2312     switch (Level) {
2313     case AVX512F:
2314       Features["avx512f"] = true;
2315     case AVX2:
2316       Features["avx2"] = true;
2317     case AVX:
2318       Features["avx"] = true;
2319     case SSE42:
2320       Features["sse4.2"] = true;
2321     case SSE41:
2322       Features["sse4.1"] = true;
2323     case SSSE3:
2324       Features["ssse3"] = true;
2325     case SSE3:
2326       Features["sse3"] = true;
2327     case SSE2:
2328       Features["sse2"] = true;
2329     case SSE1:
2330       Features["sse"] = true;
2331     case NoSSE:
2332       break;
2333     }
2334     return;
2335   }
2336 
2337   switch (Level) {
2338   case NoSSE:
2339   case SSE1:
2340     Features["sse"] = false;
2341   case SSE2:
2342     Features["sse2"] = Features["pclmul"] = Features["aes"] =
2343       Features["sha"] = false;
2344   case SSE3:
2345     Features["sse3"] = false;
2346     setXOPLevel(Features, NoXOP, false);
2347   case SSSE3:
2348     Features["ssse3"] = false;
2349   case SSE41:
2350     Features["sse4.1"] = false;
2351   case SSE42:
2352     Features["sse4.2"] = false;
2353   case AVX:
2354     Features["fma"] = Features["avx"] = Features["f16c"] = false;
2355     setXOPLevel(Features, FMA4, false);
2356   case AVX2:
2357     Features["avx2"] = false;
2358   case AVX512F:
2359     Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
2360         Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] =
2361             Features["avx512vl"] = false;
2362   }
2363 }
2364 
2365 void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
2366                                 MMX3DNowEnum Level, bool Enabled) {
2367   if (Enabled) {
2368     switch (Level) {
2369     case AMD3DNowAthlon:
2370       Features["3dnowa"] = true;
2371     case AMD3DNow:
2372       Features["3dnow"] = true;
2373     case MMX:
2374       Features["mmx"] = true;
2375     case NoMMX3DNow:
2376       break;
2377     }
2378     return;
2379   }
2380 
2381   switch (Level) {
2382   case NoMMX3DNow:
2383   case MMX:
2384     Features["mmx"] = false;
2385   case AMD3DNow:
2386     Features["3dnow"] = false;
2387   case AMD3DNowAthlon:
2388     Features["3dnowa"] = false;
2389   }
2390 }
2391 
2392 void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2393                                 bool Enabled) {
2394   if (Enabled) {
2395     switch (Level) {
2396     case XOP:
2397       Features["xop"] = true;
2398     case FMA4:
2399       Features["fma4"] = true;
2400       setSSELevel(Features, AVX, true);
2401     case SSE4A:
2402       Features["sse4a"] = true;
2403       setSSELevel(Features, SSE3, true);
2404     case NoXOP:
2405       break;
2406     }
2407     return;
2408   }
2409 
2410   switch (Level) {
2411   case NoXOP:
2412   case SSE4A:
2413     Features["sse4a"] = false;
2414   case FMA4:
2415     Features["fma4"] = false;
2416   case XOP:
2417     Features["xop"] = false;
2418   }
2419 }
2420 
2421 void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2422                                           StringRef Name, bool Enabled) {
2423   // FIXME: This *really* should not be here.  We need some way of translating
2424   // options into llvm subtarget features.
2425   if (Name == "sse4")
2426     Name = "sse4.2";
2427 
2428   Features[Name] = Enabled;
2429 
2430   if (Name == "mmx") {
2431     setMMXLevel(Features, MMX, Enabled);
2432   } else if (Name == "sse") {
2433     setSSELevel(Features, SSE1, Enabled);
2434   } else if (Name == "sse2") {
2435     setSSELevel(Features, SSE2, Enabled);
2436   } else if (Name == "sse3") {
2437     setSSELevel(Features, SSE3, Enabled);
2438   } else if (Name == "ssse3") {
2439     setSSELevel(Features, SSSE3, Enabled);
2440   } else if (Name == "sse4.2") {
2441     setSSELevel(Features, SSE42, Enabled);
2442   } else if (Name == "sse4.1") {
2443     setSSELevel(Features, SSE41, Enabled);
2444   } else if (Name == "3dnow") {
2445     setMMXLevel(Features, AMD3DNow, Enabled);
2446   } else if (Name == "3dnowa") {
2447     setMMXLevel(Features, AMD3DNowAthlon, Enabled);
2448   } else if (Name == "aes") {
2449     if (Enabled)
2450       setSSELevel(Features, SSE2, Enabled);
2451   } else if (Name == "pclmul") {
2452     if (Enabled)
2453       setSSELevel(Features, SSE2, Enabled);
2454   } else if (Name == "avx") {
2455     setSSELevel(Features, AVX, Enabled);
2456   } else if (Name == "avx2") {
2457     setSSELevel(Features, AVX2, Enabled);
2458   } else if (Name == "avx512f") {
2459     setSSELevel(Features, AVX512F, Enabled);
2460   } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf"
2461           || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") {
2462     if (Enabled)
2463       setSSELevel(Features, AVX512F, Enabled);
2464   } else if (Name == "fma") {
2465     if (Enabled)
2466       setSSELevel(Features, AVX, Enabled);
2467   } else if (Name == "fma4") {
2468     setXOPLevel(Features, FMA4, Enabled);
2469   } else if (Name == "xop") {
2470     setXOPLevel(Features, XOP, Enabled);
2471   } else if (Name == "sse4a") {
2472     setXOPLevel(Features, SSE4A, Enabled);
2473   } else if (Name == "f16c") {
2474     if (Enabled)
2475       setSSELevel(Features, AVX, Enabled);
2476   } else if (Name == "sha") {
2477     if (Enabled)
2478       setSSELevel(Features, SSE2, Enabled);
2479   }
2480 }
2481 
2482 /// handleTargetFeatures - Perform initialization based on the user
2483 /// configured set of features.
2484 bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
2485                                          DiagnosticsEngine &Diags) {
2486   // Remember the maximum enabled sselevel.
2487   for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2488     // Ignore disabled features.
2489     if (Features[i][0] == '-')
2490       continue;
2491 
2492     StringRef Feature = StringRef(Features[i]).substr(1);
2493 
2494     if (Feature == "aes") {
2495       HasAES = true;
2496       continue;
2497     }
2498 
2499     if (Feature == "pclmul") {
2500       HasPCLMUL = true;
2501       continue;
2502     }
2503 
2504     if (Feature == "lzcnt") {
2505       HasLZCNT = true;
2506       continue;
2507     }
2508 
2509     if (Feature == "rdrnd") {
2510       HasRDRND = true;
2511       continue;
2512     }
2513 
2514     if (Feature == "fsgsbase") {
2515       HasFSGSBASE = true;
2516       continue;
2517     }
2518 
2519     if (Feature == "bmi") {
2520       HasBMI = true;
2521       continue;
2522     }
2523 
2524     if (Feature == "bmi2") {
2525       HasBMI2 = true;
2526       continue;
2527     }
2528 
2529     if (Feature == "popcnt") {
2530       HasPOPCNT = true;
2531       continue;
2532     }
2533 
2534     if (Feature == "rtm") {
2535       HasRTM = true;
2536       continue;
2537     }
2538 
2539     if (Feature == "prfchw") {
2540       HasPRFCHW = true;
2541       continue;
2542     }
2543 
2544     if (Feature == "rdseed") {
2545       HasRDSEED = true;
2546       continue;
2547     }
2548 
2549     if (Feature == "adx") {
2550       HasADX = true;
2551       continue;
2552     }
2553 
2554     if (Feature == "tbm") {
2555       HasTBM = true;
2556       continue;
2557     }
2558 
2559     if (Feature == "fma") {
2560       HasFMA = true;
2561       continue;
2562     }
2563 
2564     if (Feature == "f16c") {
2565       HasF16C = true;
2566       continue;
2567     }
2568 
2569     if (Feature == "avx512cd") {
2570       HasAVX512CD = true;
2571       continue;
2572     }
2573 
2574     if (Feature == "avx512er") {
2575       HasAVX512ER = true;
2576       continue;
2577     }
2578 
2579     if (Feature == "avx512pf") {
2580       HasAVX512PF = true;
2581       continue;
2582     }
2583 
2584     if (Feature == "avx512dq") {
2585       HasAVX512DQ = true;
2586       continue;
2587     }
2588 
2589     if (Feature == "avx512bw") {
2590       HasAVX512BW = true;
2591       continue;
2592     }
2593 
2594     if (Feature == "avx512vl") {
2595       HasAVX512VL = true;
2596       continue;
2597     }
2598 
2599     if (Feature == "sha") {
2600       HasSHA = true;
2601       continue;
2602     }
2603 
2604     if (Feature == "cx16") {
2605       HasCX16 = true;
2606       continue;
2607     }
2608 
2609     assert(Features[i][0] == '+' && "Invalid target feature!");
2610     X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
2611       .Case("avx512f", AVX512F)
2612       .Case("avx2", AVX2)
2613       .Case("avx", AVX)
2614       .Case("sse4.2", SSE42)
2615       .Case("sse4.1", SSE41)
2616       .Case("ssse3", SSSE3)
2617       .Case("sse3", SSE3)
2618       .Case("sse2", SSE2)
2619       .Case("sse", SSE1)
2620       .Default(NoSSE);
2621     SSELevel = std::max(SSELevel, Level);
2622 
2623     MMX3DNowEnum ThreeDNowLevel =
2624       llvm::StringSwitch<MMX3DNowEnum>(Feature)
2625         .Case("3dnowa", AMD3DNowAthlon)
2626         .Case("3dnow", AMD3DNow)
2627         .Case("mmx", MMX)
2628         .Default(NoMMX3DNow);
2629     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
2630 
2631     XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2632         .Case("xop", XOP)
2633         .Case("fma4", FMA4)
2634         .Case("sse4a", SSE4A)
2635         .Default(NoXOP);
2636     XOPLevel = std::max(XOPLevel, XLevel);
2637   }
2638 
2639   // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2640   // Can't do this earlier because we need to be able to explicitly enable
2641   // popcnt and still disable sse4.2.
2642   if (!HasPOPCNT && SSELevel >= SSE42 &&
2643       std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){
2644     HasPOPCNT = true;
2645     Features.push_back("+popcnt");
2646   }
2647 
2648   // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2649   if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow &&
2650       std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){
2651     HasPRFCHW = true;
2652     Features.push_back("+prfchw");
2653   }
2654 
2655   // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2656   // matches the selected sse level.
2657   if (FPMath == FP_SSE && SSELevel < SSE1) {
2658     Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2659     return false;
2660   } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2661     Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2662     return false;
2663   }
2664 
2665   // Don't tell the backend if we're turning off mmx; it will end up disabling
2666   // SSE, which we don't want.
2667   // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2668   // then enable MMX.
2669   std::vector<std::string>::iterator it;
2670   it = std::find(Features.begin(), Features.end(), "-mmx");
2671   if (it != Features.end())
2672     Features.erase(it);
2673   else if (SSELevel > NoSSE)
2674     MMX3DNowLevel = std::max(MMX3DNowLevel, MMX);
2675   return true;
2676 }
2677 
2678 /// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2679 /// definitions for this particular subtarget.
2680 void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
2681                                      MacroBuilder &Builder) const {
2682   // Target identification.
2683   if (getTriple().getArch() == llvm::Triple::x86_64) {
2684     Builder.defineMacro("__amd64__");
2685     Builder.defineMacro("__amd64");
2686     Builder.defineMacro("__x86_64");
2687     Builder.defineMacro("__x86_64__");
2688     if (getTriple().getArchName() == "x86_64h") {
2689       Builder.defineMacro("__x86_64h");
2690       Builder.defineMacro("__x86_64h__");
2691     }
2692   } else {
2693     DefineStd(Builder, "i386", Opts);
2694   }
2695 
2696   // Subtarget options.
2697   // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2698   // truly should be based on -mtune options.
2699   switch (CPU) {
2700   case CK_Generic:
2701     break;
2702   case CK_i386:
2703     // The rest are coming from the i386 define above.
2704     Builder.defineMacro("__tune_i386__");
2705     break;
2706   case CK_i486:
2707   case CK_WinChipC6:
2708   case CK_WinChip2:
2709   case CK_C3:
2710     defineCPUMacros(Builder, "i486");
2711     break;
2712   case CK_PentiumMMX:
2713     Builder.defineMacro("__pentium_mmx__");
2714     Builder.defineMacro("__tune_pentium_mmx__");
2715     // Fallthrough
2716   case CK_i586:
2717   case CK_Pentium:
2718     defineCPUMacros(Builder, "i586");
2719     defineCPUMacros(Builder, "pentium");
2720     break;
2721   case CK_Pentium3:
2722   case CK_Pentium3M:
2723   case CK_PentiumM:
2724     Builder.defineMacro("__tune_pentium3__");
2725     // Fallthrough
2726   case CK_Pentium2:
2727   case CK_C3_2:
2728     Builder.defineMacro("__tune_pentium2__");
2729     // Fallthrough
2730   case CK_PentiumPro:
2731     Builder.defineMacro("__tune_i686__");
2732     Builder.defineMacro("__tune_pentiumpro__");
2733     // Fallthrough
2734   case CK_i686:
2735     Builder.defineMacro("__i686");
2736     Builder.defineMacro("__i686__");
2737     // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2738     Builder.defineMacro("__pentiumpro");
2739     Builder.defineMacro("__pentiumpro__");
2740     break;
2741   case CK_Pentium4:
2742   case CK_Pentium4M:
2743     defineCPUMacros(Builder, "pentium4");
2744     break;
2745   case CK_Yonah:
2746   case CK_Prescott:
2747   case CK_Nocona:
2748     defineCPUMacros(Builder, "nocona");
2749     break;
2750   case CK_Core2:
2751   case CK_Penryn:
2752     defineCPUMacros(Builder, "core2");
2753     break;
2754   case CK_Atom:
2755     defineCPUMacros(Builder, "atom");
2756     break;
2757   case CK_Silvermont:
2758     defineCPUMacros(Builder, "slm");
2759     break;
2760   case CK_Corei7:
2761   case CK_Corei7AVX:
2762   case CK_CoreAVXi:
2763   case CK_CoreAVX2:
2764   case CK_Broadwell:
2765     defineCPUMacros(Builder, "corei7");
2766     break;
2767   case CK_KNL:
2768     defineCPUMacros(Builder, "knl");
2769     break;
2770   case CK_SKX:
2771     defineCPUMacros(Builder, "skx");
2772     break;
2773   case CK_K6_2:
2774     Builder.defineMacro("__k6_2__");
2775     Builder.defineMacro("__tune_k6_2__");
2776     // Fallthrough
2777   case CK_K6_3:
2778     if (CPU != CK_K6_2) {  // In case of fallthrough
2779       // FIXME: GCC may be enabling these in cases where some other k6
2780       // architecture is specified but -m3dnow is explicitly provided. The
2781       // exact semantics need to be determined and emulated here.
2782       Builder.defineMacro("__k6_3__");
2783       Builder.defineMacro("__tune_k6_3__");
2784     }
2785     // Fallthrough
2786   case CK_K6:
2787     defineCPUMacros(Builder, "k6");
2788     break;
2789   case CK_Athlon:
2790   case CK_AthlonThunderbird:
2791   case CK_Athlon4:
2792   case CK_AthlonXP:
2793   case CK_AthlonMP:
2794     defineCPUMacros(Builder, "athlon");
2795     if (SSELevel != NoSSE) {
2796       Builder.defineMacro("__athlon_sse__");
2797       Builder.defineMacro("__tune_athlon_sse__");
2798     }
2799     break;
2800   case CK_K8:
2801   case CK_K8SSE3:
2802   case CK_x86_64:
2803   case CK_Opteron:
2804   case CK_OpteronSSE3:
2805   case CK_Athlon64:
2806   case CK_Athlon64SSE3:
2807   case CK_AthlonFX:
2808     defineCPUMacros(Builder, "k8");
2809     break;
2810   case CK_AMDFAM10:
2811     defineCPUMacros(Builder, "amdfam10");
2812     break;
2813   case CK_BTVER1:
2814     defineCPUMacros(Builder, "btver1");
2815     break;
2816   case CK_BTVER2:
2817     defineCPUMacros(Builder, "btver2");
2818     break;
2819   case CK_BDVER1:
2820     defineCPUMacros(Builder, "bdver1");
2821     break;
2822   case CK_BDVER2:
2823     defineCPUMacros(Builder, "bdver2");
2824     break;
2825   case CK_BDVER3:
2826     defineCPUMacros(Builder, "bdver3");
2827     break;
2828   case CK_BDVER4:
2829     defineCPUMacros(Builder, "bdver4");
2830     break;
2831   case CK_Geode:
2832     defineCPUMacros(Builder, "geode");
2833     break;
2834   }
2835 
2836   // Target properties.
2837   Builder.defineMacro("__REGISTER_PREFIX__", "");
2838 
2839   // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2840   // functions in glibc header files that use FP Stack inline asm which the
2841   // backend can't deal with (PR879).
2842   Builder.defineMacro("__NO_MATH_INLINES");
2843 
2844   if (HasAES)
2845     Builder.defineMacro("__AES__");
2846 
2847   if (HasPCLMUL)
2848     Builder.defineMacro("__PCLMUL__");
2849 
2850   if (HasLZCNT)
2851     Builder.defineMacro("__LZCNT__");
2852 
2853   if (HasRDRND)
2854     Builder.defineMacro("__RDRND__");
2855 
2856   if (HasFSGSBASE)
2857     Builder.defineMacro("__FSGSBASE__");
2858 
2859   if (HasBMI)
2860     Builder.defineMacro("__BMI__");
2861 
2862   if (HasBMI2)
2863     Builder.defineMacro("__BMI2__");
2864 
2865   if (HasPOPCNT)
2866     Builder.defineMacro("__POPCNT__");
2867 
2868   if (HasRTM)
2869     Builder.defineMacro("__RTM__");
2870 
2871   if (HasPRFCHW)
2872     Builder.defineMacro("__PRFCHW__");
2873 
2874   if (HasRDSEED)
2875     Builder.defineMacro("__RDSEED__");
2876 
2877   if (HasADX)
2878     Builder.defineMacro("__ADX__");
2879 
2880   if (HasTBM)
2881     Builder.defineMacro("__TBM__");
2882 
2883   switch (XOPLevel) {
2884   case XOP:
2885     Builder.defineMacro("__XOP__");
2886   case FMA4:
2887     Builder.defineMacro("__FMA4__");
2888   case SSE4A:
2889     Builder.defineMacro("__SSE4A__");
2890   case NoXOP:
2891     break;
2892   }
2893 
2894   if (HasFMA)
2895     Builder.defineMacro("__FMA__");
2896 
2897   if (HasF16C)
2898     Builder.defineMacro("__F16C__");
2899 
2900   if (HasAVX512CD)
2901     Builder.defineMacro("__AVX512CD__");
2902   if (HasAVX512ER)
2903     Builder.defineMacro("__AVX512ER__");
2904   if (HasAVX512PF)
2905     Builder.defineMacro("__AVX512PF__");
2906   if (HasAVX512DQ)
2907     Builder.defineMacro("__AVX512DQ__");
2908   if (HasAVX512BW)
2909     Builder.defineMacro("__AVX512BW__");
2910   if (HasAVX512VL)
2911     Builder.defineMacro("__AVX512VL__");
2912 
2913   if (HasSHA)
2914     Builder.defineMacro("__SHA__");
2915 
2916   if (HasCX16)
2917     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
2918 
2919   // Each case falls through to the previous one here.
2920   switch (SSELevel) {
2921   case AVX512F:
2922     Builder.defineMacro("__AVX512F__");
2923   case AVX2:
2924     Builder.defineMacro("__AVX2__");
2925   case AVX:
2926     Builder.defineMacro("__AVX__");
2927   case SSE42:
2928     Builder.defineMacro("__SSE4_2__");
2929   case SSE41:
2930     Builder.defineMacro("__SSE4_1__");
2931   case SSSE3:
2932     Builder.defineMacro("__SSSE3__");
2933   case SSE3:
2934     Builder.defineMacro("__SSE3__");
2935   case SSE2:
2936     Builder.defineMacro("__SSE2__");
2937     Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
2938   case SSE1:
2939     Builder.defineMacro("__SSE__");
2940     Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
2941   case NoSSE:
2942     break;
2943   }
2944 
2945   if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
2946     switch (SSELevel) {
2947     case AVX512F:
2948     case AVX2:
2949     case AVX:
2950     case SSE42:
2951     case SSE41:
2952     case SSSE3:
2953     case SSE3:
2954     case SSE2:
2955       Builder.defineMacro("_M_IX86_FP", Twine(2));
2956       break;
2957     case SSE1:
2958       Builder.defineMacro("_M_IX86_FP", Twine(1));
2959       break;
2960     default:
2961       Builder.defineMacro("_M_IX86_FP", Twine(0));
2962     }
2963   }
2964 
2965   // Each case falls through to the previous one here.
2966   switch (MMX3DNowLevel) {
2967   case AMD3DNowAthlon:
2968     Builder.defineMacro("__3dNOW_A__");
2969   case AMD3DNow:
2970     Builder.defineMacro("__3dNOW__");
2971   case MMX:
2972     Builder.defineMacro("__MMX__");
2973   case NoMMX3DNow:
2974     break;
2975   }
2976 
2977   if (CPU >= CK_i486) {
2978     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2979     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2980     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2981   }
2982   if (CPU >= CK_i586)
2983     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
2984 }
2985 
2986 bool X86TargetInfo::hasFeature(StringRef Feature) const {
2987   return llvm::StringSwitch<bool>(Feature)
2988       .Case("aes", HasAES)
2989       .Case("avx", SSELevel >= AVX)
2990       .Case("avx2", SSELevel >= AVX2)
2991       .Case("avx512f", SSELevel >= AVX512F)
2992       .Case("avx512cd", HasAVX512CD)
2993       .Case("avx512er", HasAVX512ER)
2994       .Case("avx512pf", HasAVX512PF)
2995       .Case("avx512dq", HasAVX512DQ)
2996       .Case("avx512bw", HasAVX512BW)
2997       .Case("avx512vl", HasAVX512VL)
2998       .Case("bmi", HasBMI)
2999       .Case("bmi2", HasBMI2)
3000       .Case("cx16", HasCX16)
3001       .Case("f16c", HasF16C)
3002       .Case("fma", HasFMA)
3003       .Case("fma4", XOPLevel >= FMA4)
3004       .Case("fsgsbase", HasFSGSBASE)
3005       .Case("lzcnt", HasLZCNT)
3006       .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
3007       .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3008       .Case("mmx", MMX3DNowLevel >= MMX)
3009       .Case("pclmul", HasPCLMUL)
3010       .Case("popcnt", HasPOPCNT)
3011       .Case("prfchw", HasPRFCHW)
3012       .Case("rdrnd", HasRDRND)
3013       .Case("rdseed", HasRDSEED)
3014       .Case("rtm", HasRTM)
3015       .Case("sha", HasSHA)
3016       .Case("sse", SSELevel >= SSE1)
3017       .Case("sse2", SSELevel >= SSE2)
3018       .Case("sse3", SSELevel >= SSE3)
3019       .Case("ssse3", SSELevel >= SSSE3)
3020       .Case("sse4.1", SSELevel >= SSE41)
3021       .Case("sse4.2", SSELevel >= SSE42)
3022       .Case("sse4a", XOPLevel >= SSE4A)
3023       .Case("tbm", HasTBM)
3024       .Case("x86", true)
3025       .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
3026       .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
3027       .Case("xop", XOPLevel >= XOP)
3028       .Default(false);
3029 }
3030 
3031 bool
3032 X86TargetInfo::validateAsmConstraint(const char *&Name,
3033                                      TargetInfo::ConstraintInfo &Info) const {
3034   switch (*Name) {
3035   default: return false;
3036   case 'Y': // first letter of a pair:
3037     switch (*(Name+1)) {
3038     default: return false;
3039     case '0':  // First SSE register.
3040     case 't':  // Any SSE register, when SSE2 is enabled.
3041     case 'i':  // Any SSE register, when SSE2 and inter-unit moves enabled.
3042     case 'm':  // any MMX register, when inter-unit moves enabled.
3043       break;   // falls through to setAllowsRegister.
3044   }
3045   case 'f': // any x87 floating point stack register.
3046     // Constraint 'f' cannot be used for output operands.
3047     if (Info.ConstraintStr[0] == '=')
3048       return false;
3049 
3050     Info.setAllowsRegister();
3051     return true;
3052   case 'a': // eax.
3053   case 'b': // ebx.
3054   case 'c': // ecx.
3055   case 'd': // edx.
3056   case 'S': // esi.
3057   case 'D': // edi.
3058   case 'A': // edx:eax.
3059   case 't': // top of floating point stack.
3060   case 'u': // second from top of floating point stack.
3061   case 'q': // Any register accessible as [r]l: a, b, c, and d.
3062   case 'y': // Any MMX register.
3063   case 'x': // Any SSE register.
3064   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
3065   case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
3066   case 'l': // "Index" registers: any general register that can be used as an
3067             // index in a base+index memory access.
3068     Info.setAllowsRegister();
3069     return true;
3070   case 'C': // SSE floating point constant.
3071   case 'G': // x87 floating point constant.
3072   case 'e': // 32-bit signed integer constant for use with zero-extending
3073             // x86_64 instructions.
3074   case 'Z': // 32-bit unsigned integer constant for use with zero-extending
3075             // x86_64 instructions.
3076     return true;
3077   }
3078 }
3079 
3080 bool X86TargetInfo::validateOutputSize(StringRef Constraint,
3081                                        unsigned Size) const {
3082   // Strip off constraint modifiers.
3083   while (Constraint[0] == '=' ||
3084          Constraint[0] == '+' ||
3085          Constraint[0] == '&')
3086     Constraint = Constraint.substr(1);
3087 
3088   return validateOperandSize(Constraint, Size);
3089 }
3090 
3091 bool X86TargetInfo::validateInputSize(StringRef Constraint,
3092                                       unsigned Size) const {
3093   return validateOperandSize(Constraint, Size);
3094 }
3095 
3096 bool X86TargetInfo::validateOperandSize(StringRef Constraint,
3097                                         unsigned Size) const {
3098   switch (Constraint[0]) {
3099   default: break;
3100   case 'y':
3101     return Size <= 64;
3102   case 'f':
3103   case 't':
3104   case 'u':
3105     return Size <= 128;
3106   case 'x':
3107     // 256-bit ymm registers can be used if target supports AVX.
3108     return Size <= (SSELevel >= AVX ? 256U : 128U);
3109   }
3110 
3111   return true;
3112 }
3113 
3114 std::string
3115 X86TargetInfo::convertConstraint(const char *&Constraint) const {
3116   switch (*Constraint) {
3117   case 'a': return std::string("{ax}");
3118   case 'b': return std::string("{bx}");
3119   case 'c': return std::string("{cx}");
3120   case 'd': return std::string("{dx}");
3121   case 'S': return std::string("{si}");
3122   case 'D': return std::string("{di}");
3123   case 'p': // address
3124     return std::string("im");
3125   case 't': // top of floating point stack.
3126     return std::string("{st}");
3127   case 'u': // second from top of floating point stack.
3128     return std::string("{st(1)}"); // second from top of floating point stack.
3129   default:
3130     return std::string(1, *Constraint);
3131   }
3132 }
3133 } // end anonymous namespace
3134 
3135 namespace {
3136 // X86-32 generic target
3137 class X86_32TargetInfo : public X86TargetInfo {
3138 public:
3139   X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
3140     DoubleAlign = LongLongAlign = 32;
3141     LongDoubleWidth = 96;
3142     LongDoubleAlign = 32;
3143     SuitableAlign = 128;
3144     DescriptionString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
3145     SizeType = UnsignedInt;
3146     PtrDiffType = SignedInt;
3147     IntPtrType = SignedInt;
3148     RegParmMax = 3;
3149 
3150     // Use fpret for all types.
3151     RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
3152                              (1 << TargetInfo::Double) |
3153                              (1 << TargetInfo::LongDouble));
3154 
3155     // x86-32 has atomics up to 8 bytes
3156     // FIXME: Check that we actually have cmpxchg8b before setting
3157     // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
3158     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3159   }
3160   BuiltinVaListKind getBuiltinVaListKind() const override {
3161     return TargetInfo::CharPtrBuiltinVaList;
3162   }
3163 
3164   int getEHDataRegisterNumber(unsigned RegNo) const override {
3165     if (RegNo == 0) return 0;
3166     if (RegNo == 1) return 2;
3167     return -1;
3168   }
3169   bool validateOperandSize(StringRef Constraint,
3170                            unsigned Size) const override {
3171     switch (Constraint[0]) {
3172     default: break;
3173     case 'R':
3174     case 'q':
3175     case 'Q':
3176     case 'a':
3177     case 'b':
3178     case 'c':
3179     case 'd':
3180     case 'S':
3181     case 'D':
3182       return Size <= 32;
3183     case 'A':
3184       return Size <= 64;
3185     }
3186 
3187     return X86TargetInfo::validateOperandSize(Constraint, Size);
3188   }
3189 };
3190 } // end anonymous namespace
3191 
3192 namespace {
3193 class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
3194 public:
3195   NetBSDI386TargetInfo(const llvm::Triple &Triple)
3196       : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
3197 
3198   unsigned getFloatEvalMethod() const override {
3199     unsigned Major, Minor, Micro;
3200     getTriple().getOSVersion(Major, Minor, Micro);
3201     // New NetBSD uses the default rounding mode.
3202     if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3203       return X86_32TargetInfo::getFloatEvalMethod();
3204     // NetBSD before 6.99.26 defaults to "double" rounding.
3205     return 1;
3206   }
3207 };
3208 } // end anonymous namespace
3209 
3210 namespace {
3211 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
3212 public:
3213   OpenBSDI386TargetInfo(const llvm::Triple &Triple)
3214       : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
3215     SizeType = UnsignedLong;
3216     IntPtrType = SignedLong;
3217     PtrDiffType = SignedLong;
3218   }
3219 };
3220 } // end anonymous namespace
3221 
3222 namespace {
3223 class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3224 public:
3225   BitrigI386TargetInfo(const llvm::Triple &Triple)
3226       : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
3227     SizeType = UnsignedLong;
3228     IntPtrType = SignedLong;
3229     PtrDiffType = SignedLong;
3230   }
3231 };
3232 } // end anonymous namespace
3233 
3234 namespace {
3235 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
3236 public:
3237   DarwinI386TargetInfo(const llvm::Triple &Triple)
3238       : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
3239     LongDoubleWidth = 128;
3240     LongDoubleAlign = 128;
3241     SuitableAlign = 128;
3242     MaxVectorAlign = 256;
3243     SizeType = UnsignedLong;
3244     IntPtrType = SignedLong;
3245     DescriptionString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
3246     HasAlignMac68kSupport = true;
3247   }
3248 
3249 };
3250 } // end anonymous namespace
3251 
3252 namespace {
3253 // x86-32 Windows target
3254 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
3255 public:
3256   WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3257       : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
3258     WCharType = UnsignedShort;
3259     DoubleAlign = LongLongAlign = 64;
3260     DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
3261   }
3262   void getTargetDefines(const LangOptions &Opts,
3263                         MacroBuilder &Builder) const override {
3264     WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3265   }
3266 };
3267 
3268 // x86-32 Windows Visual Studio target
3269 class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
3270 public:
3271   MicrosoftX86_32TargetInfo(const llvm::Triple &Triple)
3272       : WindowsX86_32TargetInfo(Triple) {
3273     LongDoubleWidth = LongDoubleAlign = 64;
3274     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3275   }
3276   void getTargetDefines(const LangOptions &Opts,
3277                         MacroBuilder &Builder) const override {
3278     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3279     WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3280     // The value of the following reflects processor type.
3281     // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3282     // We lost the original triple, so we use the default.
3283     Builder.defineMacro("_M_IX86", "600");
3284   }
3285 };
3286 } // end anonymous namespace
3287 
3288 static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
3289   Builder.defineMacro("__MSVCRT__");
3290   Builder.defineMacro("__MINGW32__");
3291 
3292   // Mingw defines __declspec(a) to __attribute__((a)).  Clang supports
3293   // __declspec natively under -fms-extensions, but we define a no-op __declspec
3294   // macro anyway for pre-processor compatibility.
3295   if (Opts.MicrosoftExt)
3296     Builder.defineMacro("__declspec", "__declspec");
3297   else
3298     Builder.defineMacro("__declspec(a)", "__attribute__((a))");
3299 
3300   if (!Opts.MicrosoftExt) {
3301     // Provide macros for all the calling convention keywords.  Provide both
3302     // single and double underscore prefixed variants.  These are available on
3303     // x64 as well as x86, even though they have no effect.
3304     const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
3305     for (const char *CC : CCs) {
3306       std::string GCCSpelling = "__attribute__((__";
3307       GCCSpelling += CC;
3308       GCCSpelling += "__))";
3309       Builder.defineMacro(Twine("_") + CC, GCCSpelling);
3310       Builder.defineMacro(Twine("__") + CC, GCCSpelling);
3311     }
3312   }
3313 }
3314 
3315 namespace {
3316 // x86-32 MinGW target
3317 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3318 public:
3319   MinGWX86_32TargetInfo(const llvm::Triple &Triple)
3320       : WindowsX86_32TargetInfo(Triple) {}
3321   void getTargetDefines(const LangOptions &Opts,
3322                         MacroBuilder &Builder) const override {
3323     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3324     DefineStd(Builder, "WIN32", Opts);
3325     DefineStd(Builder, "WINNT", Opts);
3326     Builder.defineMacro("_X86_");
3327     addMinGWDefines(Opts, Builder);
3328   }
3329 };
3330 } // end anonymous namespace
3331 
3332 namespace {
3333 // x86-32 Cygwin target
3334 class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3335 public:
3336   CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3337       : X86_32TargetInfo(Triple) {
3338     TLSSupported = false;
3339     WCharType = UnsignedShort;
3340     DoubleAlign = LongLongAlign = 64;
3341     DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
3342   }
3343   void getTargetDefines(const LangOptions &Opts,
3344                         MacroBuilder &Builder) const override {
3345     X86_32TargetInfo::getTargetDefines(Opts, Builder);
3346     Builder.defineMacro("_X86_");
3347     Builder.defineMacro("__CYGWIN__");
3348     Builder.defineMacro("__CYGWIN32__");
3349     DefineStd(Builder, "unix", Opts);
3350     if (Opts.CPlusPlus)
3351       Builder.defineMacro("_GNU_SOURCE");
3352   }
3353 };
3354 } // end anonymous namespace
3355 
3356 namespace {
3357 // x86-32 Haiku target
3358 class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3359 public:
3360   HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3361     SizeType = UnsignedLong;
3362     IntPtrType = SignedLong;
3363     PtrDiffType = SignedLong;
3364     ProcessIDType = SignedLong;
3365     this->UserLabelPrefix = "";
3366     this->TLSSupported = false;
3367   }
3368   void getTargetDefines(const LangOptions &Opts,
3369                         MacroBuilder &Builder) const override {
3370     X86_32TargetInfo::getTargetDefines(Opts, Builder);
3371     Builder.defineMacro("__INTEL__");
3372     Builder.defineMacro("__HAIKU__");
3373   }
3374 };
3375 } // end anonymous namespace
3376 
3377 // RTEMS Target
3378 template<typename Target>
3379 class RTEMSTargetInfo : public OSTargetInfo<Target> {
3380 protected:
3381   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3382                     MacroBuilder &Builder) const override {
3383     // RTEMS defines; list based off of gcc output
3384 
3385     Builder.defineMacro("__rtems__");
3386     Builder.defineMacro("__ELF__");
3387   }
3388 
3389 public:
3390   RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3391     this->UserLabelPrefix = "";
3392 
3393     switch (Triple.getArch()) {
3394     default:
3395     case llvm::Triple::x86:
3396       // this->MCountName = ".mcount";
3397       break;
3398     case llvm::Triple::mips:
3399     case llvm::Triple::mipsel:
3400     case llvm::Triple::ppc:
3401     case llvm::Triple::ppc64:
3402     case llvm::Triple::ppc64le:
3403       // this->MCountName = "_mcount";
3404       break;
3405     case llvm::Triple::arm:
3406       // this->MCountName = "__mcount";
3407       break;
3408     }
3409   }
3410 };
3411 
3412 namespace {
3413 // x86-32 RTEMS target
3414 class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3415 public:
3416   RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3417     SizeType = UnsignedLong;
3418     IntPtrType = SignedLong;
3419     PtrDiffType = SignedLong;
3420     this->UserLabelPrefix = "";
3421   }
3422   void getTargetDefines(const LangOptions &Opts,
3423                         MacroBuilder &Builder) const override {
3424     X86_32TargetInfo::getTargetDefines(Opts, Builder);
3425     Builder.defineMacro("__INTEL__");
3426     Builder.defineMacro("__rtems__");
3427   }
3428 };
3429 } // end anonymous namespace
3430 
3431 namespace {
3432 // x86-64 generic target
3433 class X86_64TargetInfo : public X86TargetInfo {
3434 public:
3435   X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
3436     const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
3437     LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
3438     LongDoubleWidth = 128;
3439     LongDoubleAlign = 128;
3440     LargeArrayMinWidth = 128;
3441     LargeArrayAlign = 128;
3442     SuitableAlign = 128;
3443     SizeType    = IsX32 ? UnsignedInt      : UnsignedLong;
3444     PtrDiffType = IsX32 ? SignedInt        : SignedLong;
3445     IntPtrType  = IsX32 ? SignedInt        : SignedLong;
3446     IntMaxType  = IsX32 ? SignedLongLong   : SignedLong;
3447     Int64Type   = IsX32 ? SignedLongLong   : SignedLong;
3448     RegParmMax = 6;
3449 
3450     // Pointers are 32-bit in x32.
3451     DescriptionString = (IsX32)
3452                             ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
3453                             : "e-m:e-i64:64-f80:128-n8:16:32:64-S128";
3454 
3455     // Use fpret only for long double.
3456     RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
3457 
3458     // Use fp2ret for _Complex long double.
3459     ComplexLongDoubleUsesFP2Ret = true;
3460 
3461     // x86-64 has atomics up to 16 bytes.
3462     MaxAtomicPromoteWidth = 128;
3463     MaxAtomicInlineWidth = 128;
3464   }
3465   BuiltinVaListKind getBuiltinVaListKind() const override {
3466     return TargetInfo::X86_64ABIBuiltinVaList;
3467   }
3468 
3469   int getEHDataRegisterNumber(unsigned RegNo) const override {
3470     if (RegNo == 0) return 0;
3471     if (RegNo == 1) return 1;
3472     return -1;
3473   }
3474 
3475   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
3476     return (CC == CC_C ||
3477             CC == CC_X86VectorCall ||
3478             CC == CC_IntelOclBicc ||
3479             CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
3480   }
3481 
3482   CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
3483     return CC_C;
3484   }
3485 
3486   // for x32 we need it here explicitly
3487   bool hasInt128Type() const override { return true; }
3488 };
3489 } // end anonymous namespace
3490 
3491 namespace {
3492 // x86-64 Windows target
3493 class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
3494 public:
3495   WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3496       : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
3497     WCharType = UnsignedShort;
3498     LongWidth = LongAlign = 32;
3499     DoubleAlign = LongLongAlign = 64;
3500     IntMaxType = SignedLongLong;
3501     Int64Type = SignedLongLong;
3502     SizeType = UnsignedLongLong;
3503     PtrDiffType = SignedLongLong;
3504     IntPtrType = SignedLongLong;
3505     this->UserLabelPrefix = "";
3506   }
3507   void getTargetDefines(const LangOptions &Opts,
3508                                 MacroBuilder &Builder) const override {
3509     WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
3510     Builder.defineMacro("_WIN64");
3511   }
3512   BuiltinVaListKind getBuiltinVaListKind() const override {
3513     return TargetInfo::CharPtrBuiltinVaList;
3514   }
3515   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
3516     return (CC == CC_C ||
3517             CC == CC_X86VectorCall ||
3518             CC == CC_IntelOclBicc ||
3519             CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
3520   }
3521 };
3522 } // end anonymous namespace
3523 
3524 namespace {
3525 // x86-64 Windows Visual Studio target
3526 class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
3527 public:
3528   MicrosoftX86_64TargetInfo(const llvm::Triple &Triple)
3529       : WindowsX86_64TargetInfo(Triple) {
3530     LongDoubleWidth = LongDoubleAlign = 64;
3531     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3532   }
3533   void getTargetDefines(const LangOptions &Opts,
3534                         MacroBuilder &Builder) const override {
3535     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3536     WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
3537     Builder.defineMacro("_M_X64");
3538     Builder.defineMacro("_M_AMD64");
3539   }
3540 };
3541 } // end anonymous namespace
3542 
3543 namespace {
3544 // x86-64 MinGW target
3545 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3546 public:
3547   MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3548       : WindowsX86_64TargetInfo(Triple) {}
3549   void getTargetDefines(const LangOptions &Opts,
3550                         MacroBuilder &Builder) const override {
3551     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3552     DefineStd(Builder, "WIN64", Opts);
3553     Builder.defineMacro("__MINGW64__");
3554     addMinGWDefines(Opts, Builder);
3555 
3556     // GCC defines this macro when it is using __gxx_personality_seh0.
3557     if (!Opts.SjLjExceptions)
3558       Builder.defineMacro("__SEH__");
3559   }
3560 };
3561 } // end anonymous namespace
3562 
3563 namespace {
3564 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3565 public:
3566   DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3567       : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
3568     Int64Type = SignedLongLong;
3569     MaxVectorAlign = 256;
3570     // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
3571     llvm::Triple T = llvm::Triple(Triple);
3572     if (T.isiOS())
3573       UseSignedCharForObjCBool = false;
3574     DescriptionString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128";
3575   }
3576 };
3577 } // end anonymous namespace
3578 
3579 namespace {
3580 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3581 public:
3582   OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3583       : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
3584     IntMaxType = SignedLongLong;
3585     Int64Type = SignedLongLong;
3586   }
3587 };
3588 } // end anonymous namespace
3589 
3590 namespace {
3591 class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3592 public:
3593   BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3594       : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3595     IntMaxType = SignedLongLong;
3596     Int64Type = SignedLongLong;
3597   }
3598 };
3599 }
3600 
3601 
3602 namespace {
3603 class ARMTargetInfo : public TargetInfo {
3604   // Possible FPU choices.
3605   enum FPUMode {
3606     VFP2FPU = (1 << 0),
3607     VFP3FPU = (1 << 1),
3608     VFP4FPU = (1 << 2),
3609     NeonFPU = (1 << 3),
3610     FPARMV8 = (1 << 4)
3611   };
3612 
3613   // Possible HWDiv features.
3614   enum HWDivMode {
3615     HWDivThumb = (1 << 0),
3616     HWDivARM = (1 << 1)
3617   };
3618 
3619   static bool FPUModeIsVFP(FPUMode Mode) {
3620     return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
3621   }
3622 
3623   static const TargetInfo::GCCRegAlias GCCRegAliases[];
3624   static const char * const GCCRegNames[];
3625 
3626   std::string ABI, CPU;
3627 
3628   enum {
3629     FP_Default,
3630     FP_VFP,
3631     FP_Neon
3632   } FPMath;
3633 
3634   unsigned FPU : 5;
3635 
3636   unsigned IsAAPCS : 1;
3637   unsigned IsThumb : 1;
3638   unsigned HWDiv : 2;
3639 
3640   // Initialized via features.
3641   unsigned SoftFloat : 1;
3642   unsigned SoftFloatABI : 1;
3643 
3644   unsigned CRC : 1;
3645   unsigned Crypto : 1;
3646 
3647   // ACLE 6.5.1 Hardware floating point
3648   enum {
3649     HW_FP_HP = (1 << 1), /// half (16-bit)
3650     HW_FP_SP = (1 << 2), /// single (32-bit)
3651     HW_FP_DP = (1 << 3), /// double (64-bit)
3652   };
3653   uint32_t HW_FP;
3654 
3655   static const Builtin::Info BuiltinInfo[];
3656 
3657   static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3658     StringRef ArchName = T.getArchName();
3659     if (T.getArch() == llvm::Triple::arm ||
3660         T.getArch() == llvm::Triple::armeb) {
3661       StringRef VersionStr;
3662       if (ArchName.startswith("armv"))
3663         VersionStr = ArchName.substr(4, 1);
3664       else if (ArchName.startswith("armebv"))
3665         VersionStr = ArchName.substr(6, 1);
3666       else
3667         return false;
3668       unsigned Version;
3669       if (VersionStr.getAsInteger(10, Version))
3670         return false;
3671       return Version >= 6;
3672     }
3673     assert(T.getArch() == llvm::Triple::thumb ||
3674            T.getArch() == llvm::Triple::thumbeb);
3675     StringRef VersionStr;
3676     if (ArchName.startswith("thumbv"))
3677       VersionStr = ArchName.substr(6, 1);
3678     else if (ArchName.startswith("thumbebv"))
3679       VersionStr = ArchName.substr(8, 1);
3680     else
3681       return false;
3682     unsigned Version;
3683     if (VersionStr.getAsInteger(10, Version))
3684       return false;
3685     return Version >= 7;
3686   }
3687 
3688   void setABIAAPCS() {
3689     IsAAPCS = true;
3690 
3691     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
3692     const llvm::Triple &T = getTriple();
3693 
3694     // size_t is unsigned long on MachO-derived environments and NetBSD.
3695     if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD)
3696       SizeType = UnsignedLong;
3697     else
3698       SizeType = UnsignedInt;
3699 
3700     switch (T.getOS()) {
3701     case llvm::Triple::NetBSD:
3702       WCharType = SignedInt;
3703       break;
3704     case llvm::Triple::Win32:
3705       WCharType = UnsignedShort;
3706       break;
3707     case llvm::Triple::Linux:
3708     default:
3709       // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3710       WCharType = UnsignedInt;
3711       break;
3712     }
3713 
3714     UseBitFieldTypeAlignment = true;
3715 
3716     ZeroLengthBitfieldBoundary = 0;
3717 
3718     // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3719     // so set preferred for small types to 32.
3720     if (T.isOSBinFormatMachO()) {
3721       DescriptionString =
3722           BigEndian ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3723                     : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
3724     } else if (T.isOSWindows()) {
3725       // FIXME: this is invalid for WindowsCE
3726       assert(!BigEndian && "Windows on ARM does not support big endian");
3727       DescriptionString = "e"
3728                           "-m:e"
3729                           "-p:32:32"
3730                           "-i64:64"
3731                           "-v128:64:128"
3732                           "-a:0:32"
3733                           "-n32"
3734                           "-S64";
3735     } else {
3736       DescriptionString =
3737           BigEndian ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3738                     : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
3739     }
3740 
3741     // FIXME: Enumerated types are variable width in straight AAPCS.
3742   }
3743 
3744   void setABIAPCS() {
3745     const llvm::Triple &T = getTriple();
3746 
3747     IsAAPCS = false;
3748 
3749     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
3750 
3751     // size_t is unsigned int on FreeBSD.
3752     if (T.getOS() == llvm::Triple::FreeBSD)
3753       SizeType = UnsignedInt;
3754     else
3755       SizeType = UnsignedLong;
3756 
3757     // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3758     WCharType = SignedInt;
3759 
3760     // Do not respect the alignment of bit-field types when laying out
3761     // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3762     UseBitFieldTypeAlignment = false;
3763 
3764     /// gcc forces the alignment to 4 bytes, regardless of the type of the
3765     /// zero length bitfield.  This corresponds to EMPTY_FIELD_BOUNDARY in
3766     /// gcc.
3767     ZeroLengthBitfieldBoundary = 32;
3768 
3769     if (T.isOSBinFormatMachO())
3770       DescriptionString =
3771           BigEndian
3772               ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3773               : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
3774     else
3775       DescriptionString =
3776           BigEndian
3777               ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3778               : "e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
3779 
3780     // FIXME: Override "preferred align" for double and long long.
3781   }
3782 
3783 public:
3784   ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
3785       : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default),
3786         IsAAPCS(true), HW_FP(0) {
3787     BigEndian = IsBigEndian;
3788 
3789     switch (getTriple().getOS()) {
3790     case llvm::Triple::NetBSD:
3791       PtrDiffType = SignedLong;
3792       break;
3793     default:
3794       PtrDiffType = SignedInt;
3795       break;
3796     }
3797 
3798     // {} in inline assembly are neon specifiers, not assembly variant
3799     // specifiers.
3800     NoAsmVariants = true;
3801 
3802     // FIXME: Should we just treat this as a feature?
3803     IsThumb = getTriple().getArchName().startswith("thumb");
3804 
3805     setABI("aapcs-linux");
3806 
3807     // ARM targets default to using the ARM C++ ABI.
3808     TheCXXABI.set(TargetCXXABI::GenericARM);
3809 
3810     // ARM has atomics up to 8 bytes
3811     MaxAtomicPromoteWidth = 64;
3812     if (shouldUseInlineAtomic(getTriple()))
3813       MaxAtomicInlineWidth = 64;
3814 
3815     // Do force alignment of members that follow zero length bitfields.  If
3816     // the alignment of the zero-length bitfield is greater than the member
3817     // that follows it, `bar', `bar' will be aligned as the  type of the
3818     // zero length bitfield.
3819     UseZeroLengthBitfieldAlignment = true;
3820   }
3821   StringRef getABI() const override { return ABI; }
3822   bool setABI(const std::string &Name) override {
3823     ABI = Name;
3824 
3825     // The defaults (above) are for AAPCS, check if we need to change them.
3826     //
3827     // FIXME: We need support for -meabi... we could just mangle it into the
3828     // name.
3829     if (Name == "apcs-gnu") {
3830       setABIAPCS();
3831       return true;
3832     }
3833     if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
3834       setABIAAPCS();
3835       return true;
3836     }
3837     return false;
3838   }
3839 
3840   void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
3841     if (IsAAPCS)
3842       Features["aapcs"] = true;
3843     else
3844       Features["apcs"] = true;
3845 
3846     StringRef ArchName = getTriple().getArchName();
3847     if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3848       Features["vfp2"] = true;
3849     else if (CPU == "cortex-a8" || CPU == "cortex-a9") {
3850       Features["vfp3"] = true;
3851       Features["neon"] = true;
3852     }
3853     else if (CPU == "cortex-a5") {
3854       Features["vfp4"] = true;
3855       Features["neon"] = true;
3856     } else if (CPU == "swift" || CPU == "cortex-a7" ||
3857                CPU == "cortex-a12" || CPU == "cortex-a15" ||
3858                CPU == "cortex-a17" || CPU == "krait") {
3859       Features["vfp4"] = true;
3860       Features["neon"] = true;
3861       Features["hwdiv"] = true;
3862       Features["hwdiv-arm"] = true;
3863     } else if (CPU == "cyclone") {
3864       Features["v8fp"] = true;
3865       Features["neon"] = true;
3866       Features["hwdiv"] = true;
3867       Features["hwdiv-arm"] = true;
3868     } else if (CPU == "cortex-a53" || CPU == "cortex-a57") {
3869       Features["fp-armv8"] = true;
3870       Features["neon"] = true;
3871       Features["hwdiv"] = true;
3872       Features["hwdiv-arm"] = true;
3873       Features["crc"] = true;
3874       Features["crypto"] = true;
3875     } else if (CPU == "cortex-r5" ||
3876                // Enable the hwdiv extension for all v8a AArch32 cores by
3877                // default.
3878                ArchName == "armv8a" || ArchName == "armv8" ||
3879                ArchName == "armebv8a" || ArchName == "armebv8" ||
3880                ArchName == "thumbv8a" || ArchName == "thumbv8" ||
3881                ArchName == "thumbebv8a" || ArchName == "thumbebv8") {
3882       Features["hwdiv"] = true;
3883       Features["hwdiv-arm"] = true;
3884     } else if (CPU == "cortex-m3" || CPU == "cortex-m4" || CPU == "cortex-m7") {
3885       Features["hwdiv"] = true;
3886     }
3887   }
3888 
3889   bool handleTargetFeatures(std::vector<std::string> &Features,
3890                             DiagnosticsEngine &Diags) override {
3891     FPU = 0;
3892     CRC = 0;
3893     Crypto = 0;
3894     SoftFloat = SoftFloatABI = false;
3895     HWDiv = 0;
3896 
3897     for (const auto &Feature : Features) {
3898       if (Feature == "+soft-float") {
3899         SoftFloat = true;
3900       } else if (Feature == "+soft-float-abi") {
3901         SoftFloatABI = true;
3902       } else if (Feature == "+vfp2") {
3903         FPU |= VFP2FPU;
3904         HW_FP = HW_FP_SP | HW_FP_DP;
3905       } else if (Feature == "+vfp3") {
3906         FPU |= VFP3FPU;
3907         HW_FP = HW_FP_SP | HW_FP_DP;
3908       } else if (Feature == "+vfp4") {
3909         FPU |= VFP4FPU;
3910         HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3911       } else if (Feature == "+fp-armv8") {
3912         FPU |= FPARMV8;
3913         HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3914       } else if (Feature == "+neon") {
3915         FPU |= NeonFPU;
3916         HW_FP = HW_FP_SP | HW_FP_DP;
3917       } else if (Feature == "+hwdiv") {
3918         HWDiv |= HWDivThumb;
3919       } else if (Feature == "+hwdiv-arm") {
3920         HWDiv |= HWDivARM;
3921       } else if (Feature == "+crc") {
3922         CRC = 1;
3923       } else if (Feature == "+crypto") {
3924         Crypto = 1;
3925       } else if (Feature == "+fp-only-sp") {
3926         HW_FP &= ~HW_FP_DP;
3927       }
3928     }
3929 
3930     if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
3931       Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
3932       return false;
3933     }
3934 
3935     if (FPMath == FP_Neon)
3936       Features.push_back("+neonfp");
3937     else if (FPMath == FP_VFP)
3938       Features.push_back("-neonfp");
3939 
3940     // Remove front-end specific options which the backend handles differently.
3941     const StringRef FrontEndFeatures[] = { "+soft-float", "+soft-float-abi" };
3942     for (const auto &FEFeature : FrontEndFeatures) {
3943       auto Feature = std::find(Features.begin(), Features.end(), FEFeature);
3944       if (Feature != Features.end())
3945         Features.erase(Feature);
3946     }
3947 
3948     return true;
3949   }
3950 
3951   bool hasFeature(StringRef Feature) const override {
3952     return llvm::StringSwitch<bool>(Feature)
3953         .Case("arm", true)
3954         .Case("softfloat", SoftFloat)
3955         .Case("thumb", IsThumb)
3956         .Case("neon", (FPU & NeonFPU) && !SoftFloat)
3957         .Case("hwdiv", HWDiv & HWDivThumb)
3958         .Case("hwdiv-arm", HWDiv & HWDivARM)
3959         .Default(false);
3960   }
3961   // FIXME: Should we actually have some table instead of these switches?
3962   static const char *getCPUDefineSuffix(StringRef Name) {
3963     return llvm::StringSwitch<const char *>(Name)
3964         .Cases("arm8", "arm810", "4")
3965         .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110",
3966                "4")
3967         .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3968         .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3969         .Case("ep9312", "4T")
3970         .Cases("arm10tdmi", "arm1020t", "5T")
3971         .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3972         .Case("arm926ej-s", "5TEJ")
3973         .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3974         .Cases("xscale", "iwmmxt", "5TE")
3975         .Case("arm1136j-s", "6J")
3976         .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
3977         .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
3978         .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
3979         .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3980         .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait",
3981                "7A")
3982         .Cases("cortex-r4", "cortex-r5", "7R")
3983         .Case("swift", "7S")
3984         .Case("cyclone", "8A")
3985         .Case("cortex-m3", "7M")
3986         .Cases("cortex-m4", "cortex-m7", "7EM")
3987         .Case("cortex-m0", "6M")
3988         .Cases("cortex-a53", "cortex-a57", "8A")
3989         .Default(nullptr);
3990   }
3991   static const char *getCPUProfile(StringRef Name) {
3992     return llvm::StringSwitch<const char *>(Name)
3993         .Cases("cortex-a5", "cortex-a7", "cortex-a8", "A")
3994         .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait",
3995                "A")
3996         .Cases("cortex-a53", "cortex-a57", "A")
3997         .Cases("cortex-m3", "cortex-m4", "cortex-m0", "cortex-m7", "M")
3998         .Cases("cortex-r4", "cortex-r5", "R")
3999         .Default("");
4000   }
4001   bool setCPU(const std::string &Name) override {
4002     if (!getCPUDefineSuffix(Name))
4003       return false;
4004 
4005     // Cortex M does not support 8 byte atomics, while general Thumb2 does.
4006     StringRef Profile = getCPUProfile(Name);
4007     if (Profile == "M" && MaxAtomicInlineWidth) {
4008       MaxAtomicPromoteWidth = 32;
4009       MaxAtomicInlineWidth = 32;
4010     }
4011 
4012     CPU = Name;
4013     return true;
4014   }
4015   bool setFPMath(StringRef Name) override;
4016   bool supportsThumb(StringRef ArchName, StringRef CPUArch,
4017                      unsigned CPUArchVer) const {
4018     return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) ||
4019            (CPUArch.find('M') != StringRef::npos);
4020   }
4021   bool supportsThumb2(StringRef ArchName, StringRef CPUArch,
4022                       unsigned CPUArchVer) const {
4023     // We check both CPUArchVer and ArchName because when only triple is
4024     // specified, the default CPU is arm1136j-s.
4025     return ArchName.endswith("v6t2") || ArchName.endswith("v7") ||
4026            ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7;
4027   }
4028   void getTargetDefines(const LangOptions &Opts,
4029                         MacroBuilder &Builder) const override {
4030     // Target identification.
4031     Builder.defineMacro("__arm");
4032     Builder.defineMacro("__arm__");
4033 
4034     // Target properties.
4035     Builder.defineMacro("__REGISTER_PREFIX__", "");
4036 
4037     StringRef CPUArch = getCPUDefineSuffix(CPU);
4038     unsigned int CPUArchVer;
4039     if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer))
4040       llvm_unreachable("Invalid char for architecture version number");
4041     Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
4042 
4043     // ACLE 6.4.1 ARM/Thumb instruction set architecture
4044     StringRef CPUProfile = getCPUProfile(CPU);
4045     StringRef ArchName = getTriple().getArchName();
4046 
4047     // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
4048     Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
4049     if (CPUArch[0] >= '8') {
4050       Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4051       Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
4052     }
4053 
4054     // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA.  It
4055     // is not defined for the M-profile.
4056     // NOTE that the deffault profile is assumed to be 'A'
4057     if (CPUProfile.empty() || CPUProfile != "M")
4058       Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
4059 
4060     // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original
4061     // Thumb ISA (including v6-M).  It is set to 2 if the core supports the
4062     // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture.
4063     if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
4064       Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
4065     else if (supportsThumb(ArchName, CPUArch, CPUArchVer))
4066       Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
4067 
4068     // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
4069     // instruction set such as ARM or Thumb.
4070     Builder.defineMacro("__ARM_32BIT_STATE", "1");
4071 
4072     // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
4073 
4074     // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
4075     if (!CPUProfile.empty())
4076       Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
4077 
4078     // ACLE 6.5.1 Hardware Floating Point
4079     if (HW_FP)
4080       Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
4081 
4082     // ACLE predefines.
4083     Builder.defineMacro("__ARM_ACLE", "200");
4084 
4085     // Subtarget options.
4086 
4087     // FIXME: It's more complicated than this and we don't really support
4088     // interworking.
4089     // Windows on ARM does not "support" interworking
4090     if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows())
4091       Builder.defineMacro("__THUMB_INTERWORK__");
4092 
4093     if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
4094       // Embedded targets on Darwin follow AAPCS, but not EABI.
4095       // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
4096       if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
4097         Builder.defineMacro("__ARM_EABI__");
4098       Builder.defineMacro("__ARM_PCS", "1");
4099 
4100       if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
4101         Builder.defineMacro("__ARM_PCS_VFP", "1");
4102     }
4103 
4104     if (SoftFloat)
4105       Builder.defineMacro("__SOFTFP__");
4106 
4107     if (CPU == "xscale")
4108       Builder.defineMacro("__XSCALE__");
4109 
4110     if (IsThumb) {
4111       Builder.defineMacro("__THUMBEL__");
4112       Builder.defineMacro("__thumb__");
4113       if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
4114         Builder.defineMacro("__thumb2__");
4115     }
4116     if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb))
4117       Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
4118 
4119     // Note, this is always on in gcc, even though it doesn't make sense.
4120     Builder.defineMacro("__APCS_32__");
4121 
4122     if (FPUModeIsVFP((FPUMode) FPU)) {
4123       Builder.defineMacro("__VFP_FP__");
4124       if (FPU & VFP2FPU)
4125         Builder.defineMacro("__ARM_VFPV2__");
4126       if (FPU & VFP3FPU)
4127         Builder.defineMacro("__ARM_VFPV3__");
4128       if (FPU & VFP4FPU)
4129         Builder.defineMacro("__ARM_VFPV4__");
4130     }
4131 
4132     // This only gets set when Neon instructions are actually available, unlike
4133     // the VFP define, hence the soft float and arch check. This is subtly
4134     // different from gcc, we follow the intent which was that it should be set
4135     // when Neon instructions are actually available.
4136     if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) {
4137       Builder.defineMacro("__ARM_NEON");
4138       Builder.defineMacro("__ARM_NEON__");
4139     }
4140 
4141     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
4142                         Opts.ShortWChar ? "2" : "4");
4143 
4144     Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4145                         Opts.ShortEnums ? "1" : "4");
4146 
4147     if (CRC)
4148       Builder.defineMacro("__ARM_FEATURE_CRC32");
4149 
4150     if (Crypto)
4151       Builder.defineMacro("__ARM_FEATURE_CRYPTO");
4152 
4153     if (CPUArchVer >= 6 && CPUArch != "6M") {
4154       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4155       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4156       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4157       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4158     }
4159   }
4160   void getTargetBuiltins(const Builtin::Info *&Records,
4161                          unsigned &NumRecords) const override {
4162     Records = BuiltinInfo;
4163     NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
4164   }
4165   bool isCLZForZeroUndef() const override { return false; }
4166   BuiltinVaListKind getBuiltinVaListKind() const override {
4167     return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
4168   }
4169   void getGCCRegNames(const char * const *&Names,
4170                       unsigned &NumNames) const override;
4171   void getGCCRegAliases(const GCCRegAlias *&Aliases,
4172                         unsigned &NumAliases) const override;
4173   bool validateAsmConstraint(const char *&Name,
4174                              TargetInfo::ConstraintInfo &Info) const override {
4175     switch (*Name) {
4176     default: break;
4177     case 'l': // r0-r7
4178     case 'h': // r8-r15
4179     case 'w': // VFP Floating point register single precision
4180     case 'P': // VFP Floating point register double precision
4181       Info.setAllowsRegister();
4182       return true;
4183     case 'Q': // A memory address that is a single base register.
4184       Info.setAllowsMemory();
4185       return true;
4186     case 'U': // a memory reference...
4187       switch (Name[1]) {
4188       case 'q': // ...ARMV4 ldrsb
4189       case 'v': // ...VFP load/store (reg+constant offset)
4190       case 'y': // ...iWMMXt load/store
4191       case 't': // address valid for load/store opaque types wider
4192                 // than 128-bits
4193       case 'n': // valid address for Neon doubleword vector load/store
4194       case 'm': // valid address for Neon element and structure load/store
4195       case 's': // valid address for non-offset loads/stores of quad-word
4196                 // values in four ARM registers
4197         Info.setAllowsMemory();
4198         Name++;
4199         return true;
4200       }
4201     }
4202     return false;
4203   }
4204   std::string convertConstraint(const char *&Constraint) const override {
4205     std::string R;
4206     switch (*Constraint) {
4207     case 'U':   // Two-character constraint; add "^" hint for later parsing.
4208       R = std::string("^") + std::string(Constraint, 2);
4209       Constraint++;
4210       break;
4211     case 'p': // 'p' should be translated to 'r' by default.
4212       R = std::string("r");
4213       break;
4214     default:
4215       return std::string(1, *Constraint);
4216     }
4217     return R;
4218   }
4219   bool
4220   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
4221                              std::string &SuggestedModifier) const override {
4222     bool isOutput = (Constraint[0] == '=');
4223     bool isInOut = (Constraint[0] == '+');
4224 
4225     // Strip off constraint modifiers.
4226     while (Constraint[0] == '=' ||
4227            Constraint[0] == '+' ||
4228            Constraint[0] == '&')
4229       Constraint = Constraint.substr(1);
4230 
4231     switch (Constraint[0]) {
4232     default: break;
4233     case 'r': {
4234       switch (Modifier) {
4235       default:
4236         return (isInOut || isOutput || Size <= 64);
4237       case 'q':
4238         // A register of size 32 cannot fit a vector type.
4239         return false;
4240       }
4241     }
4242     }
4243 
4244     return true;
4245   }
4246   const char *getClobbers() const override {
4247     // FIXME: Is this really right?
4248     return "";
4249   }
4250 
4251   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
4252     return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4253   }
4254 
4255   int getEHDataRegisterNumber(unsigned RegNo) const override {
4256     if (RegNo == 0) return 0;
4257     if (RegNo == 1) return 1;
4258     return -1;
4259   }
4260 };
4261 
4262 bool ARMTargetInfo::setFPMath(StringRef Name) {
4263   if (Name == "neon") {
4264     FPMath = FP_Neon;
4265     return true;
4266   } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
4267              Name == "vfp4") {
4268     FPMath = FP_VFP;
4269     return true;
4270   }
4271   return false;
4272 }
4273 
4274 const char * const ARMTargetInfo::GCCRegNames[] = {
4275   // Integer registers
4276   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4277   "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
4278 
4279   // Float registers
4280   "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
4281   "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
4282   "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
4283   "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
4284 
4285   // Double registers
4286   "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
4287   "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
4288   "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
4289   "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
4290 
4291   // Quad registers
4292   "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
4293   "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
4294 };
4295 
4296 void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
4297                                    unsigned &NumNames) const {
4298   Names = GCCRegNames;
4299   NumNames = llvm::array_lengthof(GCCRegNames);
4300 }
4301 
4302 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
4303   { { "a1" }, "r0" },
4304   { { "a2" }, "r1" },
4305   { { "a3" }, "r2" },
4306   { { "a4" }, "r3" },
4307   { { "v1" }, "r4" },
4308   { { "v2" }, "r5" },
4309   { { "v3" }, "r6" },
4310   { { "v4" }, "r7" },
4311   { { "v5" }, "r8" },
4312   { { "v6", "rfp" }, "r9" },
4313   { { "sl" }, "r10" },
4314   { { "fp" }, "r11" },
4315   { { "ip" }, "r12" },
4316   { { "r13" }, "sp" },
4317   { { "r14" }, "lr" },
4318   { { "r15" }, "pc" },
4319   // The S, D and Q registers overlap, but aren't really aliases; we
4320   // don't want to substitute one of these for a different-sized one.
4321 };
4322 
4323 void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4324                                        unsigned &NumAliases) const {
4325   Aliases = GCCRegAliases;
4326   NumAliases = llvm::array_lengthof(GCCRegAliases);
4327 }
4328 
4329 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
4330 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4331 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4332                                               ALL_LANGUAGES },
4333 #include "clang/Basic/BuiltinsNEON.def"
4334 
4335 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4336 #define LANGBUILTIN(ID, TYPE, ATTRS, LANG) { #ID, TYPE, ATTRS, 0, LANG },
4337 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4338                                               ALL_LANGUAGES },
4339 #include "clang/Basic/BuiltinsARM.def"
4340 };
4341 
4342 class ARMleTargetInfo : public ARMTargetInfo {
4343 public:
4344   ARMleTargetInfo(const llvm::Triple &Triple)
4345     : ARMTargetInfo(Triple, false) { }
4346   virtual void getTargetDefines(const LangOptions &Opts,
4347                                 MacroBuilder &Builder) const {
4348     Builder.defineMacro("__ARMEL__");
4349     ARMTargetInfo::getTargetDefines(Opts, Builder);
4350   }
4351 };
4352 
4353 class ARMbeTargetInfo : public ARMTargetInfo {
4354 public:
4355   ARMbeTargetInfo(const llvm::Triple &Triple)
4356     : ARMTargetInfo(Triple, true) { }
4357   virtual void getTargetDefines(const LangOptions &Opts,
4358                                 MacroBuilder &Builder) const {
4359     Builder.defineMacro("__ARMEB__");
4360     Builder.defineMacro("__ARM_BIG_ENDIAN");
4361     ARMTargetInfo::getTargetDefines(Opts, Builder);
4362   }
4363 };
4364 } // end anonymous namespace.
4365 
4366 namespace {
4367 class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
4368   const llvm::Triple Triple;
4369 public:
4370   WindowsARMTargetInfo(const llvm::Triple &Triple)
4371     : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
4372     TLSSupported = false;
4373     WCharType = UnsignedShort;
4374     SizeType = UnsignedInt;
4375     UserLabelPrefix = "";
4376   }
4377   void getVisualStudioDefines(const LangOptions &Opts,
4378                               MacroBuilder &Builder) const {
4379     WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
4380 
4381     // FIXME: this is invalid for WindowsCE
4382     Builder.defineMacro("_M_ARM_NT", "1");
4383     Builder.defineMacro("_M_ARMT", "_M_ARM");
4384     Builder.defineMacro("_M_THUMB", "_M_ARM");
4385 
4386     assert((Triple.getArch() == llvm::Triple::arm ||
4387             Triple.getArch() == llvm::Triple::thumb) &&
4388            "invalid architecture for Windows ARM target info");
4389     unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4390     Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
4391 
4392     // TODO map the complete set of values
4393     // 31: VFPv3 40: VFPv4
4394     Builder.defineMacro("_M_ARM_FP", "31");
4395   }
4396   BuiltinVaListKind getBuiltinVaListKind() const override {
4397     return TargetInfo::CharPtrBuiltinVaList;
4398   }
4399 };
4400 
4401 // Windows ARM + Itanium C++ ABI Target
4402 class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
4403 public:
4404   ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple)
4405     : WindowsARMTargetInfo(Triple) {
4406     TheCXXABI.set(TargetCXXABI::GenericARM);
4407   }
4408 
4409   void getTargetDefines(const LangOptions &Opts,
4410                         MacroBuilder &Builder) const override {
4411     WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4412 
4413     if (Opts.MSVCCompat)
4414       WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4415   }
4416 };
4417 
4418 // Windows ARM, MS (C++) ABI
4419 class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
4420 public:
4421   MicrosoftARMleTargetInfo(const llvm::Triple &Triple)
4422     : WindowsARMTargetInfo(Triple) {
4423     TheCXXABI.set(TargetCXXABI::Microsoft);
4424   }
4425 
4426   void getTargetDefines(const LangOptions &Opts,
4427                         MacroBuilder &Builder) const override {
4428     WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4429     WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4430   }
4431 };
4432 }
4433 
4434 
4435 namespace {
4436 class DarwinARMTargetInfo :
4437   public DarwinTargetInfo<ARMleTargetInfo> {
4438 protected:
4439   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4440                     MacroBuilder &Builder) const override {
4441     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
4442   }
4443 
4444 public:
4445   DarwinARMTargetInfo(const llvm::Triple &Triple)
4446       : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
4447     HasAlignMac68kSupport = true;
4448     // iOS always has 64-bit atomic instructions.
4449     // FIXME: This should be based off of the target features in
4450     // ARMleTargetInfo.
4451     MaxAtomicInlineWidth = 64;
4452 
4453     // Darwin on iOS uses a variant of the ARM C++ ABI.
4454     TheCXXABI.set(TargetCXXABI::iOS);
4455   }
4456 };
4457 } // end anonymous namespace.
4458 
4459 
4460 namespace {
4461 class AArch64TargetInfo : public TargetInfo {
4462   virtual void setDescriptionString() = 0;
4463   static const TargetInfo::GCCRegAlias GCCRegAliases[];
4464   static const char *const GCCRegNames[];
4465 
4466   enum FPUModeEnum {
4467     FPUMode,
4468     NeonMode
4469   };
4470 
4471   unsigned FPU;
4472   unsigned CRC;
4473   unsigned Crypto;
4474 
4475   static const Builtin::Info BuiltinInfo[];
4476 
4477   std::string ABI;
4478 
4479 public:
4480   AArch64TargetInfo(const llvm::Triple &Triple)
4481       : TargetInfo(Triple), ABI("aapcs") {
4482 
4483     if (getTriple().getOS() == llvm::Triple::NetBSD) {
4484       WCharType = SignedInt;
4485 
4486       // NetBSD apparently prefers consistency across ARM targets to consistency
4487       // across 64-bit targets.
4488       Int64Type = SignedLongLong;
4489       IntMaxType = SignedLongLong;
4490     } else {
4491       WCharType = UnsignedInt;
4492       Int64Type = SignedLong;
4493       IntMaxType = SignedLong;
4494     }
4495 
4496     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
4497     MaxVectorAlign = 128;
4498     RegParmMax = 8;
4499     MaxAtomicInlineWidth = 128;
4500     MaxAtomicPromoteWidth = 128;
4501 
4502     LongDoubleWidth = LongDoubleAlign = 128;
4503     LongDoubleFormat = &llvm::APFloat::IEEEquad;
4504 
4505     // {} in inline assembly are neon specifiers, not assembly variant
4506     // specifiers.
4507     NoAsmVariants = true;
4508 
4509     // AArch64 targets default to using the ARM C++ ABI.
4510     TheCXXABI.set(TargetCXXABI::GenericAArch64);
4511   }
4512 
4513   StringRef getABI() const override { return ABI; }
4514   bool setABI(const std::string &Name) override {
4515     if (Name != "aapcs" && Name != "darwinpcs")
4516       return false;
4517 
4518     ABI = Name;
4519     return true;
4520   }
4521 
4522   bool setCPU(const std::string &Name) override {
4523     bool CPUKnown = llvm::StringSwitch<bool>(Name)
4524                         .Case("generic", true)
4525                         .Cases("cortex-a53", "cortex-a57", true)
4526                         .Case("cyclone", true)
4527                         .Default(false);
4528     return CPUKnown;
4529   }
4530 
4531   virtual void getTargetDefines(const LangOptions &Opts,
4532                                 MacroBuilder &Builder) const  override {
4533     // Target identification.
4534     Builder.defineMacro("__aarch64__");
4535 
4536     // Target properties.
4537     Builder.defineMacro("_LP64");
4538     Builder.defineMacro("__LP64__");
4539 
4540     // ACLE predefines. Many can only have one possible value on v8 AArch64.
4541     Builder.defineMacro("__ARM_ACLE", "200");
4542     Builder.defineMacro("__ARM_ARCH", "8");
4543     Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
4544 
4545     Builder.defineMacro("__ARM_64BIT_STATE");
4546     Builder.defineMacro("__ARM_PCS_AAPCS64");
4547     Builder.defineMacro("__ARM_ARCH_ISA_A64");
4548 
4549     Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
4550     Builder.defineMacro("__ARM_FEATURE_CLZ");
4551     Builder.defineMacro("__ARM_FEATURE_FMA");
4552     Builder.defineMacro("__ARM_FEATURE_DIV");
4553     Builder.defineMacro("__ARM_FEATURE_IDIV"); // As specified in ACLE
4554     Builder.defineMacro("__ARM_FEATURE_DIV");  // For backwards compatibility
4555     Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4556     Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
4557 
4558     Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
4559 
4560     // 0xe implies support for half, single and double precision operations.
4561     Builder.defineMacro("__ARM_FP", "0xe");
4562 
4563     // PCS specifies this for SysV variants, which is all we support. Other ABIs
4564     // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
4565     Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
4566 
4567     if (Opts.FastMath || Opts.FiniteMathOnly)
4568       Builder.defineMacro("__ARM_FP_FAST");
4569 
4570     if (Opts.C99 && !Opts.Freestanding)
4571       Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
4572 
4573     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
4574 
4575     Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4576                         Opts.ShortEnums ? "1" : "4");
4577 
4578     if (FPU == NeonMode) {
4579       Builder.defineMacro("__ARM_NEON");
4580       // 64-bit NEON supports half, single and double precision operations.
4581       Builder.defineMacro("__ARM_NEON_FP", "0xe");
4582     }
4583 
4584     if (CRC)
4585       Builder.defineMacro("__ARM_FEATURE_CRC32");
4586 
4587     if (Crypto)
4588       Builder.defineMacro("__ARM_FEATURE_CRYPTO");
4589   }
4590 
4591   virtual void getTargetBuiltins(const Builtin::Info *&Records,
4592                                  unsigned &NumRecords) const override {
4593     Records = BuiltinInfo;
4594     NumRecords = clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
4595   }
4596 
4597   bool hasFeature(StringRef Feature) const override {
4598     return Feature == "aarch64" ||
4599       Feature == "arm64" ||
4600       (Feature == "neon" && FPU == NeonMode);
4601   }
4602 
4603   bool handleTargetFeatures(std::vector<std::string> &Features,
4604                             DiagnosticsEngine &Diags) override {
4605     FPU = FPUMode;
4606     CRC = 0;
4607     Crypto = 0;
4608     for (unsigned i = 0, e = Features.size(); i != e; ++i) {
4609       if (Features[i] == "+neon")
4610         FPU = NeonMode;
4611       if (Features[i] == "+crc")
4612         CRC = 1;
4613       if (Features[i] == "+crypto")
4614         Crypto = 1;
4615     }
4616 
4617     setDescriptionString();
4618 
4619     return true;
4620   }
4621 
4622   bool isCLZForZeroUndef() const override { return false; }
4623 
4624   BuiltinVaListKind getBuiltinVaListKind() const override {
4625     return TargetInfo::AArch64ABIBuiltinVaList;
4626   }
4627 
4628   virtual void getGCCRegNames(const char *const *&Names,
4629                               unsigned &NumNames) const override;
4630   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4631                                 unsigned &NumAliases) const override;
4632 
4633   virtual bool
4634   validateAsmConstraint(const char *&Name,
4635                         TargetInfo::ConstraintInfo &Info) const override {
4636     switch (*Name) {
4637     default:
4638       return false;
4639     case 'w': // Floating point and SIMD registers (V0-V31)
4640       Info.setAllowsRegister();
4641       return true;
4642     case 'I': // Constant that can be used with an ADD instruction
4643     case 'J': // Constant that can be used with a SUB instruction
4644     case 'K': // Constant that can be used with a 32-bit logical instruction
4645     case 'L': // Constant that can be used with a 64-bit logical instruction
4646     case 'M': // Constant that can be used as a 32-bit MOV immediate
4647     case 'N': // Constant that can be used as a 64-bit MOV immediate
4648     case 'Y': // Floating point constant zero
4649     case 'Z': // Integer constant zero
4650       return true;
4651     case 'Q': // A memory reference with base register and no offset
4652       Info.setAllowsMemory();
4653       return true;
4654     case 'S': // A symbolic address
4655       Info.setAllowsRegister();
4656       return true;
4657     case 'U':
4658       // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
4659       // Utf: A memory address suitable for ldp/stp in TF mode.
4660       // Usa: An absolute symbolic address.
4661       // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
4662       llvm_unreachable("FIXME: Unimplemented support for U* constraints.");
4663     case 'z': // Zero register, wzr or xzr
4664       Info.setAllowsRegister();
4665       return true;
4666     case 'x': // Floating point and SIMD registers (V0-V15)
4667       Info.setAllowsRegister();
4668       return true;
4669     }
4670     return false;
4671   }
4672 
4673   bool
4674   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
4675                              std::string &SuggestedModifier) const override {
4676     // Strip off constraint modifiers.
4677     while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
4678       Constraint = Constraint.substr(1);
4679 
4680     switch (Constraint[0]) {
4681     default:
4682       return true;
4683     case 'z':
4684     case 'r': {
4685       switch (Modifier) {
4686       case 'x':
4687       case 'w':
4688         // For now assume that the person knows what they're
4689         // doing with the modifier.
4690         return true;
4691       default:
4692         // By default an 'r' constraint will be in the 'x'
4693         // registers.
4694         if (Size == 64)
4695           return true;
4696 
4697         SuggestedModifier = "w";
4698         return false;
4699       }
4700     }
4701     }
4702   }
4703 
4704   const char *getClobbers() const override { return ""; }
4705 
4706   int getEHDataRegisterNumber(unsigned RegNo) const override {
4707     if (RegNo == 0)
4708       return 0;
4709     if (RegNo == 1)
4710       return 1;
4711     return -1;
4712   }
4713 };
4714 
4715 const char *const AArch64TargetInfo::GCCRegNames[] = {
4716   // 32-bit Integer registers
4717   "w0",  "w1",  "w2",  "w3",  "w4",  "w5",  "w6",  "w7",  "w8",  "w9",  "w10",
4718   "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
4719   "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
4720 
4721   // 64-bit Integer registers
4722   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",  "x8",  "x9",  "x10",
4723   "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
4724   "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp",  "lr",  "sp",
4725 
4726   // 32-bit floating point regsisters
4727   "s0",  "s1",  "s2",  "s3",  "s4",  "s5",  "s6",  "s7",  "s8",  "s9",  "s10",
4728   "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
4729   "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
4730 
4731   // 64-bit floating point regsisters
4732   "d0",  "d1",  "d2",  "d3",  "d4",  "d5",  "d6",  "d7",  "d8",  "d9",  "d10",
4733   "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
4734   "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
4735 
4736   // Vector registers
4737   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",  "v8",  "v9",  "v10",
4738   "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
4739   "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
4740 };
4741 
4742 void AArch64TargetInfo::getGCCRegNames(const char *const *&Names,
4743                                      unsigned &NumNames) const {
4744   Names = GCCRegNames;
4745   NumNames = llvm::array_lengthof(GCCRegNames);
4746 }
4747 
4748 const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
4749   { { "w31" }, "wsp" },
4750   { { "x29" }, "fp" },
4751   { { "x30" }, "lr" },
4752   { { "x31" }, "sp" },
4753   // The S/D/Q and W/X registers overlap, but aren't really aliases; we
4754   // don't want to substitute one of these for a different-sized one.
4755 };
4756 
4757 void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4758                                        unsigned &NumAliases) const {
4759   Aliases = GCCRegAliases;
4760   NumAliases = llvm::array_lengthof(GCCRegAliases);
4761 }
4762 
4763 const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
4764 #define BUILTIN(ID, TYPE, ATTRS)                                               \
4765   { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4766 #include "clang/Basic/BuiltinsNEON.def"
4767 
4768 #define BUILTIN(ID, TYPE, ATTRS)                                               \
4769   { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4770 #include "clang/Basic/BuiltinsAArch64.def"
4771 };
4772 
4773 class AArch64leTargetInfo : public AArch64TargetInfo {
4774   void setDescriptionString() override {
4775     if (getTriple().isOSBinFormatMachO())
4776       DescriptionString = "e-m:o-i64:64-i128:128-n32:64-S128";
4777     else
4778       DescriptionString = "e-m:e-i64:64-i128:128-n32:64-S128";
4779   }
4780 
4781 public:
4782   AArch64leTargetInfo(const llvm::Triple &Triple)
4783     : AArch64TargetInfo(Triple) {
4784     BigEndian = false;
4785     }
4786   void getTargetDefines(const LangOptions &Opts,
4787                         MacroBuilder &Builder) const override {
4788     Builder.defineMacro("__AARCH64EL__");
4789     AArch64TargetInfo::getTargetDefines(Opts, Builder);
4790   }
4791 };
4792 
4793 class AArch64beTargetInfo : public AArch64TargetInfo {
4794   void setDescriptionString() override {
4795     assert(!getTriple().isOSBinFormatMachO());
4796     DescriptionString = "E-m:e-i64:64-i128:128-n32:64-S128";
4797   }
4798 
4799 public:
4800   AArch64beTargetInfo(const llvm::Triple &Triple)
4801     : AArch64TargetInfo(Triple) { }
4802   void getTargetDefines(const LangOptions &Opts,
4803                         MacroBuilder &Builder) const override {
4804     Builder.defineMacro("__AARCH64EB__");
4805     Builder.defineMacro("__AARCH_BIG_ENDIAN");
4806     Builder.defineMacro("__ARM_BIG_ENDIAN");
4807     AArch64TargetInfo::getTargetDefines(Opts, Builder);
4808   }
4809 };
4810 } // end anonymous namespace.
4811 
4812 namespace {
4813 class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
4814 protected:
4815   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4816                     MacroBuilder &Builder) const override {
4817     Builder.defineMacro("__AARCH64_SIMD__");
4818     Builder.defineMacro("__ARM64_ARCH_8__");
4819     Builder.defineMacro("__ARM_NEON__");
4820     Builder.defineMacro("__LITTLE_ENDIAN__");
4821     Builder.defineMacro("__REGISTER_PREFIX__", "");
4822     Builder.defineMacro("__arm64", "1");
4823     Builder.defineMacro("__arm64__", "1");
4824 
4825     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
4826   }
4827 
4828 public:
4829   DarwinAArch64TargetInfo(const llvm::Triple &Triple)
4830       : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
4831     Int64Type = SignedLongLong;
4832     WCharType = SignedInt;
4833     UseSignedCharForObjCBool = false;
4834 
4835     LongDoubleWidth = LongDoubleAlign = 64;
4836     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4837 
4838     TheCXXABI.set(TargetCXXABI::iOS64);
4839   }
4840 
4841   BuiltinVaListKind getBuiltinVaListKind() const override {
4842     return TargetInfo::CharPtrBuiltinVaList;
4843   }
4844 };
4845 } // end anonymous namespace
4846 
4847 namespace {
4848 // Hexagon abstract base class
4849 class HexagonTargetInfo : public TargetInfo {
4850   static const Builtin::Info BuiltinInfo[];
4851   static const char * const GCCRegNames[];
4852   static const TargetInfo::GCCRegAlias GCCRegAliases[];
4853   std::string CPU;
4854 public:
4855   HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
4856     BigEndian = false;
4857     DescriptionString = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32";
4858 
4859     // {} in inline assembly are packet specifiers, not assembly variant
4860     // specifiers.
4861     NoAsmVariants = true;
4862   }
4863 
4864   void getTargetBuiltins(const Builtin::Info *&Records,
4865                          unsigned &NumRecords) const override {
4866     Records = BuiltinInfo;
4867     NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4868   }
4869 
4870   bool validateAsmConstraint(const char *&Name,
4871                              TargetInfo::ConstraintInfo &Info) const override {
4872     return true;
4873   }
4874 
4875   void getTargetDefines(const LangOptions &Opts,
4876                         MacroBuilder &Builder) const override;
4877 
4878   bool hasFeature(StringRef Feature) const override {
4879     return Feature == "hexagon";
4880   }
4881 
4882   BuiltinVaListKind getBuiltinVaListKind() const override {
4883     return TargetInfo::CharPtrBuiltinVaList;
4884   }
4885   void getGCCRegNames(const char * const *&Names,
4886                       unsigned &NumNames) const override;
4887   void getGCCRegAliases(const GCCRegAlias *&Aliases,
4888                         unsigned &NumAliases) const override;
4889   const char *getClobbers() const override {
4890     return "";
4891   }
4892 
4893   static const char *getHexagonCPUSuffix(StringRef Name) {
4894     return llvm::StringSwitch<const char*>(Name)
4895       .Case("hexagonv4", "4")
4896       .Case("hexagonv5", "5")
4897       .Default(nullptr);
4898   }
4899 
4900   bool setCPU(const std::string &Name) override {
4901     if (!getHexagonCPUSuffix(Name))
4902       return false;
4903 
4904     CPU = Name;
4905     return true;
4906   }
4907 };
4908 
4909 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4910                                 MacroBuilder &Builder) const {
4911   Builder.defineMacro("qdsp6");
4912   Builder.defineMacro("__qdsp6", "1");
4913   Builder.defineMacro("__qdsp6__", "1");
4914 
4915   Builder.defineMacro("hexagon");
4916   Builder.defineMacro("__hexagon", "1");
4917   Builder.defineMacro("__hexagon__", "1");
4918 
4919   if(CPU == "hexagonv1") {
4920     Builder.defineMacro("__HEXAGON_V1__");
4921     Builder.defineMacro("__HEXAGON_ARCH__", "1");
4922     if(Opts.HexagonQdsp6Compat) {
4923       Builder.defineMacro("__QDSP6_V1__");
4924       Builder.defineMacro("__QDSP6_ARCH__", "1");
4925     }
4926   }
4927   else if(CPU == "hexagonv2") {
4928     Builder.defineMacro("__HEXAGON_V2__");
4929     Builder.defineMacro("__HEXAGON_ARCH__", "2");
4930     if(Opts.HexagonQdsp6Compat) {
4931       Builder.defineMacro("__QDSP6_V2__");
4932       Builder.defineMacro("__QDSP6_ARCH__", "2");
4933     }
4934   }
4935   else if(CPU == "hexagonv3") {
4936     Builder.defineMacro("__HEXAGON_V3__");
4937     Builder.defineMacro("__HEXAGON_ARCH__", "3");
4938     if(Opts.HexagonQdsp6Compat) {
4939       Builder.defineMacro("__QDSP6_V3__");
4940       Builder.defineMacro("__QDSP6_ARCH__", "3");
4941     }
4942   }
4943   else if(CPU == "hexagonv4") {
4944     Builder.defineMacro("__HEXAGON_V4__");
4945     Builder.defineMacro("__HEXAGON_ARCH__", "4");
4946     if(Opts.HexagonQdsp6Compat) {
4947       Builder.defineMacro("__QDSP6_V4__");
4948       Builder.defineMacro("__QDSP6_ARCH__", "4");
4949     }
4950   }
4951   else if(CPU == "hexagonv5") {
4952     Builder.defineMacro("__HEXAGON_V5__");
4953     Builder.defineMacro("__HEXAGON_ARCH__", "5");
4954     if(Opts.HexagonQdsp6Compat) {
4955       Builder.defineMacro("__QDSP6_V5__");
4956       Builder.defineMacro("__QDSP6_ARCH__", "5");
4957     }
4958   }
4959 }
4960 
4961 const char * const HexagonTargetInfo::GCCRegNames[] = {
4962   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4963   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4964   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4965   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4966   "p0", "p1", "p2", "p3",
4967   "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4968 };
4969 
4970 void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4971                                    unsigned &NumNames) const {
4972   Names = GCCRegNames;
4973   NumNames = llvm::array_lengthof(GCCRegNames);
4974 }
4975 
4976 
4977 const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4978   { { "sp" }, "r29" },
4979   { { "fp" }, "r30" },
4980   { { "lr" }, "r31" },
4981  };
4982 
4983 void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4984                                      unsigned &NumAliases) const {
4985   Aliases = GCCRegAliases;
4986   NumAliases = llvm::array_lengthof(GCCRegAliases);
4987 }
4988 
4989 
4990 const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4991 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4992 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4993                                               ALL_LANGUAGES },
4994 #include "clang/Basic/BuiltinsHexagon.def"
4995 };
4996 }
4997 
4998 
4999 namespace {
5000 // Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
5001 class SparcTargetInfo : public TargetInfo {
5002   static const TargetInfo::GCCRegAlias GCCRegAliases[];
5003   static const char * const GCCRegNames[];
5004   bool SoftFloat;
5005 public:
5006   SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
5007 
5008   bool handleTargetFeatures(std::vector<std::string> &Features,
5009                             DiagnosticsEngine &Diags) override {
5010     SoftFloat = false;
5011     for (unsigned i = 0, e = Features.size(); i != e; ++i)
5012       if (Features[i] == "+soft-float")
5013         SoftFloat = true;
5014     return true;
5015   }
5016   void getTargetDefines(const LangOptions &Opts,
5017                         MacroBuilder &Builder) const override {
5018     DefineStd(Builder, "sparc", Opts);
5019     Builder.defineMacro("__REGISTER_PREFIX__", "");
5020 
5021     if (SoftFloat)
5022       Builder.defineMacro("SOFT_FLOAT", "1");
5023   }
5024 
5025   bool hasFeature(StringRef Feature) const override {
5026     return llvm::StringSwitch<bool>(Feature)
5027              .Case("softfloat", SoftFloat)
5028              .Case("sparc", true)
5029              .Default(false);
5030   }
5031 
5032   void getTargetBuiltins(const Builtin::Info *&Records,
5033                          unsigned &NumRecords) const override {
5034     // FIXME: Implement!
5035   }
5036   BuiltinVaListKind getBuiltinVaListKind() const override {
5037     return TargetInfo::VoidPtrBuiltinVaList;
5038   }
5039   void getGCCRegNames(const char * const *&Names,
5040                       unsigned &NumNames) const override;
5041   void getGCCRegAliases(const GCCRegAlias *&Aliases,
5042                         unsigned &NumAliases) const override;
5043   bool validateAsmConstraint(const char *&Name,
5044                              TargetInfo::ConstraintInfo &info) const override {
5045     // FIXME: Implement!
5046     return false;
5047   }
5048   const char *getClobbers() const override {
5049     // FIXME: Implement!
5050     return "";
5051   }
5052 };
5053 
5054 const char * const SparcTargetInfo::GCCRegNames[] = {
5055   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5056   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5057   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5058   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
5059 };
5060 
5061 void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
5062                                      unsigned &NumNames) const {
5063   Names = GCCRegNames;
5064   NumNames = llvm::array_lengthof(GCCRegNames);
5065 }
5066 
5067 const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
5068   { { "g0" }, "r0" },
5069   { { "g1" }, "r1" },
5070   { { "g2" }, "r2" },
5071   { { "g3" }, "r3" },
5072   { { "g4" }, "r4" },
5073   { { "g5" }, "r5" },
5074   { { "g6" }, "r6" },
5075   { { "g7" }, "r7" },
5076   { { "o0" }, "r8" },
5077   { { "o1" }, "r9" },
5078   { { "o2" }, "r10" },
5079   { { "o3" }, "r11" },
5080   { { "o4" }, "r12" },
5081   { { "o5" }, "r13" },
5082   { { "o6", "sp" }, "r14" },
5083   { { "o7" }, "r15" },
5084   { { "l0" }, "r16" },
5085   { { "l1" }, "r17" },
5086   { { "l2" }, "r18" },
5087   { { "l3" }, "r19" },
5088   { { "l4" }, "r20" },
5089   { { "l5" }, "r21" },
5090   { { "l6" }, "r22" },
5091   { { "l7" }, "r23" },
5092   { { "i0" }, "r24" },
5093   { { "i1" }, "r25" },
5094   { { "i2" }, "r26" },
5095   { { "i3" }, "r27" },
5096   { { "i4" }, "r28" },
5097   { { "i5" }, "r29" },
5098   { { "i6", "fp" }, "r30" },
5099   { { "i7" }, "r31" },
5100 };
5101 
5102 void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5103                                        unsigned &NumAliases) const {
5104   Aliases = GCCRegAliases;
5105   NumAliases = llvm::array_lengthof(GCCRegAliases);
5106 }
5107 
5108 // SPARC v8 is the 32-bit mode selected by Triple::sparc.
5109 class SparcV8TargetInfo : public SparcTargetInfo {
5110 public:
5111   SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
5112     DescriptionString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64";
5113   }
5114 
5115   void getTargetDefines(const LangOptions &Opts,
5116                         MacroBuilder &Builder) const override {
5117     SparcTargetInfo::getTargetDefines(Opts, Builder);
5118     Builder.defineMacro("__sparcv8");
5119   }
5120 };
5121 
5122 // SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
5123 class SparcV9TargetInfo : public SparcTargetInfo {
5124 public:
5125   SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
5126     // FIXME: Support Sparc quad-precision long double?
5127     DescriptionString = "E-m:e-i64:64-n32:64-S128";
5128     // This is an LP64 platform.
5129     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
5130 
5131     // OpenBSD uses long long for int64_t and intmax_t.
5132     if (getTriple().getOS() == llvm::Triple::OpenBSD)
5133       IntMaxType = SignedLongLong;
5134     else
5135       IntMaxType = SignedLong;
5136     Int64Type = IntMaxType;
5137 
5138     // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
5139     // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
5140     LongDoubleWidth = 128;
5141     LongDoubleAlign = 128;
5142     LongDoubleFormat = &llvm::APFloat::IEEEquad;
5143     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5144   }
5145 
5146   void getTargetDefines(const LangOptions &Opts,
5147                         MacroBuilder &Builder) const override {
5148     SparcTargetInfo::getTargetDefines(Opts, Builder);
5149     Builder.defineMacro("__sparcv9");
5150     Builder.defineMacro("__arch64__");
5151     // Solaris doesn't need these variants, but the BSDs do.
5152     if (getTriple().getOS() != llvm::Triple::Solaris) {
5153       Builder.defineMacro("__sparc64__");
5154       Builder.defineMacro("__sparc_v9__");
5155       Builder.defineMacro("__sparcv9__");
5156     }
5157   }
5158 
5159   bool setCPU(const std::string &Name) override {
5160     bool CPUKnown = llvm::StringSwitch<bool>(Name)
5161       .Case("v9", true)
5162       .Case("ultrasparc", true)
5163       .Case("ultrasparc3", true)
5164       .Case("niagara", true)
5165       .Case("niagara2", true)
5166       .Case("niagara3", true)
5167       .Case("niagara4", true)
5168       .Default(false);
5169 
5170     // No need to store the CPU yet.  There aren't any CPU-specific
5171     // macros to define.
5172     return CPUKnown;
5173   }
5174 };
5175 
5176 } // end anonymous namespace.
5177 
5178 namespace {
5179 class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
5180 public:
5181   SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
5182       : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
5183     SizeType = UnsignedInt;
5184     PtrDiffType = SignedInt;
5185   }
5186 };
5187 } // end anonymous namespace.
5188 
5189 namespace {
5190 class SystemZTargetInfo : public TargetInfo {
5191   static const char *const GCCRegNames[];
5192 
5193 public:
5194   SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5195     TLSSupported = true;
5196     IntWidth = IntAlign = 32;
5197     LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
5198     PointerWidth = PointerAlign = 64;
5199     LongDoubleWidth = 128;
5200     LongDoubleAlign = 64;
5201     LongDoubleFormat = &llvm::APFloat::IEEEquad;
5202     MinGlobalAlign = 16;
5203     DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
5204     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5205   }
5206   void getTargetDefines(const LangOptions &Opts,
5207                         MacroBuilder &Builder) const override {
5208     Builder.defineMacro("__s390__");
5209     Builder.defineMacro("__s390x__");
5210     Builder.defineMacro("__zarch__");
5211     Builder.defineMacro("__LONG_DOUBLE_128__");
5212   }
5213   void getTargetBuiltins(const Builtin::Info *&Records,
5214                          unsigned &NumRecords) const override {
5215     // FIXME: Implement.
5216     Records = nullptr;
5217     NumRecords = 0;
5218   }
5219 
5220   void getGCCRegNames(const char *const *&Names,
5221                       unsigned &NumNames) const override;
5222   void getGCCRegAliases(const GCCRegAlias *&Aliases,
5223                         unsigned &NumAliases) const override {
5224     // No aliases.
5225     Aliases = nullptr;
5226     NumAliases = 0;
5227   }
5228   bool validateAsmConstraint(const char *&Name,
5229                              TargetInfo::ConstraintInfo &info) const override;
5230   const char *getClobbers() const override {
5231     // FIXME: Is this really right?
5232     return "";
5233   }
5234   BuiltinVaListKind getBuiltinVaListKind() const override {
5235     return TargetInfo::SystemZBuiltinVaList;
5236   }
5237   bool setCPU(const std::string &Name) override {
5238     bool CPUKnown = llvm::StringSwitch<bool>(Name)
5239       .Case("z10", true)
5240       .Case("z196", true)
5241       .Case("zEC12", true)
5242       .Default(false);
5243 
5244     // No need to store the CPU yet.  There aren't any CPU-specific
5245     // macros to define.
5246     return CPUKnown;
5247   }
5248 };
5249 
5250 const char *const SystemZTargetInfo::GCCRegNames[] = {
5251   "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
5252   "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
5253   "f0",  "f2",  "f4",  "f6",  "f1",  "f3",  "f5",  "f7",
5254   "f8",  "f10", "f12", "f14", "f9",  "f11", "f13", "f15"
5255 };
5256 
5257 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
5258                                        unsigned &NumNames) const {
5259   Names = GCCRegNames;
5260   NumNames = llvm::array_lengthof(GCCRegNames);
5261 }
5262 
5263 bool SystemZTargetInfo::
5264 validateAsmConstraint(const char *&Name,
5265                       TargetInfo::ConstraintInfo &Info) const {
5266   switch (*Name) {
5267   default:
5268     return false;
5269 
5270   case 'a': // Address register
5271   case 'd': // Data register (equivalent to 'r')
5272   case 'f': // Floating-point register
5273     Info.setAllowsRegister();
5274     return true;
5275 
5276   case 'I': // Unsigned 8-bit constant
5277   case 'J': // Unsigned 12-bit constant
5278   case 'K': // Signed 16-bit constant
5279   case 'L': // Signed 20-bit displacement (on all targets we support)
5280   case 'M': // 0x7fffffff
5281     return true;
5282 
5283   case 'Q': // Memory with base and unsigned 12-bit displacement
5284   case 'R': // Likewise, plus an index
5285   case 'S': // Memory with base and signed 20-bit displacement
5286   case 'T': // Likewise, plus an index
5287     Info.setAllowsMemory();
5288     return true;
5289   }
5290 }
5291 }
5292 
5293 namespace {
5294   class MSP430TargetInfo : public TargetInfo {
5295     static const char * const GCCRegNames[];
5296   public:
5297     MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5298       BigEndian = false;
5299       TLSSupported = false;
5300       IntWidth = 16; IntAlign = 16;
5301       LongWidth = 32; LongLongWidth = 64;
5302       LongAlign = LongLongAlign = 16;
5303       PointerWidth = 16; PointerAlign = 16;
5304       SuitableAlign = 16;
5305       SizeType = UnsignedInt;
5306       IntMaxType = SignedLongLong;
5307       IntPtrType = SignedInt;
5308       PtrDiffType = SignedInt;
5309       SigAtomicType = SignedLong;
5310       DescriptionString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16";
5311     }
5312     void getTargetDefines(const LangOptions &Opts,
5313                           MacroBuilder &Builder) const override {
5314       Builder.defineMacro("MSP430");
5315       Builder.defineMacro("__MSP430__");
5316       // FIXME: defines for different 'flavours' of MCU
5317     }
5318     void getTargetBuiltins(const Builtin::Info *&Records,
5319                            unsigned &NumRecords) const override {
5320       // FIXME: Implement.
5321       Records = nullptr;
5322       NumRecords = 0;
5323     }
5324     bool hasFeature(StringRef Feature) const override {
5325       return Feature == "msp430";
5326     }
5327     void getGCCRegNames(const char * const *&Names,
5328                         unsigned &NumNames) const override;
5329     void getGCCRegAliases(const GCCRegAlias *&Aliases,
5330                           unsigned &NumAliases) const override {
5331       // No aliases.
5332       Aliases = nullptr;
5333       NumAliases = 0;
5334     }
5335     bool
5336     validateAsmConstraint(const char *&Name,
5337                           TargetInfo::ConstraintInfo &info) const override {
5338       // No target constraints for now.
5339       return false;
5340     }
5341     const char *getClobbers() const override {
5342       // FIXME: Is this really right?
5343       return "";
5344     }
5345     BuiltinVaListKind getBuiltinVaListKind() const override {
5346       // FIXME: implement
5347       return TargetInfo::CharPtrBuiltinVaList;
5348    }
5349   };
5350 
5351   const char * const MSP430TargetInfo::GCCRegNames[] = {
5352     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5353     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
5354   };
5355 
5356   void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
5357                                         unsigned &NumNames) const {
5358     Names = GCCRegNames;
5359     NumNames = llvm::array_lengthof(GCCRegNames);
5360   }
5361 }
5362 
5363 namespace {
5364 
5365   // LLVM and Clang cannot be used directly to output native binaries for
5366   // target, but is used to compile C code to llvm bitcode with correct
5367   // type and alignment information.
5368   //
5369   // TCE uses the llvm bitcode as input and uses it for generating customized
5370   // target processor and program binary. TCE co-design environment is
5371   // publicly available in http://tce.cs.tut.fi
5372 
5373   static const unsigned TCEOpenCLAddrSpaceMap[] = {
5374       3, // opencl_global
5375       4, // opencl_local
5376       5, // opencl_constant
5377       0, // cuda_device
5378       0, // cuda_constant
5379       0  // cuda_shared
5380   };
5381 
5382   class TCETargetInfo : public TargetInfo{
5383   public:
5384     TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5385       TLSSupported = false;
5386       IntWidth = 32;
5387       LongWidth = LongLongWidth = 32;
5388       PointerWidth = 32;
5389       IntAlign = 32;
5390       LongAlign = LongLongAlign = 32;
5391       PointerAlign = 32;
5392       SuitableAlign = 32;
5393       SizeType = UnsignedInt;
5394       IntMaxType = SignedLong;
5395       IntPtrType = SignedInt;
5396       PtrDiffType = SignedInt;
5397       FloatWidth = 32;
5398       FloatAlign = 32;
5399       DoubleWidth = 32;
5400       DoubleAlign = 32;
5401       LongDoubleWidth = 32;
5402       LongDoubleAlign = 32;
5403       FloatFormat = &llvm::APFloat::IEEEsingle;
5404       DoubleFormat = &llvm::APFloat::IEEEsingle;
5405       LongDoubleFormat = &llvm::APFloat::IEEEsingle;
5406       DescriptionString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
5407                           "-f64:32-v64:32-v128:32-a:0:32-n32";
5408       AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
5409       UseAddrSpaceMapMangling = true;
5410     }
5411 
5412     void getTargetDefines(const LangOptions &Opts,
5413                           MacroBuilder &Builder) const override {
5414       DefineStd(Builder, "tce", Opts);
5415       Builder.defineMacro("__TCE__");
5416       Builder.defineMacro("__TCE_V1__");
5417     }
5418     bool hasFeature(StringRef Feature) const override {
5419       return Feature == "tce";
5420     }
5421 
5422     void getTargetBuiltins(const Builtin::Info *&Records,
5423                            unsigned &NumRecords) const override {}
5424     const char *getClobbers() const override {
5425       return "";
5426     }
5427     BuiltinVaListKind getBuiltinVaListKind() const override {
5428       return TargetInfo::VoidPtrBuiltinVaList;
5429     }
5430     void getGCCRegNames(const char * const *&Names,
5431                         unsigned &NumNames) const override {}
5432     bool validateAsmConstraint(const char *&Name,
5433                                TargetInfo::ConstraintInfo &info) const override{
5434       return true;
5435     }
5436     void getGCCRegAliases(const GCCRegAlias *&Aliases,
5437                           unsigned &NumAliases) const override {}
5438   };
5439 }
5440 
5441 namespace {
5442 class MipsTargetInfoBase : public TargetInfo {
5443   virtual void setDescriptionString() = 0;
5444 
5445   static const Builtin::Info BuiltinInfo[];
5446   std::string CPU;
5447   bool IsMips16;
5448   bool IsMicromips;
5449   bool IsNan2008;
5450   bool IsSingleFloat;
5451   enum MipsFloatABI {
5452     HardFloat, SoftFloat
5453   } FloatABI;
5454   enum DspRevEnum {
5455     NoDSP, DSP1, DSP2
5456   } DspRev;
5457   bool HasMSA;
5458 
5459 protected:
5460   bool HasFP64;
5461   std::string ABI;
5462 
5463 public:
5464   MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
5465                      const std::string &CPUStr)
5466       : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
5467         IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
5468         DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {}
5469 
5470   bool isNaN2008Default() const {
5471     return CPU == "mips32r6" || CPU == "mips64r6";
5472   }
5473 
5474   bool isFP64Default() const {
5475     return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
5476   }
5477 
5478   StringRef getABI() const override { return ABI; }
5479   bool setCPU(const std::string &Name) override {
5480     bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
5481                     getTriple().getArch() == llvm::Triple::mipsel;
5482     CPU = Name;
5483     return llvm::StringSwitch<bool>(Name)
5484         .Case("mips1", IsMips32)
5485         .Case("mips2", IsMips32)
5486         .Case("mips3", true)
5487         .Case("mips4", true)
5488         .Case("mips5", true)
5489         .Case("mips32", IsMips32)
5490         .Case("mips32r2", IsMips32)
5491         .Case("mips32r6", IsMips32)
5492         .Case("mips64", true)
5493         .Case("mips64r2", true)
5494         .Case("mips64r6", true)
5495         .Case("octeon", true)
5496         .Default(false);
5497   }
5498   const std::string& getCPU() const { return CPU; }
5499   void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
5500     // The backend enables certain ABI's by default according to the
5501     // architecture.
5502     // Disable both possible defaults so that we don't end up with multiple
5503     // ABI's selected and trigger an assertion.
5504     Features["o32"] = false;
5505     Features["n64"] = false;
5506 
5507     Features[ABI] = true;
5508     if (CPU == "octeon")
5509       Features["mips64r2"] = Features["cnmips"] = true;
5510     else
5511       Features[CPU] = true;
5512   }
5513 
5514   void getTargetDefines(const LangOptions &Opts,
5515                         MacroBuilder &Builder) const override {
5516     Builder.defineMacro("__mips__");
5517     Builder.defineMacro("_mips");
5518     if (Opts.GNUMode)
5519       Builder.defineMacro("mips");
5520 
5521     Builder.defineMacro("__REGISTER_PREFIX__", "");
5522 
5523     switch (FloatABI) {
5524     case HardFloat:
5525       Builder.defineMacro("__mips_hard_float", Twine(1));
5526       break;
5527     case SoftFloat:
5528       Builder.defineMacro("__mips_soft_float", Twine(1));
5529       break;
5530     }
5531 
5532     if (IsSingleFloat)
5533       Builder.defineMacro("__mips_single_float", Twine(1));
5534 
5535     Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
5536     Builder.defineMacro("_MIPS_FPSET",
5537                         Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
5538 
5539     if (IsMips16)
5540       Builder.defineMacro("__mips16", Twine(1));
5541 
5542     if (IsMicromips)
5543       Builder.defineMacro("__mips_micromips", Twine(1));
5544 
5545     if (IsNan2008)
5546       Builder.defineMacro("__mips_nan2008", Twine(1));
5547 
5548     switch (DspRev) {
5549     default:
5550       break;
5551     case DSP1:
5552       Builder.defineMacro("__mips_dsp_rev", Twine(1));
5553       Builder.defineMacro("__mips_dsp", Twine(1));
5554       break;
5555     case DSP2:
5556       Builder.defineMacro("__mips_dsp_rev", Twine(2));
5557       Builder.defineMacro("__mips_dspr2", Twine(1));
5558       Builder.defineMacro("__mips_dsp", Twine(1));
5559       break;
5560     }
5561 
5562     if (HasMSA)
5563       Builder.defineMacro("__mips_msa", Twine(1));
5564 
5565     Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
5566     Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
5567     Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
5568 
5569     Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
5570     Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
5571   }
5572 
5573   void getTargetBuiltins(const Builtin::Info *&Records,
5574                          unsigned &NumRecords) const override {
5575     Records = BuiltinInfo;
5576     NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
5577   }
5578   bool hasFeature(StringRef Feature) const override {
5579     return llvm::StringSwitch<bool>(Feature)
5580       .Case("mips", true)
5581       .Case("fp64", HasFP64)
5582       .Default(false);
5583   }
5584   BuiltinVaListKind getBuiltinVaListKind() const override {
5585     return TargetInfo::VoidPtrBuiltinVaList;
5586   }
5587   void getGCCRegNames(const char * const *&Names,
5588                       unsigned &NumNames) const override {
5589     static const char *const GCCRegNames[] = {
5590       // CPU register names
5591       // Must match second column of GCCRegAliases
5592       "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
5593       "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
5594       "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
5595       "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31",
5596       // Floating point register names
5597       "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
5598       "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
5599       "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
5600       "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
5601       // Hi/lo and condition register names
5602       "hi",   "lo",   "",     "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
5603       "$fcc5","$fcc6","$fcc7",
5604       // MSA register names
5605       "$w0",  "$w1",  "$w2",  "$w3",  "$w4",  "$w5",  "$w6",  "$w7",
5606       "$w8",  "$w9",  "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
5607       "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
5608       "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
5609       // MSA control register names
5610       "$msair",      "$msacsr", "$msaaccess", "$msasave", "$msamodify",
5611       "$msarequest", "$msamap", "$msaunmap"
5612     };
5613     Names = GCCRegNames;
5614     NumNames = llvm::array_lengthof(GCCRegNames);
5615   }
5616   void getGCCRegAliases(const GCCRegAlias *&Aliases,
5617                         unsigned &NumAliases) const override = 0;
5618   bool validateAsmConstraint(const char *&Name,
5619                              TargetInfo::ConstraintInfo &Info) const override {
5620     switch (*Name) {
5621     default:
5622       return false;
5623     case 'r': // CPU registers.
5624     case 'd': // Equivalent to "r" unless generating MIPS16 code.
5625     case 'y': // Equivalent to "r", backward compatibility only.
5626     case 'f': // floating-point registers.
5627     case 'c': // $25 for indirect jumps
5628     case 'l': // lo register
5629     case 'x': // hilo register pair
5630       Info.setAllowsRegister();
5631       return true;
5632     case 'R': // An address that can be used in a non-macro load or store
5633       Info.setAllowsMemory();
5634       return true;
5635     }
5636   }
5637 
5638   const char *getClobbers() const override {
5639     // FIXME: Implement!
5640     return "";
5641   }
5642 
5643   bool handleTargetFeatures(std::vector<std::string> &Features,
5644                             DiagnosticsEngine &Diags) override {
5645     IsMips16 = false;
5646     IsMicromips = false;
5647     IsNan2008 = isNaN2008Default();
5648     IsSingleFloat = false;
5649     FloatABI = HardFloat;
5650     DspRev = NoDSP;
5651     HasFP64 = isFP64Default();
5652 
5653     for (std::vector<std::string>::iterator it = Features.begin(),
5654          ie = Features.end(); it != ie; ++it) {
5655       if (*it == "+single-float")
5656         IsSingleFloat = true;
5657       else if (*it == "+soft-float")
5658         FloatABI = SoftFloat;
5659       else if (*it == "+mips16")
5660         IsMips16 = true;
5661       else if (*it == "+micromips")
5662         IsMicromips = true;
5663       else if (*it == "+dsp")
5664         DspRev = std::max(DspRev, DSP1);
5665       else if (*it == "+dspr2")
5666         DspRev = std::max(DspRev, DSP2);
5667       else if (*it == "+msa")
5668         HasMSA = true;
5669       else if (*it == "+fp64")
5670         HasFP64 = true;
5671       else if (*it == "-fp64")
5672         HasFP64 = false;
5673       else if (*it == "+nan2008")
5674         IsNan2008 = true;
5675       else if (*it == "-nan2008")
5676         IsNan2008 = false;
5677     }
5678 
5679     // Remove front-end specific options.
5680     std::vector<std::string>::iterator it =
5681       std::find(Features.begin(), Features.end(), "+soft-float");
5682     if (it != Features.end())
5683       Features.erase(it);
5684 
5685     setDescriptionString();
5686 
5687     return true;
5688   }
5689 
5690   int getEHDataRegisterNumber(unsigned RegNo) const override {
5691     if (RegNo == 0) return 4;
5692     if (RegNo == 1) return 5;
5693     return -1;
5694   }
5695 
5696   bool isCLZForZeroUndef() const override { return false; }
5697 };
5698 
5699 const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
5700 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5701 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5702                                               ALL_LANGUAGES },
5703 #include "clang/Basic/BuiltinsMips.def"
5704 };
5705 
5706 class Mips32TargetInfoBase : public MipsTargetInfoBase {
5707 public:
5708   Mips32TargetInfoBase(const llvm::Triple &Triple)
5709       : MipsTargetInfoBase(Triple, "o32", "mips32r2") {
5710     SizeType = UnsignedInt;
5711     PtrDiffType = SignedInt;
5712     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
5713   }
5714   bool setABI(const std::string &Name) override {
5715     if (Name == "o32" || Name == "eabi") {
5716       ABI = Name;
5717       return true;
5718     }
5719     return false;
5720   }
5721   void getTargetDefines(const LangOptions &Opts,
5722                         MacroBuilder &Builder) const override {
5723     MipsTargetInfoBase::getTargetDefines(Opts, Builder);
5724 
5725     Builder.defineMacro("__mips", "32");
5726     Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
5727 
5728     const std::string& CPUStr = getCPU();
5729     if (CPUStr == "mips32")
5730       Builder.defineMacro("__mips_isa_rev", "1");
5731     else if (CPUStr == "mips32r2")
5732       Builder.defineMacro("__mips_isa_rev", "2");
5733 
5734     if (ABI == "o32") {
5735       Builder.defineMacro("__mips_o32");
5736       Builder.defineMacro("_ABIO32", "1");
5737       Builder.defineMacro("_MIPS_SIM", "_ABIO32");
5738     }
5739     else if (ABI == "eabi")
5740       Builder.defineMacro("__mips_eabi");
5741     else
5742       llvm_unreachable("Invalid ABI for Mips32.");
5743   }
5744   void getGCCRegAliases(const GCCRegAlias *&Aliases,
5745                         unsigned &NumAliases) const override {
5746     static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5747       { { "at" },  "$1" },
5748       { { "v0" },  "$2" },
5749       { { "v1" },  "$3" },
5750       { { "a0" },  "$4" },
5751       { { "a1" },  "$5" },
5752       { { "a2" },  "$6" },
5753       { { "a3" },  "$7" },
5754       { { "t0" },  "$8" },
5755       { { "t1" },  "$9" },
5756       { { "t2" }, "$10" },
5757       { { "t3" }, "$11" },
5758       { { "t4" }, "$12" },
5759       { { "t5" }, "$13" },
5760       { { "t6" }, "$14" },
5761       { { "t7" }, "$15" },
5762       { { "s0" }, "$16" },
5763       { { "s1" }, "$17" },
5764       { { "s2" }, "$18" },
5765       { { "s3" }, "$19" },
5766       { { "s4" }, "$20" },
5767       { { "s5" }, "$21" },
5768       { { "s6" }, "$22" },
5769       { { "s7" }, "$23" },
5770       { { "t8" }, "$24" },
5771       { { "t9" }, "$25" },
5772       { { "k0" }, "$26" },
5773       { { "k1" }, "$27" },
5774       { { "gp" }, "$28" },
5775       { { "sp","$sp" }, "$29" },
5776       { { "fp","$fp" }, "$30" },
5777       { { "ra" }, "$31" }
5778     };
5779     Aliases = GCCRegAliases;
5780     NumAliases = llvm::array_lengthof(GCCRegAliases);
5781   }
5782 };
5783 
5784 class Mips32EBTargetInfo : public Mips32TargetInfoBase {
5785   void setDescriptionString() override {
5786     DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
5787   }
5788 
5789 public:
5790   Mips32EBTargetInfo(const llvm::Triple &Triple)
5791       : Mips32TargetInfoBase(Triple) {
5792   }
5793   void getTargetDefines(const LangOptions &Opts,
5794                         MacroBuilder &Builder) const override {
5795     DefineStd(Builder, "MIPSEB", Opts);
5796     Builder.defineMacro("_MIPSEB");
5797     Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
5798   }
5799 };
5800 
5801 class Mips32ELTargetInfo : public Mips32TargetInfoBase {
5802   void setDescriptionString() override {
5803     DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
5804   }
5805 
5806 public:
5807   Mips32ELTargetInfo(const llvm::Triple &Triple)
5808       : Mips32TargetInfoBase(Triple) {
5809     BigEndian = false;
5810   }
5811   void getTargetDefines(const LangOptions &Opts,
5812                         MacroBuilder &Builder) const override {
5813     DefineStd(Builder, "MIPSEL", Opts);
5814     Builder.defineMacro("_MIPSEL");
5815     Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
5816   }
5817 };
5818 
5819 class Mips64TargetInfoBase : public MipsTargetInfoBase {
5820 public:
5821   Mips64TargetInfoBase(const llvm::Triple &Triple)
5822       : MipsTargetInfoBase(Triple, "n64", "mips64r2") {
5823     LongDoubleWidth = LongDoubleAlign = 128;
5824     LongDoubleFormat = &llvm::APFloat::IEEEquad;
5825     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
5826       LongDoubleWidth = LongDoubleAlign = 64;
5827       LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5828     }
5829     setN64ABITypes();
5830     SuitableAlign = 128;
5831     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5832   }
5833 
5834   void setN64ABITypes() {
5835     LongWidth = LongAlign = 64;
5836     PointerWidth = PointerAlign = 64;
5837     SizeType = UnsignedLong;
5838     PtrDiffType = SignedLong;
5839   }
5840 
5841   void setN32ABITypes() {
5842     LongWidth = LongAlign = 32;
5843     PointerWidth = PointerAlign = 32;
5844     SizeType = UnsignedInt;
5845     PtrDiffType = SignedInt;
5846   }
5847 
5848   bool setABI(const std::string &Name) override {
5849     if (Name == "n32") {
5850       setN32ABITypes();
5851       ABI = Name;
5852       return true;
5853     }
5854     if (Name == "n64") {
5855       setN64ABITypes();
5856       ABI = Name;
5857       return true;
5858     }
5859     return false;
5860   }
5861 
5862   void getTargetDefines(const LangOptions &Opts,
5863                         MacroBuilder &Builder) const override {
5864     MipsTargetInfoBase::getTargetDefines(Opts, Builder);
5865 
5866     Builder.defineMacro("__mips", "64");
5867     Builder.defineMacro("__mips64");
5868     Builder.defineMacro("__mips64__");
5869     Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
5870 
5871     const std::string& CPUStr = getCPU();
5872     if (CPUStr == "mips64")
5873       Builder.defineMacro("__mips_isa_rev", "1");
5874     else if (CPUStr == "mips64r2")
5875       Builder.defineMacro("__mips_isa_rev", "2");
5876 
5877     if (ABI == "n32") {
5878       Builder.defineMacro("__mips_n32");
5879       Builder.defineMacro("_ABIN32", "2");
5880       Builder.defineMacro("_MIPS_SIM", "_ABIN32");
5881     }
5882     else if (ABI == "n64") {
5883       Builder.defineMacro("__mips_n64");
5884       Builder.defineMacro("_ABI64", "3");
5885       Builder.defineMacro("_MIPS_SIM", "_ABI64");
5886     }
5887     else
5888       llvm_unreachable("Invalid ABI for Mips64.");
5889   }
5890   void getGCCRegAliases(const GCCRegAlias *&Aliases,
5891                         unsigned &NumAliases) const override {
5892     static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5893       { { "at" },  "$1" },
5894       { { "v0" },  "$2" },
5895       { { "v1" },  "$3" },
5896       { { "a0" },  "$4" },
5897       { { "a1" },  "$5" },
5898       { { "a2" },  "$6" },
5899       { { "a3" },  "$7" },
5900       { { "a4" },  "$8" },
5901       { { "a5" },  "$9" },
5902       { { "a6" }, "$10" },
5903       { { "a7" }, "$11" },
5904       { { "t0" }, "$12" },
5905       { { "t1" }, "$13" },
5906       { { "t2" }, "$14" },
5907       { { "t3" }, "$15" },
5908       { { "s0" }, "$16" },
5909       { { "s1" }, "$17" },
5910       { { "s2" }, "$18" },
5911       { { "s3" }, "$19" },
5912       { { "s4" }, "$20" },
5913       { { "s5" }, "$21" },
5914       { { "s6" }, "$22" },
5915       { { "s7" }, "$23" },
5916       { { "t8" }, "$24" },
5917       { { "t9" }, "$25" },
5918       { { "k0" }, "$26" },
5919       { { "k1" }, "$27" },
5920       { { "gp" }, "$28" },
5921       { { "sp","$sp" }, "$29" },
5922       { { "fp","$fp" }, "$30" },
5923       { { "ra" }, "$31" }
5924     };
5925     Aliases = GCCRegAliases;
5926     NumAliases = llvm::array_lengthof(GCCRegAliases);
5927   }
5928 
5929   bool hasInt128Type() const override { return true; }
5930 };
5931 
5932 class Mips64EBTargetInfo : public Mips64TargetInfoBase {
5933   void setDescriptionString() override {
5934     if (ABI == "n32")
5935       DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
5936     else
5937       DescriptionString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
5938 
5939   }
5940 
5941 public:
5942   Mips64EBTargetInfo(const llvm::Triple &Triple)
5943       : Mips64TargetInfoBase(Triple) {}
5944   void getTargetDefines(const LangOptions &Opts,
5945                         MacroBuilder &Builder) const override {
5946     DefineStd(Builder, "MIPSEB", Opts);
5947     Builder.defineMacro("_MIPSEB");
5948     Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
5949   }
5950 };
5951 
5952 class Mips64ELTargetInfo : public Mips64TargetInfoBase {
5953   void setDescriptionString() override {
5954     if (ABI == "n32")
5955       DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
5956     else
5957       DescriptionString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
5958   }
5959 public:
5960   Mips64ELTargetInfo(const llvm::Triple &Triple)
5961       : Mips64TargetInfoBase(Triple) {
5962     // Default ABI is n64.
5963     BigEndian = false;
5964   }
5965   void getTargetDefines(const LangOptions &Opts,
5966                         MacroBuilder &Builder) const override {
5967     DefineStd(Builder, "MIPSEL", Opts);
5968     Builder.defineMacro("_MIPSEL");
5969     Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
5970   }
5971 };
5972 } // end anonymous namespace.
5973 
5974 namespace {
5975 class PNaClTargetInfo : public TargetInfo {
5976 public:
5977   PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5978     BigEndian = false;
5979     this->UserLabelPrefix = "";
5980     this->LongAlign = 32;
5981     this->LongWidth = 32;
5982     this->PointerAlign = 32;
5983     this->PointerWidth = 32;
5984     this->IntMaxType = TargetInfo::SignedLongLong;
5985     this->Int64Type = TargetInfo::SignedLongLong;
5986     this->DoubleAlign = 64;
5987     this->LongDoubleWidth = 64;
5988     this->LongDoubleAlign = 64;
5989     this->SizeType = TargetInfo::UnsignedInt;
5990     this->PtrDiffType = TargetInfo::SignedInt;
5991     this->IntPtrType = TargetInfo::SignedInt;
5992     this->RegParmMax = 0; // Disallow regparm
5993   }
5994 
5995   void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
5996   }
5997   void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
5998     Builder.defineMacro("__le32__");
5999     Builder.defineMacro("__pnacl__");
6000   }
6001   void getTargetDefines(const LangOptions &Opts,
6002                         MacroBuilder &Builder) const override {
6003     getArchDefines(Opts, Builder);
6004   }
6005   bool hasFeature(StringRef Feature) const override {
6006     return Feature == "pnacl";
6007   }
6008   void getTargetBuiltins(const Builtin::Info *&Records,
6009                          unsigned &NumRecords) const override {
6010   }
6011   BuiltinVaListKind getBuiltinVaListKind() const override {
6012     return TargetInfo::PNaClABIBuiltinVaList;
6013   }
6014   void getGCCRegNames(const char * const *&Names,
6015                       unsigned &NumNames) const override;
6016   void getGCCRegAliases(const GCCRegAlias *&Aliases,
6017                         unsigned &NumAliases) const override;
6018   bool validateAsmConstraint(const char *&Name,
6019                              TargetInfo::ConstraintInfo &Info) const override {
6020     return false;
6021   }
6022 
6023   const char *getClobbers() const override {
6024     return "";
6025   }
6026 };
6027 
6028 void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
6029                                      unsigned &NumNames) const {
6030   Names = nullptr;
6031   NumNames = 0;
6032 }
6033 
6034 void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
6035                                        unsigned &NumAliases) const {
6036   Aliases = nullptr;
6037   NumAliases = 0;
6038 }
6039 } // end anonymous namespace.
6040 
6041 namespace {
6042 class Le64TargetInfo : public TargetInfo {
6043   static const Builtin::Info BuiltinInfo[];
6044 
6045 public:
6046   Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6047     BigEndian = false;
6048     NoAsmVariants = true;
6049     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6050     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6051     DescriptionString =
6052         "e-S128-p:64:64-v16:16-v32:32-v64:64-v96:32-v128:32-m:e-n8:16:32:64";
6053   }
6054 
6055   void getTargetDefines(const LangOptions &Opts,
6056                         MacroBuilder &Builder) const override {
6057     DefineStd(Builder, "unix", Opts);
6058     defineCPUMacros(Builder, "le64", /*Tuning=*/false);
6059     Builder.defineMacro("__ELF__");
6060   }
6061   void getTargetBuiltins(const Builtin::Info *&Records,
6062                          unsigned &NumRecords) const override {
6063     Records = BuiltinInfo;
6064     NumRecords = clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin;
6065   }
6066   BuiltinVaListKind getBuiltinVaListKind() const override {
6067     return TargetInfo::PNaClABIBuiltinVaList;
6068   }
6069   const char *getClobbers() const override { return ""; }
6070   void getGCCRegNames(const char *const *&Names,
6071                       unsigned &NumNames) const override {
6072     Names = nullptr;
6073     NumNames = 0;
6074   }
6075   void getGCCRegAliases(const GCCRegAlias *&Aliases,
6076                         unsigned &NumAliases) const override {
6077     Aliases = nullptr;
6078     NumAliases = 0;
6079   }
6080   bool validateAsmConstraint(const char *&Name,
6081                              TargetInfo::ConstraintInfo &Info) const override {
6082     return false;
6083   }
6084 
6085   bool hasProtectedVisibility() const override { return false; }
6086 };
6087 } // end anonymous namespace.
6088 
6089 const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
6090 #define BUILTIN(ID, TYPE, ATTRS)                                               \
6091   { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6092 #include "clang/Basic/BuiltinsLe64.def"
6093 };
6094 
6095 namespace {
6096   static const unsigned SPIRAddrSpaceMap[] = {
6097     1,    // opencl_global
6098     3,    // opencl_local
6099     2,    // opencl_constant
6100     0,    // cuda_device
6101     0,    // cuda_constant
6102     0     // cuda_shared
6103   };
6104   class SPIRTargetInfo : public TargetInfo {
6105   public:
6106     SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6107       assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
6108         "SPIR target must use unknown OS");
6109       assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
6110         "SPIR target must use unknown environment type");
6111       BigEndian = false;
6112       TLSSupported = false;
6113       LongWidth = LongAlign = 64;
6114       AddrSpaceMap = &SPIRAddrSpaceMap;
6115       UseAddrSpaceMapMangling = true;
6116       // Define available target features
6117       // These must be defined in sorted order!
6118       NoAsmVariants = true;
6119     }
6120     void getTargetDefines(const LangOptions &Opts,
6121                           MacroBuilder &Builder) const override {
6122       DefineStd(Builder, "SPIR", Opts);
6123     }
6124     bool hasFeature(StringRef Feature) const override {
6125       return Feature == "spir";
6126     }
6127 
6128     void getTargetBuiltins(const Builtin::Info *&Records,
6129                            unsigned &NumRecords) const override {}
6130     const char *getClobbers() const override {
6131       return "";
6132     }
6133     void getGCCRegNames(const char * const *&Names,
6134                         unsigned &NumNames) const override {}
6135     bool
6136     validateAsmConstraint(const char *&Name,
6137                           TargetInfo::ConstraintInfo &info) const override {
6138       return true;
6139     }
6140     void getGCCRegAliases(const GCCRegAlias *&Aliases,
6141                           unsigned &NumAliases) const override {}
6142     BuiltinVaListKind getBuiltinVaListKind() const override {
6143       return TargetInfo::VoidPtrBuiltinVaList;
6144     }
6145   };
6146 
6147 
6148   class SPIR32TargetInfo : public SPIRTargetInfo {
6149   public:
6150     SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
6151       PointerWidth = PointerAlign = 32;
6152       SizeType     = TargetInfo::UnsignedInt;
6153       PtrDiffType = IntPtrType = TargetInfo::SignedInt;
6154       DescriptionString
6155         = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
6156           "v96:128-v192:256-v256:256-v512:512-v1024:1024";
6157     }
6158     void getTargetDefines(const LangOptions &Opts,
6159                           MacroBuilder &Builder) const override {
6160       DefineStd(Builder, "SPIR32", Opts);
6161     }
6162   };
6163 
6164   class SPIR64TargetInfo : public SPIRTargetInfo {
6165   public:
6166     SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
6167       PointerWidth = PointerAlign = 64;
6168       SizeType     = TargetInfo::UnsignedLong;
6169       PtrDiffType = IntPtrType = TargetInfo::SignedLong;
6170       DescriptionString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-"
6171                           "v96:128-v192:256-v256:256-v512:512-v1024:1024";
6172     }
6173     void getTargetDefines(const LangOptions &Opts,
6174                           MacroBuilder &Builder) const override {
6175       DefineStd(Builder, "SPIR64", Opts);
6176     }
6177   };
6178 }
6179 
6180 namespace {
6181 class XCoreTargetInfo : public TargetInfo {
6182   static const Builtin::Info BuiltinInfo[];
6183 public:
6184   XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6185     BigEndian = false;
6186     NoAsmVariants = true;
6187     LongLongAlign = 32;
6188     SuitableAlign = 32;
6189     DoubleAlign = LongDoubleAlign = 32;
6190     SizeType = UnsignedInt;
6191     PtrDiffType = SignedInt;
6192     IntPtrType = SignedInt;
6193     WCharType = UnsignedChar;
6194     WIntType = UnsignedInt;
6195     UseZeroLengthBitfieldAlignment = true;
6196     DescriptionString = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
6197                         "-f64:32-a:0:32-n32";
6198   }
6199   void getTargetDefines(const LangOptions &Opts,
6200                         MacroBuilder &Builder) const override {
6201     Builder.defineMacro("__XS1B__");
6202   }
6203   void getTargetBuiltins(const Builtin::Info *&Records,
6204                          unsigned &NumRecords) const override {
6205     Records = BuiltinInfo;
6206     NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
6207   }
6208   BuiltinVaListKind getBuiltinVaListKind() const override {
6209     return TargetInfo::VoidPtrBuiltinVaList;
6210   }
6211   const char *getClobbers() const override {
6212     return "";
6213   }
6214   void getGCCRegNames(const char * const *&Names,
6215                       unsigned &NumNames) const override {
6216     static const char * const GCCRegNames[] = {
6217       "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
6218       "r8",   "r9",   "r10",  "r11",  "cp",   "dp",   "sp",   "lr"
6219     };
6220     Names = GCCRegNames;
6221     NumNames = llvm::array_lengthof(GCCRegNames);
6222   }
6223   void getGCCRegAliases(const GCCRegAlias *&Aliases,
6224                         unsigned &NumAliases) const override {
6225     Aliases = nullptr;
6226     NumAliases = 0;
6227   }
6228   bool validateAsmConstraint(const char *&Name,
6229                              TargetInfo::ConstraintInfo &Info) const override {
6230     return false;
6231   }
6232   int getEHDataRegisterNumber(unsigned RegNo) const override {
6233     // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
6234     return (RegNo < 2)? RegNo : -1;
6235   }
6236 };
6237 
6238 const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
6239 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6240 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
6241                                               ALL_LANGUAGES },
6242 #include "clang/Basic/BuiltinsXCore.def"
6243 };
6244 } // end anonymous namespace.
6245 
6246 
6247 //===----------------------------------------------------------------------===//
6248 // Driver code
6249 //===----------------------------------------------------------------------===//
6250 
6251 static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
6252   llvm::Triple::OSType os = Triple.getOS();
6253 
6254   switch (Triple.getArch()) {
6255   default:
6256     return nullptr;
6257 
6258   case llvm::Triple::xcore:
6259     return new XCoreTargetInfo(Triple);
6260 
6261   case llvm::Triple::hexagon:
6262     return new HexagonTargetInfo(Triple);
6263 
6264   case llvm::Triple::aarch64:
6265     if (Triple.isOSDarwin())
6266       return new DarwinAArch64TargetInfo(Triple);
6267 
6268     switch (os) {
6269     case llvm::Triple::FreeBSD:
6270       return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple);
6271     case llvm::Triple::Linux:
6272       return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
6273     case llvm::Triple::NetBSD:
6274       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
6275     default:
6276       return new AArch64leTargetInfo(Triple);
6277     }
6278 
6279   case llvm::Triple::aarch64_be:
6280     switch (os) {
6281     case llvm::Triple::FreeBSD:
6282       return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple);
6283     case llvm::Triple::Linux:
6284       return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
6285     case llvm::Triple::NetBSD:
6286       return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
6287     default:
6288       return new AArch64beTargetInfo(Triple);
6289     }
6290 
6291   case llvm::Triple::arm:
6292   case llvm::Triple::thumb:
6293     if (Triple.isOSBinFormatMachO())
6294       return new DarwinARMTargetInfo(Triple);
6295 
6296     switch (os) {
6297     case llvm::Triple::Linux:
6298       return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
6299     case llvm::Triple::FreeBSD:
6300       return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
6301     case llvm::Triple::NetBSD:
6302       return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
6303     case llvm::Triple::OpenBSD:
6304       return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
6305     case llvm::Triple::Bitrig:
6306       return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
6307     case llvm::Triple::RTEMS:
6308       return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
6309     case llvm::Triple::NaCl:
6310       return new NaClTargetInfo<ARMleTargetInfo>(Triple);
6311     case llvm::Triple::Win32:
6312       switch (Triple.getEnvironment()) {
6313       default:
6314         return new ARMleTargetInfo(Triple);
6315       case llvm::Triple::Itanium:
6316         return new ItaniumWindowsARMleTargetInfo(Triple);
6317       case llvm::Triple::MSVC:
6318         return new MicrosoftARMleTargetInfo(Triple);
6319       }
6320     default:
6321       return new ARMleTargetInfo(Triple);
6322     }
6323 
6324   case llvm::Triple::armeb:
6325   case llvm::Triple::thumbeb:
6326     if (Triple.isOSDarwin())
6327       return new DarwinARMTargetInfo(Triple);
6328 
6329     switch (os) {
6330     case llvm::Triple::Linux:
6331       return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
6332     case llvm::Triple::FreeBSD:
6333       return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
6334     case llvm::Triple::NetBSD:
6335       return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
6336     case llvm::Triple::OpenBSD:
6337       return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
6338     case llvm::Triple::Bitrig:
6339       return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
6340     case llvm::Triple::RTEMS:
6341       return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
6342     case llvm::Triple::NaCl:
6343       return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
6344     default:
6345       return new ARMbeTargetInfo(Triple);
6346     }
6347 
6348   case llvm::Triple::msp430:
6349     return new MSP430TargetInfo(Triple);
6350 
6351   case llvm::Triple::mips:
6352     switch (os) {
6353     case llvm::Triple::Linux:
6354       return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
6355     case llvm::Triple::RTEMS:
6356       return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
6357     case llvm::Triple::FreeBSD:
6358       return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
6359     case llvm::Triple::NetBSD:
6360       return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
6361     default:
6362       return new Mips32EBTargetInfo(Triple);
6363     }
6364 
6365   case llvm::Triple::mipsel:
6366     switch (os) {
6367     case llvm::Triple::Linux:
6368       return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
6369     case llvm::Triple::RTEMS:
6370       return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
6371     case llvm::Triple::FreeBSD:
6372       return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
6373     case llvm::Triple::NetBSD:
6374       return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
6375     case llvm::Triple::NaCl:
6376       return new NaClTargetInfo<Mips32ELTargetInfo>(Triple);
6377     default:
6378       return new Mips32ELTargetInfo(Triple);
6379     }
6380 
6381   case llvm::Triple::mips64:
6382     switch (os) {
6383     case llvm::Triple::Linux:
6384       return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
6385     case llvm::Triple::RTEMS:
6386       return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
6387     case llvm::Triple::FreeBSD:
6388       return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
6389     case llvm::Triple::NetBSD:
6390       return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
6391     case llvm::Triple::OpenBSD:
6392       return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
6393     default:
6394       return new Mips64EBTargetInfo(Triple);
6395     }
6396 
6397   case llvm::Triple::mips64el:
6398     switch (os) {
6399     case llvm::Triple::Linux:
6400       return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
6401     case llvm::Triple::RTEMS:
6402       return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
6403     case llvm::Triple::FreeBSD:
6404       return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
6405     case llvm::Triple::NetBSD:
6406       return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
6407     case llvm::Triple::OpenBSD:
6408       return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
6409     default:
6410       return new Mips64ELTargetInfo(Triple);
6411     }
6412 
6413   case llvm::Triple::le32:
6414     switch (os) {
6415       case llvm::Triple::NaCl:
6416         return new NaClTargetInfo<PNaClTargetInfo>(Triple);
6417       default:
6418         return nullptr;
6419     }
6420 
6421   case llvm::Triple::le64:
6422     return new Le64TargetInfo(Triple);
6423 
6424   case llvm::Triple::ppc:
6425     if (Triple.isOSDarwin())
6426       return new DarwinPPC32TargetInfo(Triple);
6427     switch (os) {
6428     case llvm::Triple::Linux:
6429       return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
6430     case llvm::Triple::FreeBSD:
6431       return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
6432     case llvm::Triple::NetBSD:
6433       return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
6434     case llvm::Triple::OpenBSD:
6435       return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
6436     case llvm::Triple::RTEMS:
6437       return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
6438     default:
6439       return new PPC32TargetInfo(Triple);
6440     }
6441 
6442   case llvm::Triple::ppc64:
6443     if (Triple.isOSDarwin())
6444       return new DarwinPPC64TargetInfo(Triple);
6445     switch (os) {
6446     case llvm::Triple::Linux:
6447       return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
6448     case llvm::Triple::Lv2:
6449       return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
6450     case llvm::Triple::FreeBSD:
6451       return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
6452     case llvm::Triple::NetBSD:
6453       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
6454     default:
6455       return new PPC64TargetInfo(Triple);
6456     }
6457 
6458   case llvm::Triple::ppc64le:
6459     switch (os) {
6460     case llvm::Triple::Linux:
6461       return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
6462     default:
6463       return new PPC64TargetInfo(Triple);
6464     }
6465 
6466   case llvm::Triple::nvptx:
6467     return new NVPTX32TargetInfo(Triple);
6468   case llvm::Triple::nvptx64:
6469     return new NVPTX64TargetInfo(Triple);
6470 
6471   case llvm::Triple::r600:
6472     return new R600TargetInfo(Triple);
6473 
6474   case llvm::Triple::sparc:
6475     switch (os) {
6476     case llvm::Triple::Linux:
6477       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
6478     case llvm::Triple::Solaris:
6479       return new SolarisSparcV8TargetInfo(Triple);
6480     case llvm::Triple::NetBSD:
6481       return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
6482     case llvm::Triple::OpenBSD:
6483       return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
6484     case llvm::Triple::RTEMS:
6485       return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
6486     default:
6487       return new SparcV8TargetInfo(Triple);
6488     }
6489 
6490   case llvm::Triple::sparcv9:
6491     switch (os) {
6492     case llvm::Triple::Linux:
6493       return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
6494     case llvm::Triple::Solaris:
6495       return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
6496     case llvm::Triple::NetBSD:
6497       return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
6498     case llvm::Triple::OpenBSD:
6499       return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
6500     case llvm::Triple::FreeBSD:
6501       return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
6502     default:
6503       return new SparcV9TargetInfo(Triple);
6504     }
6505 
6506   case llvm::Triple::systemz:
6507     switch (os) {
6508     case llvm::Triple::Linux:
6509       return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
6510     default:
6511       return new SystemZTargetInfo(Triple);
6512     }
6513 
6514   case llvm::Triple::tce:
6515     return new TCETargetInfo(Triple);
6516 
6517   case llvm::Triple::x86:
6518     if (Triple.isOSDarwin())
6519       return new DarwinI386TargetInfo(Triple);
6520 
6521     switch (os) {
6522     case llvm::Triple::Linux:
6523       return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
6524     case llvm::Triple::DragonFly:
6525       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
6526     case llvm::Triple::NetBSD:
6527       return new NetBSDI386TargetInfo(Triple);
6528     case llvm::Triple::OpenBSD:
6529       return new OpenBSDI386TargetInfo(Triple);
6530     case llvm::Triple::Bitrig:
6531       return new BitrigI386TargetInfo(Triple);
6532     case llvm::Triple::FreeBSD:
6533       return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
6534     case llvm::Triple::KFreeBSD:
6535       return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
6536     case llvm::Triple::Minix:
6537       return new MinixTargetInfo<X86_32TargetInfo>(Triple);
6538     case llvm::Triple::Solaris:
6539       return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
6540     case llvm::Triple::Win32: {
6541       switch (Triple.getEnvironment()) {
6542       default:
6543         return new X86_32TargetInfo(Triple);
6544       case llvm::Triple::Cygnus:
6545         return new CygwinX86_32TargetInfo(Triple);
6546       case llvm::Triple::GNU:
6547         return new MinGWX86_32TargetInfo(Triple);
6548       case llvm::Triple::Itanium:
6549       case llvm::Triple::MSVC:
6550         return new MicrosoftX86_32TargetInfo(Triple);
6551       }
6552     }
6553     case llvm::Triple::Haiku:
6554       return new HaikuX86_32TargetInfo(Triple);
6555     case llvm::Triple::RTEMS:
6556       return new RTEMSX86_32TargetInfo(Triple);
6557     case llvm::Triple::NaCl:
6558       return new NaClTargetInfo<X86_32TargetInfo>(Triple);
6559     default:
6560       return new X86_32TargetInfo(Triple);
6561     }
6562 
6563   case llvm::Triple::x86_64:
6564     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
6565       return new DarwinX86_64TargetInfo(Triple);
6566 
6567     switch (os) {
6568     case llvm::Triple::Linux:
6569       return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
6570     case llvm::Triple::DragonFly:
6571       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
6572     case llvm::Triple::NetBSD:
6573       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
6574     case llvm::Triple::OpenBSD:
6575       return new OpenBSDX86_64TargetInfo(Triple);
6576     case llvm::Triple::Bitrig:
6577       return new BitrigX86_64TargetInfo(Triple);
6578     case llvm::Triple::FreeBSD:
6579       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
6580     case llvm::Triple::KFreeBSD:
6581       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
6582     case llvm::Triple::Solaris:
6583       return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
6584     case llvm::Triple::Win32: {
6585       switch (Triple.getEnvironment()) {
6586       default:
6587         return new X86_64TargetInfo(Triple);
6588       case llvm::Triple::GNU:
6589         return new MinGWX86_64TargetInfo(Triple);
6590       case llvm::Triple::MSVC:
6591         return new MicrosoftX86_64TargetInfo(Triple);
6592       }
6593     }
6594     case llvm::Triple::NaCl:
6595       return new NaClTargetInfo<X86_64TargetInfo>(Triple);
6596     default:
6597       return new X86_64TargetInfo(Triple);
6598     }
6599 
6600     case llvm::Triple::spir: {
6601       if (Triple.getOS() != llvm::Triple::UnknownOS ||
6602           Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
6603         return nullptr;
6604       return new SPIR32TargetInfo(Triple);
6605     }
6606     case llvm::Triple::spir64: {
6607       if (Triple.getOS() != llvm::Triple::UnknownOS ||
6608           Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
6609         return nullptr;
6610       return new SPIR64TargetInfo(Triple);
6611     }
6612   }
6613 }
6614 
6615 /// CreateTargetInfo - Return the target info object for the specified target
6616 /// triple.
6617 TargetInfo *
6618 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
6619                              const std::shared_ptr<TargetOptions> &Opts) {
6620   llvm::Triple Triple(Opts->Triple);
6621 
6622   // Construct the target
6623   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple));
6624   if (!Target) {
6625     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
6626     return nullptr;
6627   }
6628   Target->TargetOpts = Opts;
6629 
6630   // Set the target CPU if specified.
6631   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
6632     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
6633     return nullptr;
6634   }
6635 
6636   // Set the target ABI if specified.
6637   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
6638     Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
6639     return nullptr;
6640   }
6641 
6642   // Set the fp math unit.
6643   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
6644     Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
6645     return nullptr;
6646   }
6647 
6648   // Compute the default target features, we need the target to handle this
6649   // because features may have dependencies on one another.
6650   llvm::StringMap<bool> Features;
6651   Target->getDefaultFeatures(Features);
6652 
6653   // Apply the user specified deltas.
6654   for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
6655        I < N; ++I) {
6656     const char *Name = Opts->FeaturesAsWritten[I].c_str();
6657     // Apply the feature via the target.
6658     bool Enabled = Name[0] == '+';
6659     Target->setFeatureEnabled(Features, Name + 1, Enabled);
6660   }
6661 
6662   // Add the features to the compile options.
6663   //
6664   // FIXME: If we are completely confident that we have the right set, we only
6665   // need to pass the minuses.
6666   Opts->Features.clear();
6667   for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
6668          ie = Features.end(); it != ie; ++it)
6669     Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
6670   if (!Target->handleTargetFeatures(Opts->Features, Diags))
6671     return nullptr;
6672 
6673   return Target.release();
6674 }
6675