contrib/llvm/tools/clang/lib/Basic/Targets.cpp

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