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

   1 //===--- Targets.cpp - Implement target feature support -------------------===//
   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/Builtins.h"
  16 #include "clang/Basic/Cuda.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/TargetInfo.h"
  22 #include "clang/Basic/TargetOptions.h"
  23 #include "clang/Basic/Version.h"
  24 #include "clang/Frontend/CodeGenOptions.h"
  25 #include "llvm/ADT/APFloat.h"
  26 #include "llvm/ADT/STLExtras.h"
  27 #include "llvm/ADT/StringExtras.h"
  28 #include "llvm/ADT/StringRef.h"
  29 #include "llvm/ADT/StringSwitch.h"
  30 #include "llvm/ADT/Triple.h"
  31 #include "llvm/MC/MCSectionMachO.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/TargetParser.h"
  34 #include <algorithm>
  35 #include <memory>
  36
  37 using namespace clang;
  38
  39 //===----------------------------------------------------------------------===//
  40 //  Common code shared among targets.
  41 //===----------------------------------------------------------------------===//
  42
  43 /// DefineStd - Define a macro name and standard variants.  For example if
  44 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
  45 /// when in GNU mode.
  46 static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
  47                       const LangOptions &Opts) {
  48   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
  49
  50   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
  51   // in the user's namespace.
  52   if (Opts.GNUMode)
  53     Builder.defineMacro(MacroName);
  54
  55   // Define __unix.
  56   Builder.defineMacro("__" + MacroName);
  57
  58   // Define __unix__.
  59   Builder.defineMacro("__" + MacroName + "__");
  60 }
  61
  62 static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
  63                             bool Tuning = true) {
  64   Builder.defineMacro("__" + CPUName);
  65   Builder.defineMacro("__" + CPUName + "__");
  66   if (Tuning)
  67     Builder.defineMacro("__tune_" + CPUName + "__");
  68 }
  69
  70 static TargetInfo *AllocateTarget(const llvm::Triple &Triple,
  71                                   const TargetOptions &Opts);
  72
  73 //===----------------------------------------------------------------------===//
  74 // Defines specific to certain operating systems.
  75 //===----------------------------------------------------------------------===//
  76
  77 namespace {
  78 template<typename TgtInfo>
  79 class OSTargetInfo : public TgtInfo {
  80 protected:
  81   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
  82                             MacroBuilder &Builder) const=0;
  83 public:
  84   OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
  85       : TgtInfo(Triple, Opts) {}
  86   void getTargetDefines(const LangOptions &Opts,
  87                         MacroBuilder &Builder) const override {
  88     TgtInfo::getTargetDefines(Opts, Builder);
  89     getOSDefines(Opts, TgtInfo::getTriple(), Builder);
  90   }
  91
  92 };
  93
  94 // CloudABI Target
  95 template <typename Target>
  96 class CloudABITargetInfo : public OSTargetInfo<Target> {
  97 protected:
  98   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
  99                     MacroBuilder &Builder) const override {
 100     Builder.defineMacro("__CloudABI__");
 101     Builder.defineMacro("__ELF__");
 102
 103     // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
 104     Builder.defineMacro("__STDC_ISO_10646__", "201206L");
 105     Builder.defineMacro("__STDC_UTF_16__");
 106     Builder.defineMacro("__STDC_UTF_32__");
 107   }
 108
 109 public:
 110   CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 111       : OSTargetInfo<Target>(Triple, Opts) {}
 112 };
 113
 114 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
 115                              const llvm::Triple &Triple,
 116                              StringRef &PlatformName,
 117                              VersionTuple &PlatformMinVersion) {
 118   Builder.defineMacro("__APPLE_CC__", "6000");
 119   Builder.defineMacro("__APPLE__");
 120   Builder.defineMacro("OBJC_NEW_PROPERTIES");
 121   // AddressSanitizer doesn't play well with source fortification, which is on
 122   // by default on Darwin.
 123   if (Opts.Sanitize.has(SanitizerKind::Address))
 124     Builder.defineMacro("_FORTIFY_SOURCE", "0");
 125
 126   // Darwin defines __weak, __strong, and __unsafe_unretained even in C mode.
 127   if (!Opts.ObjC1) {
 128     // __weak is always defined, for use in blocks and with objc pointers.
 129     Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
 130     Builder.defineMacro("__strong", "");
 131     Builder.defineMacro("__unsafe_unretained", "");
 132   }
 133
 134   if (Opts.Static)
 135     Builder.defineMacro("__STATIC__");
 136   else
 137     Builder.defineMacro("__DYNAMIC__");
 138
 139   if (Opts.POSIXThreads)
 140     Builder.defineMacro("_REENTRANT");
 141
 142   // Get the platform type and version number from the triple.
 143   unsigned Maj, Min, Rev;
 144   if (Triple.isMacOSX()) {
 145     Triple.getMacOSXVersion(Maj, Min, Rev);
 146     PlatformName = "macos";
 147   } else {
 148     Triple.getOSVersion(Maj, Min, Rev);
 149     PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
 150   }
 151
 152   // If -target arch-pc-win32-macho option specified, we're
 153   // generating code for Win32 ABI. No need to emit
 154   // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
 155   if (PlatformName == "win32") {
 156     PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 157     return;
 158   }
 159
 160   // Set the appropriate OS version define.
 161   if (Triple.isiOS()) {
 162     assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
 163     char Str[7];
 164     if (Maj < 10) {
 165       Str[0] = '0' + Maj;
 166       Str[1] = '0' + (Min / 10);
 167       Str[2] = '0' + (Min % 10);
 168       Str[3] = '0' + (Rev / 10);
 169       Str[4] = '0' + (Rev % 10);
 170       Str[5] = '\0';
 171     } else {
 172       // Handle versions >= 10.
 173       Str[0] = '0' + (Maj / 10);
 174       Str[1] = '0' + (Maj % 10);
 175       Str[2] = '0' + (Min / 10);
 176       Str[3] = '0' + (Min % 10);
 177       Str[4] = '0' + (Rev / 10);
 178       Str[5] = '0' + (Rev % 10);
 179       Str[6] = '\0';
 180     }
 181     if (Triple.isTvOS())
 182       Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str);
 183     else
 184       Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
 185                           Str);
 186
 187   } else if (Triple.isWatchOS()) {
 188     assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
 189     char Str[6];
 190     Str[0] = '0' + Maj;
 191     Str[1] = '0' + (Min / 10);
 192     Str[2] = '0' + (Min % 10);
 193     Str[3] = '0' + (Rev / 10);
 194     Str[4] = '0' + (Rev % 10);
 195     Str[5] = '\0';
 196     Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
 197   } else if (Triple.isMacOSX()) {
 198     // Note that the Driver allows versions which aren't representable in the
 199     // define (because we only get a single digit for the minor and micro
 200     // revision numbers). So, we limit them to the maximum representable
 201     // version.
 202     assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
 203     char Str[7];
 204     if (Maj < 10 || (Maj == 10 && Min < 10)) {
 205       Str[0] = '0' + (Maj / 10);
 206       Str[1] = '0' + (Maj % 10);
 207       Str[2] = '0' + std::min(Min, 9U);
 208       Str[3] = '0' + std::min(Rev, 9U);
 209       Str[4] = '\0';
 210     } else {
 211       // Handle versions > 10.9.
 212       Str[0] = '0' + (Maj / 10);
 213       Str[1] = '0' + (Maj % 10);
 214       Str[2] = '0' + (Min / 10);
 215       Str[3] = '0' + (Min % 10);
 216       Str[4] = '0' + (Rev / 10);
 217       Str[5] = '0' + (Rev % 10);
 218       Str[6] = '\0';
 219     }
 220     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
 221   }
 222
 223   // Tell users about the kernel if there is one.
 224   if (Triple.isOSDarwin())
 225     Builder.defineMacro("__MACH__");
 226
 227   // The Watch ABI uses Dwarf EH.
 228   if(Triple.isWatchABI())
 229     Builder.defineMacro("__ARM_DWARF_EH__");
 230
 231   PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 232 }
 233
 234 template<typename Target>
 235 class DarwinTargetInfo : public OSTargetInfo<Target> {
 236 protected:
 237   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 238                     MacroBuilder &Builder) const override {
 239     getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
 240                      this->PlatformMinVersion);
 241   }
 242
 243 public:
 244   DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 245       : OSTargetInfo<Target>(Triple, Opts) {
 246     // By default, no TLS, and we whitelist permitted architecture/OS
 247     // combinations.
 248     this->TLSSupported = false;
 249
 250     if (Triple.isMacOSX())
 251       this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
 252     else if (Triple.isiOS()) {
 253       // 64-bit iOS supported it from 8 onwards, 32-bit from 9 onwards.
 254       if (Triple.getArch() == llvm::Triple::x86_64 ||
 255           Triple.getArch() == llvm::Triple::aarch64)
 256         this->TLSSupported = !Triple.isOSVersionLT(8);
 257       else if (Triple.getArch() == llvm::Triple::x86 ||
 258                Triple.getArch() == llvm::Triple::arm ||
 259                Triple.getArch() == llvm::Triple::thumb)
 260         this->TLSSupported = !Triple.isOSVersionLT(9);
 261     } else if (Triple.isWatchOS())
 262       this->TLSSupported = !Triple.isOSVersionLT(2);
 263
 264     this->MCountName = "\01mcount";
 265   }
 266
 267   std::string isValidSectionSpecifier(StringRef SR) const override {
 268     // Let MCSectionMachO validate this.
 269     StringRef Segment, Section;
 270     unsigned TAA, StubSize;
 271     bool HasTAA;
 272     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
 273                                                        TAA, HasTAA, StubSize);
 274   }
 275
 276   const char *getStaticInitSectionSpecifier() const override {
 277     // FIXME: We should return 0 when building kexts.
 278     return "__TEXT,__StaticInit,regular,pure_instructions";
 279   }
 280
 281   /// Darwin does not support protected visibility.  Darwin's "default"
 282   /// is very similar to ELF's "protected";  Darwin requires a "weak"
 283   /// attribute on declarations that can be dynamically replaced.
 284   bool hasProtectedVisibility() const override {
 285     return false;
 286   }
 287
 288   unsigned getExnObjectAlignment() const override {
 289     // The alignment of an exception object is 8-bytes for darwin since
 290     // libc++abi doesn't declare _Unwind_Exception with __attribute__((aligned))
 291     // and therefore doesn't guarantee 16-byte alignment.
 292     return  64;
 293   }
 294 };
 295
 296
 297 // DragonFlyBSD Target
 298 template<typename Target>
 299 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
 300 protected:
 301   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 302                     MacroBuilder &Builder) const override {
 303     // DragonFly defines; list based off of gcc output
 304     Builder.defineMacro("__DragonFly__");
 305     Builder.defineMacro("__DragonFly_cc_version", "100001");
 306     Builder.defineMacro("__ELF__");
 307     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 308     Builder.defineMacro("__tune_i386__");
 309     DefineStd(Builder, "unix", Opts);
 310   }
 311 public:
 312   DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 313       : OSTargetInfo<Target>(Triple, Opts) {
 314     switch (Triple.getArch()) {
 315     default:
 316     case llvm::Triple::x86:
 317     case llvm::Triple::x86_64:
 318       this->MCountName = ".mcount";
 319       break;
 320     }
 321   }
 322 };
 323
 324 #ifndef FREEBSD_CC_VERSION
 325 #define FREEBSD_CC_VERSION 0U
 326 #endif
 327
 328 // FreeBSD Target
 329 template<typename Target>
 330 class FreeBSDTargetInfo : public OSTargetInfo<Target> {
 331 protected:
 332   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 333                     MacroBuilder &Builder) const override {
 334     // FreeBSD defines; list based off of gcc output
 335
 336     unsigned Release = Triple.getOSMajorVersion();
 337     if (Release == 0U)
 338       Release = 8U;
 339     unsigned CCVersion = FREEBSD_CC_VERSION;
 340     if (CCVersion == 0U)
 341       CCVersion = Release * 100000U + 1U;
 342
 343     Builder.defineMacro("__FreeBSD__", Twine(Release));
 344     Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
 345     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 346     DefineStd(Builder, "unix", Opts);
 347     Builder.defineMacro("__ELF__");
 348
 349     // On FreeBSD, wchar_t contains the number of the code point as
 350     // used by the character set of the locale. These character sets are
 351     // not necessarily a superset of ASCII.
 352     //
 353     // FIXME: This is wrong; the macro refers to the numerical values
 354     // of wchar_t *literals*, which are not locale-dependent. However,
 355     // FreeBSD systems apparently depend on us getting this wrong, and
 356     // setting this to 1 is conforming even if all the basic source
 357     // character literals have the same encoding as char and wchar_t.
 358     Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
 359   }
 360 public:
 361   FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 362       : OSTargetInfo<Target>(Triple, Opts) {
 363     switch (Triple.getArch()) {
 364     default:
 365     case llvm::Triple::x86:
 366     case llvm::Triple::x86_64:
 367       this->MCountName = ".mcount";
 368       break;
 369     case llvm::Triple::mips:
 370     case llvm::Triple::mipsel:
 371     case llvm::Triple::ppc:
 372     case llvm::Triple::ppc64:
 373     case llvm::Triple::ppc64le:
 374       this->MCountName = "_mcount";
 375       break;
 376     case llvm::Triple::arm:
 377       this->MCountName = "__mcount";
 378       break;
 379     }
 380   }
 381 };
 382
 383 // GNU/kFreeBSD Target
 384 template<typename Target>
 385 class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
 386 protected:
 387   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 388                     MacroBuilder &Builder) const override {
 389     // GNU/kFreeBSD defines; list based off of gcc output
 390
 391     DefineStd(Builder, "unix", Opts);
 392     Builder.defineMacro("__FreeBSD_kernel__");
 393     Builder.defineMacro("__GLIBC__");
 394     Builder.defineMacro("__ELF__");
 395     if (Opts.POSIXThreads)
 396       Builder.defineMacro("_REENTRANT");
 397     if (Opts.CPlusPlus)
 398       Builder.defineMacro("_GNU_SOURCE");
 399   }
 400 public:
 401   KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 402       : OSTargetInfo<Target>(Triple, Opts) {}
 403 };
 404
 405 // Haiku Target
 406 template<typename Target>
 407 class HaikuTargetInfo : public OSTargetInfo<Target> {
 408 protected:
 409   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 410                     MacroBuilder &Builder) const override {
 411     // Haiku defines; list based off of gcc output
 412     Builder.defineMacro("__HAIKU__");
 413     Builder.defineMacro("__ELF__");
 414     DefineStd(Builder, "unix", Opts);
 415   }
 416 public:
 417   HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 418       : OSTargetInfo<Target>(Triple, Opts) {
 419     this->SizeType = TargetInfo::UnsignedLong;
 420     this->IntPtrType = TargetInfo::SignedLong;
 421     this->PtrDiffType = TargetInfo::SignedLong;
 422     this->ProcessIDType = TargetInfo::SignedLong;
 423     this->TLSSupported = false;
 424
 425   }
 426 };
 427
 428 // Minix Target
 429 template<typename Target>
 430 class MinixTargetInfo : public OSTargetInfo<Target> {
 431 protected:
 432   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 433                     MacroBuilder &Builder) const override {
 434     // Minix defines
 435
 436     Builder.defineMacro("__minix", "3");
 437     Builder.defineMacro("_EM_WSIZE", "4");
 438     Builder.defineMacro("_EM_PSIZE", "4");
 439     Builder.defineMacro("_EM_SSIZE", "2");
 440     Builder.defineMacro("_EM_LSIZE", "4");
 441     Builder.defineMacro("_EM_FSIZE", "4");
 442     Builder.defineMacro("_EM_DSIZE", "8");
 443     Builder.defineMacro("__ELF__");
 444     DefineStd(Builder, "unix", Opts);
 445   }
 446 public:
 447   MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 448       : OSTargetInfo<Target>(Triple, Opts) {}
 449 };
 450
 451 // Linux target
 452 template<typename Target>
 453 class LinuxTargetInfo : public OSTargetInfo<Target> {
 454 protected:
 455   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 456                     MacroBuilder &Builder) const override {
 457     // Linux defines; list based off of gcc output
 458     DefineStd(Builder, "unix", Opts);
 459     DefineStd(Builder, "linux", Opts);
 460     Builder.defineMacro("__gnu_linux__");
 461     Builder.defineMacro("__ELF__");
 462     if (Triple.isAndroid()) {
 463       Builder.defineMacro("__ANDROID__", "1");
 464       unsigned Maj, Min, Rev;
 465       Triple.getEnvironmentVersion(Maj, Min, Rev);
 466       this->PlatformName = "android";
 467       this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 468       if (Maj)
 469         Builder.defineMacro("__ANDROID_API__", Twine(Maj));
 470     }
 471     if (Opts.POSIXThreads)
 472       Builder.defineMacro("_REENTRANT");
 473     if (Opts.CPlusPlus)
 474       Builder.defineMacro("_GNU_SOURCE");
 475     if (this->HasFloat128)
 476       Builder.defineMacro("__FLOAT128__");
 477   }
 478 public:
 479   LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 480       : OSTargetInfo<Target>(Triple, Opts) {
 481     this->WIntType = TargetInfo::UnsignedInt;
 482
 483     switch (Triple.getArch()) {
 484     default:
 485       break;
 486     case llvm::Triple::ppc:
 487     case llvm::Triple::ppc64:
 488     case llvm::Triple::ppc64le:
 489       this->MCountName = "_mcount";
 490       break;
 491     case llvm::Triple::x86:
 492     case llvm::Triple::x86_64:
 493     case llvm::Triple::systemz:
 494       this->HasFloat128 = true;
 495       break;
 496     }
 497   }
 498
 499   const char *getStaticInitSectionSpecifier() const override {
 500     return ".text.startup";
 501   }
 502 };
 503
 504 // NetBSD Target
 505 template<typename Target>
 506 class NetBSDTargetInfo : public OSTargetInfo<Target> {
 507 protected:
 508   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 509                     MacroBuilder &Builder) const override {
 510     // NetBSD defines; list based off of gcc output
 511     Builder.defineMacro("__NetBSD__");
 512     Builder.defineMacro("__unix__");
 513     Builder.defineMacro("__ELF__");
 514     if (Opts.POSIXThreads)
 515       Builder.defineMacro("_REENTRANT");
 516
 517     switch (Triple.getArch()) {
 518     default:
 519       break;
 520     case llvm::Triple::arm:
 521     case llvm::Triple::armeb:
 522     case llvm::Triple::thumb:
 523     case llvm::Triple::thumbeb:
 524       Builder.defineMacro("__ARM_DWARF_EH__");
 525       break;
 526     }
 527   }
 528 public:
 529   NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 530       : OSTargetInfo<Target>(Triple, Opts) {
 531     this->MCountName = "_mcount";
 532   }
 533 };
 534
 535 // OpenBSD Target
 536 template<typename Target>
 537 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 538 protected:
 539   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 540                     MacroBuilder &Builder) const override {
 541     // OpenBSD defines; list based off of gcc output
 542
 543     Builder.defineMacro("__OpenBSD__");
 544     DefineStd(Builder, "unix", Opts);
 545     Builder.defineMacro("__ELF__");
 546     if (Opts.POSIXThreads)
 547       Builder.defineMacro("_REENTRANT");
 548   }
 549 public:
 550   OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 551       : OSTargetInfo<Target>(Triple, Opts) {
 552     this->TLSSupported = false;
 553
 554       switch (Triple.getArch()) {
 555         default:
 556         case llvm::Triple::x86:
 557         case llvm::Triple::x86_64:
 558         case llvm::Triple::arm:
 559         case llvm::Triple::sparc:
 560           this->MCountName = "__mcount";
 561           break;
 562         case llvm::Triple::mips64:
 563         case llvm::Triple::mips64el:
 564         case llvm::Triple::ppc:
 565         case llvm::Triple::sparcv9:
 566           this->MCountName = "_mcount";
 567           break;
 568       }
 569   }
 570 };
 571
 572 // Bitrig Target
 573 template<typename Target>
 574 class BitrigTargetInfo : public OSTargetInfo<Target> {
 575 protected:
 576   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 577                     MacroBuilder &Builder) const override {
 578     // Bitrig defines; list based off of gcc output
 579
 580     Builder.defineMacro("__Bitrig__");
 581     DefineStd(Builder, "unix", Opts);
 582     Builder.defineMacro("__ELF__");
 583     if (Opts.POSIXThreads)
 584       Builder.defineMacro("_REENTRANT");
 585
 586     switch (Triple.getArch()) {
 587     default:
 588       break;
 589     case llvm::Triple::arm:
 590     case llvm::Triple::armeb:
 591     case llvm::Triple::thumb:
 592     case llvm::Triple::thumbeb:
 593       Builder.defineMacro("__ARM_DWARF_EH__");
 594       break;
 595     }
 596   }
 597 public:
 598   BitrigTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 599       : OSTargetInfo<Target>(Triple, Opts) {
 600     this->MCountName = "__mcount";
 601   }
 602 };
 603
 604 // PSP Target
 605 template<typename Target>
 606 class PSPTargetInfo : public OSTargetInfo<Target> {
 607 protected:
 608   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 609                     MacroBuilder &Builder) const override {
 610     // PSP defines; list based on the output of the pspdev gcc toolchain.
 611     Builder.defineMacro("PSP");
 612     Builder.defineMacro("_PSP");
 613     Builder.defineMacro("__psp__");
 614     Builder.defineMacro("__ELF__");
 615   }
 616 public:
 617   PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
 618 };
 619
 620 // PS3 PPU Target
 621 template<typename Target>
 622 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
 623 protected:
 624   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 625                     MacroBuilder &Builder) const override {
 626     // PS3 PPU defines.
 627     Builder.defineMacro("__PPC__");
 628     Builder.defineMacro("__PPU__");
 629     Builder.defineMacro("__CELLOS_LV2__");
 630     Builder.defineMacro("__ELF__");
 631     Builder.defineMacro("__LP32__");
 632     Builder.defineMacro("_ARCH_PPC64");
 633     Builder.defineMacro("__powerpc64__");
 634   }
 635 public:
 636   PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 637       : OSTargetInfo<Target>(Triple, Opts) {
 638     this->LongWidth = this->LongAlign = 32;
 639     this->PointerWidth = this->PointerAlign = 32;
 640     this->IntMaxType = TargetInfo::SignedLongLong;
 641     this->Int64Type = TargetInfo::SignedLongLong;
 642     this->SizeType = TargetInfo::UnsignedInt;
 643     this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
 644   }
 645 };
 646
 647 template <typename Target>
 648 class PS4OSTargetInfo : public OSTargetInfo<Target> {
 649 protected:
 650   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 651                     MacroBuilder &Builder) const override {
 652     Builder.defineMacro("__FreeBSD__", "9");
 653     Builder.defineMacro("__FreeBSD_cc_version", "900001");
 654     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 655     DefineStd(Builder, "unix", Opts);
 656     Builder.defineMacro("__ELF__");
 657     Builder.defineMacro("__ORBIS__");
 658   }
 659 public:
 660   PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 661       : OSTargetInfo<Target>(Triple, Opts) {
 662     this->WCharType = this->UnsignedShort;
 663
 664     // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
 665     this->MaxTLSAlign = 256;
 666
 667     // On PS4, do not honor explicit bit field alignment,
 668     // as in "__attribute__((aligned(2))) int b : 1;".
 669     this->UseExplicitBitFieldAlignment = false;
 670
 671     switch (Triple.getArch()) {
 672     default:
 673     case llvm::Triple::x86_64:
 674       this->MCountName = ".mcount";
 675       break;
 676     }
 677   }
 678 };
 679
 680 // Solaris target
 681 template<typename Target>
 682 class SolarisTargetInfo : public OSTargetInfo<Target> {
 683 protected:
 684   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 685                     MacroBuilder &Builder) const override {
 686     DefineStd(Builder, "sun", Opts);
 687     DefineStd(Builder, "unix", Opts);
 688     Builder.defineMacro("__ELF__");
 689     Builder.defineMacro("__svr4__");
 690     Builder.defineMacro("__SVR4");
 691     // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
 692     // newer, but to 500 for everything else.  feature_test.h has a check to
 693     // ensure that you are not using C99 with an old version of X/Open or C89
 694     // with a new version.
 695     if (Opts.C99)
 696       Builder.defineMacro("_XOPEN_SOURCE", "600");
 697     else
 698       Builder.defineMacro("_XOPEN_SOURCE", "500");
 699     if (Opts.CPlusPlus)
 700       Builder.defineMacro("__C99FEATURES__");
 701     Builder.defineMacro("_LARGEFILE_SOURCE");
 702     Builder.defineMacro("_LARGEFILE64_SOURCE");
 703     Builder.defineMacro("__EXTENSIONS__");
 704     Builder.defineMacro("_REENTRANT");
 705   }
 706 public:
 707   SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 708       : OSTargetInfo<Target>(Triple, Opts) {
 709     this->WCharType = this->SignedInt;
 710     // FIXME: WIntType should be SignedLong
 711   }
 712 };
 713
 714 // Windows target
 715 template<typename Target>
 716 class WindowsTargetInfo : public OSTargetInfo<Target> {
 717 protected:
 718   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 719                     MacroBuilder &Builder) const override {
 720     Builder.defineMacro("_WIN32");
 721   }
 722   void getVisualStudioDefines(const LangOptions &Opts,
 723                               MacroBuilder &Builder) const {
 724     if (Opts.CPlusPlus) {
 725       if (Opts.RTTIData)
 726         Builder.defineMacro("_CPPRTTI");
 727
 728       if (Opts.CXXExceptions)
 729         Builder.defineMacro("_CPPUNWIND");
 730     }
 731
 732     if (Opts.Bool)
 733       Builder.defineMacro("__BOOL_DEFINED");
 734
 735     if (!Opts.CharIsSigned)
 736       Builder.defineMacro("_CHAR_UNSIGNED");
 737
 738     // FIXME: POSIXThreads isn't exactly the option this should be defined for,
 739     //        but it works for now.
 740     if (Opts.POSIXThreads)
 741       Builder.defineMacro("_MT");
 742
 743     if (Opts.MSCompatibilityVersion) {
 744       Builder.defineMacro("_MSC_VER",
 745                           Twine(Opts.MSCompatibilityVersion / 100000));
 746       Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
 747       // FIXME We cannot encode the revision information into 32-bits
 748       Builder.defineMacro("_MSC_BUILD", Twine(1));
 749
 750       if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
 751         Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
 752
 753       if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
 754         if (Opts.CPlusPlus1z)
 755           Builder.defineMacro("_MSVC_LANG", "201403L");
 756         else if (Opts.CPlusPlus14)
 757           Builder.defineMacro("_MSVC_LANG", "201402L");
 758       }
 759     }
 760
 761     if (Opts.MicrosoftExt) {
 762       Builder.defineMacro("_MSC_EXTENSIONS");
 763
 764       if (Opts.CPlusPlus11) {
 765         Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
 766         Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
 767         Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
 768       }
 769     }
 770
 771     Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
 772   }
 773
 774 public:
 775   WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 776       : OSTargetInfo<Target>(Triple, Opts) {}
 777 };
 778
 779 template <typename Target>
 780 class NaClTargetInfo : public OSTargetInfo<Target> {
 781 protected:
 782   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 783                     MacroBuilder &Builder) const override {
 784     if (Opts.POSIXThreads)
 785       Builder.defineMacro("_REENTRANT");
 786     if (Opts.CPlusPlus)
 787       Builder.defineMacro("_GNU_SOURCE");
 788
 789     DefineStd(Builder, "unix", Opts);
 790     Builder.defineMacro("__ELF__");
 791     Builder.defineMacro("__native_client__");
 792   }
 793
 794 public:
 795   NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
 796       : OSTargetInfo<Target>(Triple, Opts) {
 797     this->LongAlign = 32;
 798     this->LongWidth = 32;
 799     this->PointerAlign = 32;
 800     this->PointerWidth = 32;
 801     this->IntMaxType = TargetInfo::SignedLongLong;
 802     this->Int64Type = TargetInfo::SignedLongLong;
 803     this->DoubleAlign = 64;
 804     this->LongDoubleWidth = 64;
 805     this->LongDoubleAlign = 64;
 806     this->LongLongWidth = 64;
 807     this->LongLongAlign = 64;
 808     this->SizeType = TargetInfo::UnsignedInt;
 809     this->PtrDiffType = TargetInfo::SignedInt;
 810     this->IntPtrType = TargetInfo::SignedInt;
 811     // RegParmMax is inherited from the underlying architecture.
 812     this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
 813     if (Triple.getArch() == llvm::Triple::arm) {
 814       // Handled in ARM's setABI().
 815     } else if (Triple.getArch() == llvm::Triple::x86) {
 816       this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
 817     } else if (Triple.getArch() == llvm::Triple::x86_64) {
 818       this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
 819     } else if (Triple.getArch() == llvm::Triple::mipsel) {
 820       // Handled on mips' setDataLayout.
 821     } else {
 822       assert(Triple.getArch() == llvm::Triple::le32);
 823       this->resetDataLayout("e-p:32:32-i64:64");
 824     }
 825   }
 826 };
 827
 828 // Fuchsia Target
 829 template<typename Target>
 830 class FuchsiaTargetInfo : public OSTargetInfo<Target> {
 831 protected:
 832   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 833                     MacroBuilder &Builder) const override {
 834     Builder.defineMacro("__Fuchsia__");
 835     Builder.defineMacro("__ELF__");
 836     if (Opts.POSIXThreads)
 837       Builder.defineMacro("_REENTRANT");
 838     // Required by the libc++ locale support.
 839     if (Opts.CPlusPlus)
 840       Builder.defineMacro("_GNU_SOURCE");
 841   }
 842 public:
 843   FuchsiaTargetInfo(const llvm::Triple &Triple,
 844                     const TargetOptions &Opts)
 845       : OSTargetInfo<Target>(Triple, Opts) {
 846     this->MCountName = "__mcount";
 847   }
 848 };
 849
 850 // WebAssembly target
 851 template <typename Target>
 852 class WebAssemblyOSTargetInfo : public OSTargetInfo<Target> {
 853   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 854                     MacroBuilder &Builder) const final {
 855     // A common platform macro.
 856     if (Opts.POSIXThreads)
 857       Builder.defineMacro("_REENTRANT");
 858     // Follow g++ convention and predefine _GNU_SOURCE for C++.
 859     if (Opts.CPlusPlus)
 860       Builder.defineMacro("_GNU_SOURCE");
 861   }
 862
 863   // As an optimization, group static init code together in a section.
 864   const char *getStaticInitSectionSpecifier() const final {
 865     return ".text.__startup";
 866   }
 867
 868 public:
 869   explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
 870                                    const TargetOptions &Opts)
 871       : OSTargetInfo<Target>(Triple, Opts) {
 872     this->MCountName = "__mcount";
 873     this->TheCXXABI.set(TargetCXXABI::WebAssembly);
 874   }
 875 };
 876
 877 //===----------------------------------------------------------------------===//
 878 // Specific target implementations.
 879 //===----------------------------------------------------------------------===//
 880
 881 // PPC abstract base class
 882 class PPCTargetInfo : public TargetInfo {
 883   static const Builtin::Info BuiltinInfo[];
 884   static const char * const GCCRegNames[];
 885   static const TargetInfo::GCCRegAlias GCCRegAliases[];
 886   std::string CPU;
 887
 888   // Target cpu features.
 889   bool HasVSX;
 890   bool HasP8Vector;
 891   bool HasP8Crypto;
 892   bool HasDirectMove;
 893   bool HasQPX;
 894   bool HasHTM;
 895   bool HasBPERMD;
 896   bool HasExtDiv;
 897   bool HasP9Vector;
 898
 899 protected:
 900   std::string ABI;
 901
 902 public:
 903   PPCTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
 904     : TargetInfo(Triple), HasVSX(false), HasP8Vector(false),
 905       HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false),
 906       HasBPERMD(false), HasExtDiv(false), HasP9Vector(false) {
 907     SimdDefaultAlign = 128;
 908     LongDoubleWidth = LongDoubleAlign = 128;
 909     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
 910   }
 911
 912   /// \brief Flags for architecture specific defines.
 913   typedef enum {
 914     ArchDefineNone  = 0,
 915     ArchDefineName  = 1 << 0, // <name> is substituted for arch name.
 916     ArchDefinePpcgr = 1 << 1,
 917     ArchDefinePpcsq = 1 << 2,
 918     ArchDefine440   = 1 << 3,
 919     ArchDefine603   = 1 << 4,
 920     ArchDefine604   = 1 << 5,
 921     ArchDefinePwr4  = 1 << 6,
 922     ArchDefinePwr5  = 1 << 7,
 923     ArchDefinePwr5x = 1 << 8,
 924     ArchDefinePwr6  = 1 << 9,
 925     ArchDefinePwr6x = 1 << 10,
 926     ArchDefinePwr7  = 1 << 11,
 927     ArchDefinePwr8  = 1 << 12,
 928     ArchDefinePwr9  = 1 << 13,
 929     ArchDefineA2    = 1 << 14,
 930     ArchDefineA2q   = 1 << 15
 931   } ArchDefineTypes;
 932
 933   // Note: GCC recognizes the following additional cpus:
 934   //  401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
 935   //  821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
 936   //  titan, rs64.
 937   bool setCPU(const std::string &Name) override {
 938     bool CPUKnown = llvm::StringSwitch<bool>(Name)
 939       .Case("generic", true)
 940       .Case("440", true)
 941       .Case("450", true)
 942       .Case("601", true)
 943       .Case("602", true)
 944       .Case("603", true)
 945       .Case("603e", true)
 946       .Case("603ev", true)
 947       .Case("604", true)
 948       .Case("604e", true)
 949       .Case("620", true)
 950       .Case("630", true)
 951       .Case("g3", true)
 952       .Case("7400", true)
 953       .Case("g4", true)
 954       .Case("7450", true)
 955       .Case("g4+", true)
 956       .Case("750", true)
 957       .Case("970", true)
 958       .Case("g5", true)
 959       .Case("a2", true)
 960       .Case("a2q", true)
 961       .Case("e500mc", true)
 962       .Case("e5500", true)
 963       .Case("power3", true)
 964       .Case("pwr3", true)
 965       .Case("power4", true)
 966       .Case("pwr4", true)
 967       .Case("power5", true)
 968       .Case("pwr5", true)
 969       .Case("power5x", true)
 970       .Case("pwr5x", true)
 971       .Case("power6", true)
 972       .Case("pwr6", true)
 973       .Case("power6x", true)
 974       .Case("pwr6x", true)
 975       .Case("power7", true)
 976       .Case("pwr7", true)
 977       .Case("power8", true)
 978       .Case("pwr8", true)
 979       .Case("power9", true)
 980       .Case("pwr9", true)
 981       .Case("powerpc", true)
 982       .Case("ppc", true)
 983       .Case("powerpc64", true)
 984       .Case("ppc64", true)
 985       .Case("powerpc64le", true)
 986       .Case("ppc64le", true)
 987       .Default(false);
 988
 989     if (CPUKnown)
 990       CPU = Name;
 991
 992     return CPUKnown;
 993   }
 994
 995
 996   StringRef getABI() const override { return ABI; }
 997
 998   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
 999     return llvm::makeArrayRef(BuiltinInfo,
1000                              clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin);
1001   }
1002
1003   bool isCLZForZeroUndef() const override { return false; }
1004
1005   void getTargetDefines(const LangOptions &Opts,
1006                         MacroBuilder &Builder) const override;
1007
1008   bool
1009   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
1010                  StringRef CPU,
1011                  const std::vector<std::string> &FeaturesVec) const override;
1012
1013   bool handleTargetFeatures(std::vector<std::string> &Features,
1014                             DiagnosticsEngine &Diags) override;
1015   bool hasFeature(StringRef Feature) const override;
1016   void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
1017                          bool Enabled) const override;
1018
1019   ArrayRef<const char *> getGCCRegNames() const override;
1020   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
1021   bool validateAsmConstraint(const char *&Name,
1022                              TargetInfo::ConstraintInfo &Info) const override {
1023     switch (*Name) {
1024     default: return false;
1025     case 'O': // Zero
1026       break;
1027     case 'b': // Base register
1028     case 'f': // Floating point register
1029       Info.setAllowsRegister();
1030       break;
1031     // FIXME: The following are added to allow parsing.
1032     // I just took a guess at what the actions should be.
1033     // Also, is more specific checking needed?  I.e. specific registers?
1034     case 'd': // Floating point register (containing 64-bit value)
1035     case 'v': // Altivec vector register
1036       Info.setAllowsRegister();
1037       break;
1038     case 'w':
1039       switch (Name[1]) {
1040         case 'd':// VSX vector register to hold vector double data
1041         case 'f':// VSX vector register to hold vector float data
1042         case 's':// VSX vector register to hold scalar float data
1043         case 'a':// Any VSX register
1044         case 'c':// An individual CR bit
1045           break;
1046         default:
1047           return false;
1048       }
1049       Info.setAllowsRegister();
1050       Name++; // Skip over 'w'.
1051       break;
1052     case 'h': // `MQ', `CTR', or `LINK' register
1053     case 'q': // `MQ' register
1054     case 'c': // `CTR' register
1055     case 'l': // `LINK' register
1056     case 'x': // `CR' register (condition register) number 0
1057     case 'y': // `CR' register (condition register)
1058     case 'z': // `XER[CA]' carry bit (part of the XER register)
1059       Info.setAllowsRegister();
1060       break;
1061     case 'I': // Signed 16-bit constant
1062     case 'J': // Unsigned 16-bit constant shifted left 16 bits
1063               //  (use `L' instead for SImode constants)
1064     case 'K': // Unsigned 16-bit constant
1065     case 'L': // Signed 16-bit constant shifted left 16 bits
1066     case 'M': // Constant larger than 31
1067     case 'N': // Exact power of 2
1068     case 'P': // Constant whose negation is a signed 16-bit constant
1069     case 'G': // Floating point constant that can be loaded into a
1070               // register with one instruction per word
1071     case 'H': // Integer/Floating point constant that can be loaded
1072               // into a register using three instructions
1073       break;
1074     case 'm': // Memory operand. Note that on PowerPC targets, m can
1075               // include addresses that update the base register. It
1076               // is therefore only safe to use `m' in an asm statement
1077               // if that asm statement accesses the operand exactly once.
1078               // The asm statement must also use `%U<opno>' as a
1079               // placeholder for the "update" flag in the corresponding
1080               // load or store instruction. For example:
1081               // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
1082               // is correct but:
1083               // asm ("st %1,%0" : "=m" (mem) : "r" (val));
1084               // is not. Use es rather than m if you don't want the base
1085               // register to be updated.
1086     case 'e':
1087       if (Name[1] != 's')
1088           return false;
1089               // es: A "stable" memory operand; that is, one which does not
1090               // include any automodification of the base register. Unlike
1091               // `m', this constraint can be used in asm statements that
1092               // might access the operand several times, or that might not
1093               // access it at all.
1094       Info.setAllowsMemory();
1095       Name++; // Skip over 'e'.
1096       break;
1097     case 'Q': // Memory operand that is an offset from a register (it is
1098               // usually better to use `m' or `es' in asm statements)
1099     case 'Z': // Memory operand that is an indexed or indirect from a
1100               // register (it is usually better to use `m' or `es' in
1101               // asm statements)
1102       Info.setAllowsMemory();
1103       Info.setAllowsRegister();
1104       break;
1105     case 'R': // AIX TOC entry
1106     case 'a': // Address operand that is an indexed or indirect from a
1107               // register (`p' is preferable for asm statements)
1108     case 'S': // Constant suitable as a 64-bit mask operand
1109     case 'T': // Constant suitable as a 32-bit mask operand
1110     case 'U': // System V Release 4 small data area reference
1111     case 't': // AND masks that can be performed by two rldic{l, r}
1112               // instructions
1113     case 'W': // Vector constant that does not require memory
1114     case 'j': // Vector constant that is all zeros.
1115       break;
1116     // End FIXME.
1117     }
1118     return true;
1119   }
1120   std::string convertConstraint(const char *&Constraint) const override {
1121     std::string R;
1122     switch (*Constraint) {
1123     case 'e':
1124     case 'w':
1125       // Two-character constraint; add "^" hint for later parsing.
1126       R = std::string("^") + std::string(Constraint, 2);
1127       Constraint++;
1128       break;
1129     default:
1130       return TargetInfo::convertConstraint(Constraint);
1131     }
1132     return R;
1133   }
1134   const char *getClobbers() const override {
1135     return "";
1136   }
1137   int getEHDataRegisterNumber(unsigned RegNo) const override {
1138     if (RegNo == 0) return 3;
1139     if (RegNo == 1) return 4;
1140     return -1;
1141   }
1142
1143   bool hasSjLjLowering() const override {
1144     return true;
1145   }
1146
1147   bool useFloat128ManglingForLongDouble() const override {
1148     return LongDoubleWidth == 128 &&
1149            LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble() &&
1150            getTriple().isOSBinFormatELF();
1151   }
1152 };
1153
1154 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
1155 #define BUILTIN(ID, TYPE, ATTRS) \
1156   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1157 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1158   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
1159 #include "clang/Basic/BuiltinsPPC.def"
1160 };
1161
1162 /// handleTargetFeatures - Perform initialization based on the user
1163 /// configured set of features.
1164 bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
1165                                          DiagnosticsEngine &Diags) {
1166   for (const auto &Feature : Features) {
1167     if (Feature == "+vsx") {
1168       HasVSX = true;
1169     } else if (Feature == "+bpermd") {
1170       HasBPERMD = true;
1171     } else if (Feature == "+extdiv") {
1172       HasExtDiv = true;
1173     } else if (Feature == "+power8-vector") {
1174       HasP8Vector = true;
1175     } else if (Feature == "+crypto") {
1176       HasP8Crypto = true;
1177     } else if (Feature == "+direct-move") {
1178       HasDirectMove = true;
1179     } else if (Feature == "+qpx") {
1180       HasQPX = true;
1181     } else if (Feature == "+htm") {
1182       HasHTM = true;
1183     } else if (Feature == "+float128") {
1184       HasFloat128 = true;
1185     } else if (Feature == "+power9-vector") {
1186       HasP9Vector = true;
1187     }
1188     // TODO: Finish this list and add an assert that we've handled them
1189     // all.
1190   }
1191
1192   return true;
1193 }
1194
1195 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
1196 /// #defines that are not tied to a specific subtarget.
1197 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
1198                                      MacroBuilder &Builder) const {
1199   // Target identification.
1200   Builder.defineMacro("__ppc__");
1201   Builder.defineMacro("__PPC__");
1202   Builder.defineMacro("_ARCH_PPC");
1203   Builder.defineMacro("__powerpc__");
1204   Builder.defineMacro("__POWERPC__");
1205   if (PointerWidth == 64) {
1206     Builder.defineMacro("_ARCH_PPC64");
1207     Builder.defineMacro("__powerpc64__");
1208     Builder.defineMacro("__ppc64__");
1209     Builder.defineMacro("__PPC64__");
1210   }
1211
1212   // Target properties.
1213   if (getTriple().getArch() == llvm::Triple::ppc64le) {
1214     Builder.defineMacro("_LITTLE_ENDIAN");
1215   } else {
1216     if (getTriple().getOS() != llvm::Triple::NetBSD &&
1217         getTriple().getOS() != llvm::Triple::OpenBSD)
1218       Builder.defineMacro("_BIG_ENDIAN");
1219   }
1220
1221   // ABI options.
1222   if (ABI == "elfv1" || ABI == "elfv1-qpx")
1223     Builder.defineMacro("_CALL_ELF", "1");
1224   if (ABI == "elfv2")
1225     Builder.defineMacro("_CALL_ELF", "2");
1226
1227   // Subtarget options.
1228   Builder.defineMacro("__NATURAL_ALIGNMENT__");
1229   Builder.defineMacro("__REGISTER_PREFIX__", "");
1230
1231   // FIXME: Should be controlled by command line option.
1232   if (LongDoubleWidth == 128)
1233     Builder.defineMacro("__LONG_DOUBLE_128__");
1234
1235   if (Opts.AltiVec) {
1236     Builder.defineMacro("__VEC__", "10206");
1237     Builder.defineMacro("__ALTIVEC__");
1238   }
1239
1240   // CPU identification.
1241   ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1242     .Case("440",   ArchDefineName)
1243     .Case("450",   ArchDefineName | ArchDefine440)
1244     .Case("601",   ArchDefineName)
1245     .Case("602",   ArchDefineName | ArchDefinePpcgr)
1246     .Case("603",   ArchDefineName | ArchDefinePpcgr)
1247     .Case("603e",  ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1248     .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1249     .Case("604",   ArchDefineName | ArchDefinePpcgr)
1250     .Case("604e",  ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1251     .Case("620",   ArchDefineName | ArchDefinePpcgr)
1252     .Case("630",   ArchDefineName | ArchDefinePpcgr)
1253     .Case("7400",  ArchDefineName | ArchDefinePpcgr)
1254     .Case("7450",  ArchDefineName | ArchDefinePpcgr)
1255     .Case("750",   ArchDefineName | ArchDefinePpcgr)
1256     .Case("970",   ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1257                      | ArchDefinePpcsq)
1258     .Case("a2",    ArchDefineA2)
1259     .Case("a2q",   ArchDefineName | ArchDefineA2 | ArchDefineA2q)
1260     .Case("pwr3",  ArchDefinePpcgr)
1261     .Case("pwr4",  ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1262     .Case("pwr5",  ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1263                      | ArchDefinePpcsq)
1264     .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1265                      | ArchDefinePpcgr | ArchDefinePpcsq)
1266     .Case("pwr6",  ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1267                      | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1268     .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1269                      | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1270                      | ArchDefinePpcsq)
1271     .Case("pwr7",  ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1272                      | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1273                      | ArchDefinePpcgr | ArchDefinePpcsq)
1274     .Case("pwr8",  ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1275                      | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1276                      | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1277     .Case("pwr9",  ArchDefineName | ArchDefinePwr8 | ArchDefinePwr7
1278                      | ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1279                      | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1280                      | ArchDefinePpcsq)
1281     .Case("power3",  ArchDefinePpcgr)
1282     .Case("power4",  ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1283     .Case("power5",  ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1284                        | ArchDefinePpcsq)
1285     .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1286                        | ArchDefinePpcgr | ArchDefinePpcsq)
1287     .Case("power6",  ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1288                        | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1289     .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1290                        | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1291                        | ArchDefinePpcsq)
1292     .Case("power7",  ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1293                        | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1294                        | ArchDefinePpcgr | ArchDefinePpcsq)
1295     .Case("power8",  ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1296                        | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1297                        | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1298     .Case("power9",  ArchDefinePwr9 | ArchDefinePwr8 | ArchDefinePwr7
1299                        | ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1300                        | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1301                        | ArchDefinePpcsq)
1302     .Default(ArchDefineNone);
1303
1304   if (defs & ArchDefineName)
1305     Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1306   if (defs & ArchDefinePpcgr)
1307     Builder.defineMacro("_ARCH_PPCGR");
1308   if (defs & ArchDefinePpcsq)
1309     Builder.defineMacro("_ARCH_PPCSQ");
1310   if (defs & ArchDefine440)
1311     Builder.defineMacro("_ARCH_440");
1312   if (defs & ArchDefine603)
1313     Builder.defineMacro("_ARCH_603");
1314   if (defs & ArchDefine604)
1315     Builder.defineMacro("_ARCH_604");
1316   if (defs & ArchDefinePwr4)
1317     Builder.defineMacro("_ARCH_PWR4");
1318   if (defs & ArchDefinePwr5)
1319     Builder.defineMacro("_ARCH_PWR5");
1320   if (defs & ArchDefinePwr5x)
1321     Builder.defineMacro("_ARCH_PWR5X");
1322   if (defs & ArchDefinePwr6)
1323     Builder.defineMacro("_ARCH_PWR6");
1324   if (defs & ArchDefinePwr6x)
1325     Builder.defineMacro("_ARCH_PWR6X");
1326   if (defs & ArchDefinePwr7)
1327     Builder.defineMacro("_ARCH_PWR7");
1328   if (defs & ArchDefinePwr8)
1329     Builder.defineMacro("_ARCH_PWR8");
1330   if (defs & ArchDefinePwr9)
1331     Builder.defineMacro("_ARCH_PWR9");
1332   if (defs & ArchDefineA2)
1333     Builder.defineMacro("_ARCH_A2");
1334   if (defs & ArchDefineA2q) {
1335     Builder.defineMacro("_ARCH_A2Q");
1336     Builder.defineMacro("_ARCH_QP");
1337   }
1338
1339   if (getTriple().getVendor() == llvm::Triple::BGQ) {
1340     Builder.defineMacro("__bg__");
1341     Builder.defineMacro("__THW_BLUEGENE__");
1342     Builder.defineMacro("__bgq__");
1343     Builder.defineMacro("__TOS_BGQ__");
1344   }
1345
1346   if (HasVSX)
1347     Builder.defineMacro("__VSX__");
1348   if (HasP8Vector)
1349     Builder.defineMacro("__POWER8_VECTOR__");
1350   if (HasP8Crypto)
1351     Builder.defineMacro("__CRYPTO__");
1352   if (HasHTM)
1353     Builder.defineMacro("__HTM__");
1354   if (HasFloat128)
1355     Builder.defineMacro("__FLOAT128__");
1356   if (HasP9Vector)
1357     Builder.defineMacro("__POWER9_VECTOR__");
1358
1359   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
1360   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
1361   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
1362   if (PointerWidth == 64)
1363     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
1364
1365   // FIXME: The following are not yet generated here by Clang, but are
1366   //        generated by GCC:
1367   //
1368   //   _SOFT_FLOAT_
1369   //   __RECIP_PRECISION__
1370   //   __APPLE_ALTIVEC__
1371   //   __RECIP__
1372   //   __RECIPF__
1373   //   __RSQRTE__
1374   //   __RSQRTEF__
1375   //   _SOFT_DOUBLE_
1376   //   __NO_LWSYNC__
1377   //   __HAVE_BSWAP__
1378   //   __LONGDOUBLE128
1379   //   __CMODEL_MEDIUM__
1380   //   __CMODEL_LARGE__
1381   //   _CALL_SYSV
1382   //   _CALL_DARWIN
1383   //   __NO_FPRS__
1384 }
1385
1386 // Handle explicit options being passed to the compiler here: if we've
1387 // explicitly turned off vsx and turned on any of:
1388 // - power8-vector
1389 // - direct-move
1390 // - float128
1391 // - power9-vector
1392 // then go ahead and error since the customer has expressed an incompatible
1393 // set of options.
1394 static bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags,
1395                                  const std::vector<std::string> &FeaturesVec) {
1396
1397   if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "-vsx") !=
1398       FeaturesVec.end()) {
1399     if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+power8-vector") !=
1400         FeaturesVec.end()) {
1401       Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower8-vector"
1402                                                      << "-mno-vsx";
1403       return false;
1404     }
1405
1406     if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+direct-move") !=
1407         FeaturesVec.end()) {
1408       Diags.Report(diag::err_opt_not_valid_with_opt) << "-mdirect-move"
1409                                                      << "-mno-vsx";
1410       return false;
1411     }
1412
1413     if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+float128") !=
1414         FeaturesVec.end()) {
1415       Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfloat128"
1416                                                      << "-mno-vsx";
1417       return false;
1418     }
1419
1420     if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+power9-vector") !=
1421         FeaturesVec.end()) {
1422       Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower9-vector"
1423                                                      << "-mno-vsx";
1424       return false;
1425     }
1426   }
1427
1428   return true;
1429 }
1430
1431 bool PPCTargetInfo::initFeatureMap(
1432     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
1433     const std::vector<std::string> &FeaturesVec) const {
1434   Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1435     .Case("7400", true)
1436     .Case("g4", true)
1437     .Case("7450", true)
1438     .Case("g4+", true)
1439     .Case("970", true)
1440     .Case("g5", true)
1441     .Case("pwr6", true)
1442     .Case("pwr7", true)
1443     .Case("pwr8", true)
1444     .Case("pwr9", true)
1445     .Case("ppc64", true)
1446     .Case("ppc64le", true)
1447     .Default(false);
1448
1449   Features["qpx"] = (CPU == "a2q");
1450   Features["power9-vector"] = (CPU == "pwr9");
1451   Features["crypto"] = llvm::StringSwitch<bool>(CPU)
1452     .Case("ppc64le", true)
1453     .Case("pwr9", true)
1454     .Case("pwr8", true)
1455     .Default(false);
1456   Features["power8-vector"] = llvm::StringSwitch<bool>(CPU)
1457     .Case("ppc64le", true)
1458     .Case("pwr9", true)
1459     .Case("pwr8", true)
1460     .Default(false);
1461   Features["bpermd"] = llvm::StringSwitch<bool>(CPU)
1462     .Case("ppc64le", true)
1463     .Case("pwr9", true)
1464     .Case("pwr8", true)
1465     .Case("pwr7", true)
1466     .Default(false);
1467   Features["extdiv"] = llvm::StringSwitch<bool>(CPU)
1468     .Case("ppc64le", true)
1469     .Case("pwr9", true)
1470     .Case("pwr8", true)
1471     .Case("pwr7", true)
1472     .Default(false);
1473   Features["direct-move"] = llvm::StringSwitch<bool>(CPU)
1474     .Case("ppc64le", true)
1475     .Case("pwr9", true)
1476     .Case("pwr8", true)
1477     .Default(false);
1478   Features["vsx"] = llvm::StringSwitch<bool>(CPU)
1479     .Case("ppc64le", true)
1480     .Case("pwr9", true)
1481     .Case("pwr8", true)
1482     .Case("pwr7", true)
1483     .Default(false);
1484
1485   if (!ppcUserFeaturesCheck(Diags, FeaturesVec))
1486     return false;
1487
1488   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
1489 }
1490
1491 bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1492   return llvm::StringSwitch<bool>(Feature)
1493     .Case("powerpc", true)
1494     .Case("vsx", HasVSX)
1495     .Case("power8-vector", HasP8Vector)
1496     .Case("crypto", HasP8Crypto)
1497     .Case("direct-move", HasDirectMove)
1498     .Case("qpx", HasQPX)
1499     .Case("htm", HasHTM)
1500     .Case("bpermd", HasBPERMD)
1501     .Case("extdiv", HasExtDiv)
1502     .Case("float128", HasFloat128)
1503     .Case("power9-vector", HasP9Vector)
1504     .Default(false);
1505 }
1506
1507 void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1508                                       StringRef Name, bool Enabled) const {
1509   // If we're enabling direct-move or power8-vector go ahead and enable vsx
1510   // as well. Do the inverse if we're disabling vsx. We'll diagnose any user
1511   // incompatible options.
1512   if (Enabled) {
1513     if (Name == "direct-move" ||
1514         Name == "power8-vector" ||
1515         Name == "float128" ||
1516         Name == "power9-vector") {
1517       // power9-vector is really a superset of power8-vector so encode that.
1518       Features[Name] = Features["vsx"] = true;
1519       if (Name == "power9-vector")
1520         Features["power8-vector"] = true;
1521     } else {
1522       Features[Name] = true;
1523     }
1524   } else {
1525     if (Name == "vsx") {
1526       Features[Name] = Features["direct-move"] = Features["power8-vector"] =
1527           Features["float128"] = Features["power9-vector"] = false;
1528     } else {
1529       Features[Name] = false;
1530     }
1531   }
1532 }
1533
1534 const char * const PPCTargetInfo::GCCRegNames[] = {
1535   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1536   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1537   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1538   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1539   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1540   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1541   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1542   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
1543   "mq", "lr", "ctr", "ap",
1544   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
1545   "xer",
1546   "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1547   "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1548   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1549   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
1550   "vrsave", "vscr",
1551   "spe_acc", "spefscr",
1552   "sfp"
1553 };
1554
1555 ArrayRef<const char*> PPCTargetInfo::getGCCRegNames() const {
1556   return llvm::makeArrayRef(GCCRegNames);
1557 }
1558
1559 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1560   // While some of these aliases do map to different registers
1561   // they still share the same register name.
1562   { { "0" }, "r0" },
1563   { { "1"}, "r1" },
1564   { { "2" }, "r2" },
1565   { { "3" }, "r3" },
1566   { { "4" }, "r4" },
1567   { { "5" }, "r5" },
1568   { { "6" }, "r6" },
1569   { { "7" }, "r7" },
1570   { { "8" }, "r8" },
1571   { { "9" }, "r9" },
1572   { { "10" }, "r10" },
1573   { { "11" }, "r11" },
1574   { { "12" }, "r12" },
1575   { { "13" }, "r13" },
1576   { { "14" }, "r14" },
1577   { { "15" }, "r15" },
1578   { { "16" }, "r16" },
1579   { { "17" }, "r17" },
1580   { { "18" }, "r18" },
1581   { { "19" }, "r19" },
1582   { { "20" }, "r20" },
1583   { { "21" }, "r21" },
1584   { { "22" }, "r22" },
1585   { { "23" }, "r23" },
1586   { { "24" }, "r24" },
1587   { { "25" }, "r25" },
1588   { { "26" }, "r26" },
1589   { { "27" }, "r27" },
1590   { { "28" }, "r28" },
1591   { { "29" }, "r29" },
1592   { { "30" }, "r30" },
1593   { { "31" }, "r31" },
1594   { { "fr0" }, "f0" },
1595   { { "fr1" }, "f1" },
1596   { { "fr2" }, "f2" },
1597   { { "fr3" }, "f3" },
1598   { { "fr4" }, "f4" },
1599   { { "fr5" }, "f5" },
1600   { { "fr6" }, "f6" },
1601   { { "fr7" }, "f7" },
1602   { { "fr8" }, "f8" },
1603   { { "fr9" }, "f9" },
1604   { { "fr10" }, "f10" },
1605   { { "fr11" }, "f11" },
1606   { { "fr12" }, "f12" },
1607   { { "fr13" }, "f13" },
1608   { { "fr14" }, "f14" },
1609   { { "fr15" }, "f15" },
1610   { { "fr16" }, "f16" },
1611   { { "fr17" }, "f17" },
1612   { { "fr18" }, "f18" },
1613   { { "fr19" }, "f19" },
1614   { { "fr20" }, "f20" },
1615   { { "fr21" }, "f21" },
1616   { { "fr22" }, "f22" },
1617   { { "fr23" }, "f23" },
1618   { { "fr24" }, "f24" },
1619   { { "fr25" }, "f25" },
1620   { { "fr26" }, "f26" },
1621   { { "fr27" }, "f27" },
1622   { { "fr28" }, "f28" },
1623   { { "fr29" }, "f29" },
1624   { { "fr30" }, "f30" },
1625   { { "fr31" }, "f31" },
1626   { { "cc" }, "cr0" },
1627 };
1628
1629 ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const {
1630   return llvm::makeArrayRef(GCCRegAliases);
1631 }
1632
1633 class PPC32TargetInfo : public PPCTargetInfo {
1634 public:
1635   PPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1636       : PPCTargetInfo(Triple, Opts) {
1637     resetDataLayout("E-m:e-p:32:32-i64:64-n32");
1638
1639     switch (getTriple().getOS()) {
1640     case llvm::Triple::Linux:
1641     case llvm::Triple::FreeBSD:
1642     case llvm::Triple::NetBSD:
1643       SizeType = UnsignedInt;
1644       PtrDiffType = SignedInt;
1645       IntPtrType = SignedInt;
1646       break;
1647     default:
1648       break;
1649     }
1650
1651     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1652       LongDoubleWidth = LongDoubleAlign = 64;
1653       LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1654     }
1655
1656     // PPC32 supports atomics up to 4 bytes.
1657     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
1658   }
1659
1660   BuiltinVaListKind getBuiltinVaListKind() const override {
1661     // This is the ELF definition, and is overridden by the Darwin sub-target
1662     return TargetInfo::PowerABIBuiltinVaList;
1663   }
1664 };
1665
1666 // Note: ABI differences may eventually require us to have a separate
1667 // TargetInfo for little endian.
1668 class PPC64TargetInfo : public PPCTargetInfo {
1669 public:
1670   PPC64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1671       : PPCTargetInfo(Triple, Opts) {
1672     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1673     IntMaxType = SignedLong;
1674     Int64Type = SignedLong;
1675
1676     if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1677       resetDataLayout("e-m:e-i64:64-n32:64");
1678       ABI = "elfv2";
1679     } else {
1680       resetDataLayout("E-m:e-i64:64-n32:64");
1681       ABI = "elfv1";
1682     }
1683
1684     switch (getTriple().getOS()) {
1685     case llvm::Triple::FreeBSD:
1686       LongDoubleWidth = LongDoubleAlign = 64;
1687       LongDoubleFormat = &llvm::APFloat::IEEEdouble();
1688       break;
1689     case llvm::Triple::NetBSD:
1690       IntMaxType = SignedLongLong;
1691       Int64Type = SignedLongLong;
1692       break;
1693     default:
1694       break;
1695     }
1696
1697     // PPC64 supports atomics up to 8 bytes.
1698     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
1699   }
1700   BuiltinVaListKind getBuiltinVaListKind() const override {
1701     return TargetInfo::CharPtrBuiltinVaList;
1702   }
1703   // PPC64 Linux-specific ABI options.
1704   bool setABI(const std::string &Name) override {
1705     if (Name == "elfv1" || Name == "elfv1-qpx" || Name == "elfv2") {
1706       ABI = Name;
1707       return true;
1708     }
1709     return false;
1710   }
1711 };
1712
1713 class DarwinPPC32TargetInfo : public DarwinTargetInfo<PPC32TargetInfo> {
1714 public:
1715   DarwinPPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1716       : DarwinTargetInfo<PPC32TargetInfo>(Triple, Opts) {
1717     HasAlignMac68kSupport = true;
1718     BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
1719     PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
1720     LongLongAlign = 32;
1721     SuitableAlign = 128;
1722     resetDataLayout("E-m:o-p:32:32-f64:32:64-n32");
1723   }
1724   BuiltinVaListKind getBuiltinVaListKind() const override {
1725     return TargetInfo::CharPtrBuiltinVaList;
1726   }
1727 };
1728
1729 class DarwinPPC64TargetInfo : public DarwinTargetInfo<PPC64TargetInfo> {
1730 public:
1731   DarwinPPC64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1732       : DarwinTargetInfo<PPC64TargetInfo>(Triple, Opts) {
1733     HasAlignMac68kSupport = true;
1734     SuitableAlign = 128;
1735     resetDataLayout("E-m:o-i64:64-n32:64");
1736   }
1737 };
1738
1739 static const unsigned NVPTXAddrSpaceMap[] = {
1740     1, // opencl_global
1741     3, // opencl_local
1742     4, // opencl_constant
1743     // FIXME: generic has to be added to the target
1744     0, // opencl_generic
1745     1, // cuda_device
1746     4, // cuda_constant
1747     3, // cuda_shared
1748 };
1749
1750 class NVPTXTargetInfo : public TargetInfo {
1751   static const char *const GCCRegNames[];
1752   static const Builtin::Info BuiltinInfo[];
1753   CudaArch GPU;
1754   std::unique_ptr<TargetInfo> HostTarget;
1755
1756 public:
1757   NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts,
1758                   unsigned TargetPointerWidth)
1759       : TargetInfo(Triple) {
1760     assert((TargetPointerWidth == 32 || TargetPointerWidth == 64) &&
1761            "NVPTX only supports 32- and 64-bit modes.");
1762
1763     TLSSupported = false;
1764     AddrSpaceMap = &NVPTXAddrSpaceMap;
1765     UseAddrSpaceMapMangling = true;
1766
1767     // Define available target features
1768     // These must be defined in sorted order!
1769     NoAsmVariants = true;
1770     GPU = CudaArch::SM_20;
1771
1772     if (TargetPointerWidth == 32)
1773       resetDataLayout("e-p:32:32-i64:64-v16:16-v32:32-n16:32:64");
1774     else
1775       resetDataLayout("e-i64:64-v16:16-v32:32-n16:32:64");
1776
1777     // If possible, get a TargetInfo for our host triple, so we can match its
1778     // types.
1779     llvm::Triple HostTriple(Opts.HostTriple);
1780     if (!HostTriple.isNVPTX())
1781       HostTarget.reset(AllocateTarget(llvm::Triple(Opts.HostTriple), Opts));
1782
1783     // If no host target, make some guesses about the data layout and return.
1784     if (!HostTarget) {
1785       LongWidth = LongAlign = TargetPointerWidth;
1786       PointerWidth = PointerAlign = TargetPointerWidth;
1787       switch (TargetPointerWidth) {
1788       case 32:
1789         SizeType = TargetInfo::UnsignedInt;
1790         PtrDiffType = TargetInfo::SignedInt;
1791         IntPtrType = TargetInfo::SignedInt;
1792         break;
1793       case 64:
1794         SizeType = TargetInfo::UnsignedLong;
1795         PtrDiffType = TargetInfo::SignedLong;
1796         IntPtrType = TargetInfo::SignedLong;
1797         break;
1798       default:
1799         llvm_unreachable("TargetPointerWidth must be 32 or 64");
1800       }
1801       return;
1802     }
1803
1804     // Copy properties from host target.
1805     PointerWidth = HostTarget->getPointerWidth(/* AddrSpace = */ 0);
1806     PointerAlign = HostTarget->getPointerAlign(/* AddrSpace = */ 0);
1807     BoolWidth = HostTarget->getBoolWidth();
1808     BoolAlign = HostTarget->getBoolAlign();
1809     IntWidth = HostTarget->getIntWidth();
1810     IntAlign = HostTarget->getIntAlign();
1811     HalfWidth = HostTarget->getHalfWidth();
1812     HalfAlign = HostTarget->getHalfAlign();
1813     FloatWidth = HostTarget->getFloatWidth();
1814     FloatAlign = HostTarget->getFloatAlign();
1815     DoubleWidth = HostTarget->getDoubleWidth();
1816     DoubleAlign = HostTarget->getDoubleAlign();
1817     LongWidth = HostTarget->getLongWidth();
1818     LongAlign = HostTarget->getLongAlign();
1819     LongLongWidth = HostTarget->getLongLongWidth();
1820     LongLongAlign = HostTarget->getLongLongAlign();
1821     MinGlobalAlign = HostTarget->getMinGlobalAlign();
1822     NewAlign = HostTarget->getNewAlign();
1823     DefaultAlignForAttributeAligned =
1824         HostTarget->getDefaultAlignForAttributeAligned();
1825     SizeType = HostTarget->getSizeType();
1826     IntMaxType = HostTarget->getIntMaxType();
1827     PtrDiffType = HostTarget->getPtrDiffType(/* AddrSpace = */ 0);
1828     IntPtrType = HostTarget->getIntPtrType();
1829     WCharType = HostTarget->getWCharType();
1830     WIntType = HostTarget->getWIntType();
1831     Char16Type = HostTarget->getChar16Type();
1832     Char32Type = HostTarget->getChar32Type();
1833     Int64Type = HostTarget->getInt64Type();
1834     SigAtomicType = HostTarget->getSigAtomicType();
1835     ProcessIDType = HostTarget->getProcessIDType();
1836
1837     UseBitFieldTypeAlignment = HostTarget->useBitFieldTypeAlignment();
1838     UseZeroLengthBitfieldAlignment =
1839         HostTarget->useZeroLengthBitfieldAlignment();
1840     UseExplicitBitFieldAlignment = HostTarget->useExplicitBitFieldAlignment();
1841     ZeroLengthBitfieldBoundary = HostTarget->getZeroLengthBitfieldBoundary();
1842
1843     // This is a bit of a lie, but it controls __GCC_ATOMIC_XXX_LOCK_FREE, and
1844     // we need those macros to be identical on host and device, because (among
1845     // other things) they affect which standard library classes are defined, and
1846     // we need all classes to be defined on both the host and device.
1847     MaxAtomicInlineWidth = HostTarget->getMaxAtomicInlineWidth();
1848
1849     // Properties intentionally not copied from host:
1850     // - LargeArrayMinWidth, LargeArrayAlign: Not visible across the
1851     //   host/device boundary.
1852     // - SuitableAlign: Not visible across the host/device boundary, and may
1853     //   correctly be different on host/device, e.g. if host has wider vector
1854     //   types than device.
1855     // - LongDoubleWidth, LongDoubleAlign: nvptx's long double type is the same
1856     //   as its double type, but that's not necessarily true on the host.
1857     //   TODO: nvcc emits a warning when using long double on device; we should
1858     //   do the same.
1859   }
1860   void getTargetDefines(const LangOptions &Opts,
1861                         MacroBuilder &Builder) const override {
1862     Builder.defineMacro("__PTX__");
1863     Builder.defineMacro("__NVPTX__");
1864     if (Opts.CUDAIsDevice) {
1865       // Set __CUDA_ARCH__ for the GPU specified.
1866       std::string CUDAArchCode = [this] {
1867         switch (GPU) {
1868         case CudaArch::UNKNOWN:
1869           assert(false && "No GPU arch when compiling CUDA device code.");
1870           return "";
1871         case CudaArch::SM_20:
1872           return "200";
1873         case CudaArch::SM_21:
1874           return "210";
1875         case CudaArch::SM_30:
1876           return "300";
1877         case CudaArch::SM_32:
1878           return "320";
1879         case CudaArch::SM_35:
1880           return "350";
1881         case CudaArch::SM_37:
1882           return "370";
1883         case CudaArch::SM_50:
1884           return "500";
1885         case CudaArch::SM_52:
1886           return "520";
1887         case CudaArch::SM_53:
1888           return "530";
1889         case CudaArch::SM_60:
1890           return "600";
1891         case CudaArch::SM_61:
1892           return "610";
1893         case CudaArch::SM_62:
1894           return "620";
1895         }
1896         llvm_unreachable("unhandled CudaArch");
1897       }();
1898       Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
1899     }
1900   }
1901   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
1902     return llvm::makeArrayRef(BuiltinInfo,
1903                          clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
1904   }
1905   bool
1906   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
1907                  StringRef CPU,
1908                  const std::vector<std::string> &FeaturesVec) const override {
1909     Features["satom"] = GPU >= CudaArch::SM_60;
1910     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
1911   }
1912
1913   bool hasFeature(StringRef Feature) const override {
1914     return llvm::StringSwitch<bool>(Feature)
1915         .Cases("ptx", "nvptx", true)
1916         .Case("satom", GPU >= CudaArch::SM_60)  // Atomics w/ scope.
1917         .Default(false);
1918   }
1919
1920   ArrayRef<const char *> getGCCRegNames() const override;
1921   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
1922     // No aliases.
1923     return None;
1924   }
1925   bool validateAsmConstraint(const char *&Name,
1926                              TargetInfo::ConstraintInfo &Info) const override {
1927     switch (*Name) {
1928     default:
1929       return false;
1930     case 'c':
1931     case 'h':
1932     case 'r':
1933     case 'l':
1934     case 'f':
1935     case 'd':
1936       Info.setAllowsRegister();
1937       return true;
1938     }
1939   }
1940   const char *getClobbers() const override {
1941     // FIXME: Is this really right?
1942     return "";
1943   }
1944   BuiltinVaListKind getBuiltinVaListKind() const override {
1945     // FIXME: implement
1946     return TargetInfo::CharPtrBuiltinVaList;
1947   }
1948   bool setCPU(const std::string &Name) override {
1949     GPU = StringToCudaArch(Name);
1950     return GPU != CudaArch::UNKNOWN;
1951   }
1952   void setSupportedOpenCLOpts() override {
1953     auto &Opts = getSupportedOpenCLOpts();
1954     Opts.support("cl_clang_storage_class_specifiers");
1955     Opts.support("cl_khr_gl_sharing");
1956     Opts.support("cl_khr_icd");
1957
1958     Opts.support("cl_khr_fp64");
1959     Opts.support("cl_khr_byte_addressable_store");
1960     Opts.support("cl_khr_global_int32_base_atomics");
1961     Opts.support("cl_khr_global_int32_extended_atomics");
1962     Opts.support("cl_khr_local_int32_base_atomics");
1963     Opts.support("cl_khr_local_int32_extended_atomics");
1964   }
1965
1966   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
1967     // CUDA compilations support all of the host's calling conventions.
1968     //
1969     // TODO: We should warn if you apply a non-default CC to anything other than
1970     // a host function.
1971     if (HostTarget)
1972       return HostTarget->checkCallingConvention(CC);
1973     return CCCR_Warning;
1974   }
1975 };
1976
1977 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1978 #define BUILTIN(ID, TYPE, ATTRS)                                               \
1979   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1980 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER)                                    \
1981   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
1982 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
1983   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
1984 #include "clang/Basic/BuiltinsNVPTX.def"
1985 };
1986
1987 const char *const NVPTXTargetInfo::GCCRegNames[] = {"r0"};
1988
1989 ArrayRef<const char *> NVPTXTargetInfo::getGCCRegNames() const {
1990   return llvm::makeArrayRef(GCCRegNames);
1991 }
1992
1993 static const unsigned AMDGPUAddrSpaceMap[] = {
1994   1,    // opencl_global
1995   3,    // opencl_local
1996   2,    // opencl_constant
1997   4,    // opencl_generic
1998   1,    // cuda_device
1999   2,    // cuda_constant
2000   3     // cuda_shared
2001 };
2002
2003 // If you edit the description strings, make sure you update
2004 // getPointerWidthV().
2005
2006 static const char *const DataLayoutStringR600 =
2007   "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
2008   "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
2009
2010 static const char *const DataLayoutStringSI =
2011   "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32"
2012   "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
2013   "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
2014
2015 class AMDGPUTargetInfo final : public TargetInfo {
2016   static const Builtin::Info BuiltinInfo[];
2017   static const char * const GCCRegNames[];
2018
2019   /// \brief The GPU profiles supported by the AMDGPU target.
2020   enum GPUKind {
2021     GK_NONE,
2022     GK_R600,
2023     GK_R600_DOUBLE_OPS,
2024     GK_R700,
2025     GK_R700_DOUBLE_OPS,
2026     GK_EVERGREEN,
2027     GK_EVERGREEN_DOUBLE_OPS,
2028     GK_NORTHERN_ISLANDS,
2029     GK_CAYMAN,
2030     GK_GFX6,
2031     GK_GFX7,
2032     GK_GFX8
2033   } GPU;
2034
2035   bool hasFP64:1;
2036   bool hasFMAF:1;
2037   bool hasLDEXPF:1;
2038   bool hasFullSpeedFP32Denorms:1;
2039
2040   static bool isAMDGCN(const llvm::Triple &TT) {
2041     return TT.getArch() == llvm::Triple::amdgcn;
2042   }
2043
2044 public:
2045   AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
2046     : TargetInfo(Triple) ,
2047       GPU(isAMDGCN(Triple) ? GK_GFX6 : GK_R600),
2048       hasFP64(false),
2049       hasFMAF(false),
2050       hasLDEXPF(false),
2051       hasFullSpeedFP32Denorms(false){
2052     if (getTriple().getArch() == llvm::Triple::amdgcn) {
2053       hasFP64 = true;
2054       hasFMAF = true;
2055       hasLDEXPF = true;
2056     }
2057
2058     resetDataLayout(getTriple().getArch() == llvm::Triple::amdgcn ?
2059                     DataLayoutStringSI : DataLayoutStringR600);
2060
2061     AddrSpaceMap = &AMDGPUAddrSpaceMap;
2062     UseAddrSpaceMapMangling = true;
2063   }
2064
2065   uint64_t getPointerWidthV(unsigned AddrSpace) const override {
2066     if (GPU <= GK_CAYMAN)
2067       return 32;
2068
2069     switch(AddrSpace) {
2070       default:
2071         return 64;
2072       case 0:
2073       case 3:
2074       case 5:
2075         return 32;
2076     }
2077   }
2078
2079   uint64_t getMaxPointerWidth() const override {
2080     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
2081   }
2082
2083   const char * getClobbers() const override {
2084     return "";
2085   }
2086
2087   ArrayRef<const char *> getGCCRegNames() const override;
2088
2089   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
2090     return None;
2091   }
2092
2093   bool validateAsmConstraint(const char *&Name,
2094                              TargetInfo::ConstraintInfo &Info) const override {
2095     switch (*Name) {
2096     default: break;
2097     case 'v': // vgpr
2098     case 's': // sgpr
2099       Info.setAllowsRegister();
2100       return true;
2101     }
2102     return false;
2103   }
2104
2105   bool initFeatureMap(llvm::StringMap<bool> &Features,
2106                       DiagnosticsEngine &Diags, StringRef CPU,
2107                       const std::vector<std::string> &FeatureVec) const override;
2108
2109   void adjustTargetOptions(const CodeGenOptions &CGOpts,
2110                            TargetOptions &TargetOpts) const override {
2111     bool hasFP32Denormals = false;
2112     bool hasFP64Denormals = false;
2113     for (auto &I : TargetOpts.FeaturesAsWritten) {
2114       if (I == "+fp32-denormals" || I == "-fp32-denormals")
2115         hasFP32Denormals = true;
2116       if (I == "+fp64-denormals" || I == "-fp64-denormals")
2117         hasFP64Denormals = true;
2118     }
2119     if (!hasFP32Denormals)
2120       TargetOpts.Features.push_back((Twine(hasFullSpeedFP32Denorms &&
2121           !CGOpts.FlushDenorm ? '+' : '-') + Twine("fp32-denormals")).str());
2122     // Always do not flush fp64 denorms.
2123     if (!hasFP64Denormals && hasFP64)
2124       TargetOpts.Features.push_back("+fp64-denormals");
2125   }
2126
2127   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
2128     return llvm::makeArrayRef(BuiltinInfo,
2129                         clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin);
2130   }
2131
2132   void getTargetDefines(const LangOptions &Opts,
2133                         MacroBuilder &Builder) const override {
2134     if (getTriple().getArch() == llvm::Triple::amdgcn)
2135       Builder.defineMacro("__AMDGCN__");
2136     else
2137       Builder.defineMacro("__R600__");
2138
2139     if (hasFMAF)
2140       Builder.defineMacro("__HAS_FMAF__");
2141     if (hasLDEXPF)
2142       Builder.defineMacro("__HAS_LDEXPF__");
2143     if (hasFP64)
2144       Builder.defineMacro("__HAS_FP64__");
2145   }
2146
2147   BuiltinVaListKind getBuiltinVaListKind() const override {
2148     return TargetInfo::CharPtrBuiltinVaList;
2149   }
2150
2151   static GPUKind parseR600Name(StringRef Name) {
2152     return llvm::StringSwitch<GPUKind>(Name)
2153       .Case("r600" ,    GK_R600)
2154       .Case("rv610",    GK_R600)
2155       .Case("rv620",    GK_R600)
2156       .Case("rv630",    GK_R600)
2157       .Case("rv635",    GK_R600)
2158       .Case("rs780",    GK_R600)
2159       .Case("rs880",    GK_R600)
2160       .Case("rv670",    GK_R600_DOUBLE_OPS)
2161       .Case("rv710",    GK_R700)
2162       .Case("rv730",    GK_R700)
2163       .Case("rv740",    GK_R700_DOUBLE_OPS)
2164       .Case("rv770",    GK_R700_DOUBLE_OPS)
2165       .Case("palm",     GK_EVERGREEN)
2166       .Case("cedar",    GK_EVERGREEN)
2167       .Case("sumo",     GK_EVERGREEN)
2168       .Case("sumo2",    GK_EVERGREEN)
2169       .Case("redwood",  GK_EVERGREEN)
2170       .Case("juniper",  GK_EVERGREEN)
2171       .Case("hemlock",  GK_EVERGREEN_DOUBLE_OPS)
2172       .Case("cypress",  GK_EVERGREEN_DOUBLE_OPS)
2173       .Case("barts",    GK_NORTHERN_ISLANDS)
2174       .Case("turks",    GK_NORTHERN_ISLANDS)
2175       .Case("caicos",   GK_NORTHERN_ISLANDS)
2176       .Case("cayman",   GK_CAYMAN)
2177       .Case("aruba",    GK_CAYMAN)
2178       .Default(GK_NONE);
2179   }
2180
2181   static GPUKind parseAMDGCNName(StringRef Name) {
2182     return llvm::StringSwitch<GPUKind>(Name)
2183       .Case("tahiti",    GK_GFX6)
2184       .Case("pitcairn",  GK_GFX6)
2185       .Case("verde",     GK_GFX6)
2186       .Case("oland",     GK_GFX6)
2187       .Case("hainan",    GK_GFX6)
2188       .Case("bonaire",   GK_GFX7)
2189       .Case("kabini",    GK_GFX7)
2190       .Case("kaveri",    GK_GFX7)
2191       .Case("hawaii",    GK_GFX7)
2192       .Case("mullins",   GK_GFX7)
2193       .Case("gfx700",    GK_GFX7)
2194       .Case("gfx701",    GK_GFX7)
2195       .Case("gfx702",    GK_GFX7)
2196       .Case("tonga",     GK_GFX8)
2197       .Case("iceland",   GK_GFX8)
2198       .Case("carrizo",   GK_GFX8)
2199       .Case("fiji",      GK_GFX8)
2200       .Case("stoney",    GK_GFX8)
2201       .Case("polaris10", GK_GFX8)
2202       .Case("polaris11", GK_GFX8)
2203       .Case("gfx800",    GK_GFX8)
2204       .Case("gfx801",    GK_GFX8)
2205       .Case("gfx802",    GK_GFX8)
2206       .Case("gfx803",    GK_GFX8)
2207       .Case("gfx804",    GK_GFX8)
2208       .Case("gfx810",    GK_GFX8)
2209       .Default(GK_NONE);
2210   }
2211
2212   bool setCPU(const std::string &Name) override {
2213     if (getTriple().getArch() == llvm::Triple::amdgcn)
2214       GPU = parseAMDGCNName(Name);
2215     else
2216       GPU = parseR600Name(Name);
2217
2218     return GPU != GK_NONE;
2219   }
2220
2221   void setSupportedOpenCLOpts() override {
2222     auto &Opts = getSupportedOpenCLOpts();
2223     Opts.support("cl_clang_storage_class_specifiers");
2224     Opts.support("cl_khr_icd");
2225
2226     if (hasFP64)
2227       Opts.support("cl_khr_fp64");
2228     if (GPU >= GK_EVERGREEN) {
2229       Opts.support("cl_khr_byte_addressable_store");
2230       Opts.support("cl_khr_global_int32_base_atomics");
2231       Opts.support("cl_khr_global_int32_extended_atomics");
2232       Opts.support("cl_khr_local_int32_base_atomics");
2233       Opts.support("cl_khr_local_int32_extended_atomics");
2234     }
2235     if (GPU >= GK_GFX6) {
2236       Opts.support("cl_khr_fp16");
2237       Opts.support("cl_khr_int64_base_atomics");
2238       Opts.support("cl_khr_int64_extended_atomics");
2239       Opts.support("cl_khr_mipmap_image");
2240       Opts.support("cl_khr_subgroups");
2241       Opts.support("cl_khr_3d_image_writes");
2242       Opts.support("cl_amd_media_ops");
2243       Opts.support("cl_amd_media_ops2");
2244     }
2245   }
2246
2247   LangAS::ID getOpenCLImageAddrSpace() const override {
2248     return LangAS::opencl_constant;
2249   }
2250
2251   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
2252     switch (CC) {
2253       default:
2254         return CCCR_Warning;
2255       case CC_C:
2256       case CC_OpenCLKernel:
2257         return CCCR_OK;
2258     }
2259   }
2260
2261   // In amdgcn target the null pointer in global, constant, and generic
2262   // address space has value 0 but in private and local address space has
2263   // value ~0.
2264   uint64_t getNullPointerValue(unsigned AS) const override {
2265     return AS != LangAS::opencl_local && AS != 0 ? 0 : ~0;
2266   }
2267 };
2268
2269 const Builtin::Info AMDGPUTargetInfo::BuiltinInfo[] = {
2270 #define BUILTIN(ID, TYPE, ATTRS)                \
2271   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
2272 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
2273   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
2274 #include "clang/Basic/BuiltinsAMDGPU.def"
2275 };
2276 const char * const AMDGPUTargetInfo::GCCRegNames[] = {
2277   "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
2278   "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
2279   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
2280   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
2281   "v32", "v33", "v34", "v35", "v36", "v37", "v38", "v39",
2282   "v40", "v41", "v42", "v43", "v44", "v45", "v46", "v47",
2283   "v48", "v49", "v50", "v51", "v52", "v53", "v54", "v55",
2284   "v56", "v57", "v58", "v59", "v60", "v61", "v62", "v63",
2285   "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71",
2286   "v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79",
2287   "v80", "v81", "v82", "v83", "v84", "v85", "v86", "v87",
2288   "v88", "v89", "v90", "v91", "v92", "v93", "v94", "v95",
2289   "v96", "v97", "v98", "v99", "v100", "v101", "v102", "v103",
2290   "v104", "v105", "v106", "v107", "v108", "v109", "v110", "v111",
2291   "v112", "v113", "v114", "v115", "v116", "v117", "v118", "v119",
2292   "v120", "v121", "v122", "v123", "v124", "v125", "v126", "v127",
2293   "v128", "v129", "v130", "v131", "v132", "v133", "v134", "v135",
2294   "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143",
2295   "v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151",
2296   "v152", "v153", "v154", "v155", "v156", "v157", "v158", "v159",
2297   "v160", "v161", "v162", "v163", "v164", "v165", "v166", "v167",
2298   "v168", "v169", "v170", "v171", "v172", "v173", "v174", "v175",
2299   "v176", "v177", "v178", "v179", "v180", "v181", "v182", "v183",
2300   "v184", "v185", "v186", "v187", "v188", "v189", "v190", "v191",
2301   "v192", "v193", "v194", "v195", "v196", "v197", "v198", "v199",
2302   "v200", "v201", "v202", "v203", "v204", "v205", "v206", "v207",
2303   "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215",
2304   "v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223",
2305   "v224", "v225", "v226", "v227", "v228", "v229", "v230", "v231",
2306   "v232", "v233", "v234", "v235", "v236", "v237", "v238", "v239",
2307   "v240", "v241", "v242", "v243", "v244", "v245", "v246", "v247",
2308   "v248", "v249", "v250", "v251", "v252", "v253", "v254", "v255",
2309   "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2310   "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2311   "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
2312   "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
2313   "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
2314   "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
2315   "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
2316   "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
2317   "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
2318   "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
2319   "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
2320   "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
2321   "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
2322   "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
2323   "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
2324   "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
2325   "exec", "vcc", "scc", "m0", "flat_scratch", "exec_lo", "exec_hi",
2326   "vcc_lo", "vcc_hi", "flat_scratch_lo", "flat_scratch_hi"
2327 };
2328
2329 ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const {
2330   return llvm::makeArrayRef(GCCRegNames);
2331 }
2332
2333 bool AMDGPUTargetInfo::initFeatureMap(
2334   llvm::StringMap<bool> &Features,
2335   DiagnosticsEngine &Diags, StringRef CPU,
2336   const std::vector<std::string> &FeatureVec) const {
2337
2338   // XXX - What does the member GPU mean if device name string passed here?
2339   if (getTriple().getArch() == llvm::Triple::amdgcn) {
2340     if (CPU.empty())
2341       CPU = "tahiti";
2342
2343     switch (parseAMDGCNName(CPU)) {
2344     case GK_GFX6:
2345     case GK_GFX7:
2346       break;
2347
2348     case GK_GFX8:
2349       Features["s-memrealtime"] = true;
2350       Features["16-bit-insts"] = true;
2351       break;
2352
2353     case GK_NONE:
2354       return false;
2355     default:
2356       llvm_unreachable("unhandled subtarget");
2357     }
2358   } else {
2359     if (CPU.empty())
2360       CPU = "r600";
2361
2362     switch (parseR600Name(CPU)) {
2363     case GK_R600:
2364     case GK_R700:
2365     case GK_EVERGREEN:
2366     case GK_NORTHERN_ISLANDS:
2367       break;
2368     case GK_R600_DOUBLE_OPS:
2369     case GK_R700_DOUBLE_OPS:
2370     case GK_EVERGREEN_DOUBLE_OPS:
2371     case GK_CAYMAN:
2372       Features["fp64"] = true;
2373       break;
2374     case GK_NONE:
2375       return false;
2376     default:
2377       llvm_unreachable("unhandled subtarget");
2378     }
2379   }
2380
2381   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec);
2382 }
2383
2384 const Builtin::Info BuiltinInfoX86[] = {
2385 #define BUILTIN(ID, TYPE, ATTRS)                                               \
2386   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
2387 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
2388   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
2389 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE)         \
2390   { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
2391 #include "clang/Basic/BuiltinsX86.def"
2392
2393 #define BUILTIN(ID, TYPE, ATTRS)                                               \
2394   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
2395 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)         \
2396   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
2397 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE)         \
2398   { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
2399 #include "clang/Basic/BuiltinsX86_64.def"
2400 };
2401
2402
2403 static const char* const GCCRegNames[] = {
2404   "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
2405   "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
2406   "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
2407   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
2408   "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
2409   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2410   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
2411   "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
2412   "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
2413   "xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23",
2414   "xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31",
2415   "ymm16", "ymm17", "ymm18", "ymm19", "ymm20", "ymm21", "ymm22", "ymm23",
2416   "ymm24", "ymm25", "ymm26", "ymm27", "ymm28", "ymm29", "ymm30", "ymm31",
2417   "zmm0", "zmm1", "zmm2", "zmm3", "zmm4", "zmm5", "zmm6", "zmm7",
2418   "zmm8", "zmm9", "zmm10", "zmm11", "zmm12", "zmm13", "zmm14", "zmm15",
2419   "zmm16", "zmm17", "zmm18", "zmm19", "zmm20", "zmm21", "zmm22", "zmm23",
2420   "zmm24", "zmm25", "zmm26", "zmm27", "zmm28", "zmm29", "zmm30", "zmm31",
2421   "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7",
2422 };
2423
2424 const TargetInfo::AddlRegName AddlRegNames[] = {
2425   { { "al", "ah", "eax", "rax" }, 0 },
2426   { { "bl", "bh", "ebx", "rbx" }, 3 },
2427   { { "cl", "ch", "ecx", "rcx" }, 2 },
2428   { { "dl", "dh", "edx", "rdx" }, 1 },
2429   { { "esi", "rsi" }, 4 },
2430   { { "edi", "rdi" }, 5 },
2431   { { "esp", "rsp" }, 7 },
2432   { { "ebp", "rbp" }, 6 },
2433   { { "r8d", "r8w", "r8b" }, 38 },
2434   { { "r9d", "r9w", "r9b" }, 39 },
2435   { { "r10d", "r10w", "r10b" }, 40 },
2436   { { "r11d", "r11w", "r11b" }, 41 },
2437   { { "r12d", "r12w", "r12b" }, 42 },
2438   { { "r13d", "r13w", "r13b" }, 43 },
2439   { { "r14d", "r14w", "r14b" }, 44 },
2440   { { "r15d", "r15w", "r15b" }, 45 },
2441 };
2442
2443 // X86 target abstract base class; x86-32 and x86-64 are very close, so
2444 // most of the implementation can be shared.
2445 class X86TargetInfo : public TargetInfo {
2446   enum X86SSEEnum {
2447     NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
2448   } SSELevel = NoSSE;
2449   enum MMX3DNowEnum {
2450     NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
2451   } MMX3DNowLevel = NoMMX3DNow;
2452   enum XOPEnum {
2453     NoXOP,
2454     SSE4A,
2455     FMA4,
2456     XOP
2457   } XOPLevel = NoXOP;
2458
2459   bool HasAES = false;
2460   bool HasPCLMUL = false;
2461   bool HasLZCNT = false;
2462   bool HasRDRND = false;
2463   bool HasFSGSBASE = false;
2464   bool HasBMI = false;
2465   bool HasBMI2 = false;
2466   bool HasPOPCNT = false;
2467   bool HasRTM = false;
2468   bool HasPRFCHW = false;
2469   bool HasRDSEED = false;
2470   bool HasADX = false;
2471   bool HasTBM = false;
2472   bool HasFMA = false;
2473   bool HasF16C = false;
2474   bool HasAVX512CD = false;
2475   bool HasAVX512ER = false;
2476   bool HasAVX512PF = false;
2477   bool HasAVX512DQ = false;
2478   bool HasAVX512BW = false;
2479   bool HasAVX512VL = false;
2480   bool HasAVX512VBMI = false;
2481   bool HasAVX512IFMA = false;
2482   bool HasSHA = false;
2483   bool HasMPX = false;
2484   bool HasSGX = false;
2485   bool HasCX16 = false;
2486   bool HasFXSR = false;
2487   bool HasXSAVE = false;
2488   bool HasXSAVEOPT = false;
2489   bool HasXSAVEC = false;
2490   bool HasXSAVES = false;
2491   bool HasMWAITX = false;
2492   bool HasPKU = false;
2493   bool HasCLFLUSHOPT = false;
2494   bool HasPCOMMIT = false;
2495   bool HasCLWB = false;
2496   bool HasUMIP = false;
2497   bool HasMOVBE = false;
2498   bool HasPREFETCHWT1 = false;
2499
2500   /// \brief Enumeration of all of the X86 CPUs supported by Clang.
2501   ///
2502   /// Each enumeration represents a particular CPU supported by Clang. These
2503   /// loosely correspond to the options passed to '-march' or '-mtune' flags.
2504   enum CPUKind {
2505     CK_Generic,
2506
2507     /// \name i386
2508     /// i386-generation processors.
2509     //@{
2510     CK_i386,
2511     //@}
2512
2513     /// \name i486
2514     /// i486-generation processors.
2515     //@{
2516     CK_i486,
2517     CK_WinChipC6,
2518     CK_WinChip2,
2519     CK_C3,
2520     //@}
2521
2522     /// \name i586
2523     /// i586-generation processors, P5 microarchitecture based.
2524     //@{
2525     CK_i586,
2526     CK_Pentium,
2527     CK_PentiumMMX,
2528     //@}
2529
2530     /// \name i686
2531     /// i686-generation processors, P6 / Pentium M microarchitecture based.
2532     //@{
2533     CK_i686,
2534     CK_PentiumPro,
2535     CK_Pentium2,
2536     CK_Pentium3,
2537     CK_Pentium3M,
2538     CK_PentiumM,
2539     CK_C3_2,
2540
2541     /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
2542     /// Clang however has some logic to suport this.
2543     // FIXME: Warn, deprecate, and potentially remove this.
2544     CK_Yonah,
2545     //@}
2546
2547     /// \name Netburst
2548     /// Netburst microarchitecture based processors.
2549     //@{
2550     CK_Pentium4,
2551     CK_Pentium4M,
2552     CK_Prescott,
2553     CK_Nocona,
2554     //@}
2555
2556     /// \name Core
2557     /// Core microarchitecture based processors.
2558     //@{
2559     CK_Core2,
2560
2561     /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
2562     /// codename which GCC no longer accepts as an option to -march, but Clang
2563     /// has some logic for recognizing it.
2564     // FIXME: Warn, deprecate, and potentially remove this.
2565     CK_Penryn,
2566     //@}
2567
2568     /// \name Atom
2569     /// Atom processors
2570     //@{
2571     CK_Bonnell,
2572     CK_Silvermont,
2573     //@}
2574
2575     /// \name Nehalem
2576     /// Nehalem microarchitecture based processors.
2577     CK_Nehalem,
2578
2579     /// \name Westmere
2580     /// Westmere microarchitecture based processors.
2581     CK_Westmere,
2582
2583     /// \name Sandy Bridge
2584     /// Sandy Bridge microarchitecture based processors.
2585     CK_SandyBridge,
2586
2587     /// \name Ivy Bridge
2588     /// Ivy Bridge microarchitecture based processors.
2589     CK_IvyBridge,
2590
2591     /// \name Haswell
2592     /// Haswell microarchitecture based processors.
2593     CK_Haswell,
2594
2595     /// \name Broadwell
2596     /// Broadwell microarchitecture based processors.
2597     CK_Broadwell,
2598
2599     /// \name Skylake Client
2600     /// Skylake client microarchitecture based processors.
2601     CK_SkylakeClient,
2602
2603     /// \name Skylake Server
2604     /// Skylake server microarchitecture based processors.
2605     CK_SkylakeServer,
2606
2607     /// \name Cannonlake Client
2608     /// Cannonlake client microarchitecture based processors.
2609     CK_Cannonlake,
2610
2611     /// \name Knights Landing
2612     /// Knights Landing processor.
2613     CK_KNL,
2614
2615     /// \name Lakemont
2616     /// Lakemont microarchitecture based processors.
2617     CK_Lakemont,
2618
2619     /// \name K6
2620     /// K6 architecture processors.
2621     //@{
2622     CK_K6,
2623     CK_K6_2,
2624     CK_K6_3,
2625     //@}
2626
2627     /// \name K7
2628     /// K7 architecture processors.
2629     //@{
2630     CK_Athlon,
2631     CK_AthlonThunderbird,
2632     CK_Athlon4,
2633     CK_AthlonXP,
2634     CK_AthlonMP,
2635     //@}
2636
2637     /// \name K8
2638     /// K8 architecture processors.
2639     //@{
2640     CK_Athlon64,
2641     CK_Athlon64SSE3,
2642     CK_AthlonFX,
2643     CK_K8,
2644     CK_K8SSE3,
2645     CK_Opteron,
2646     CK_OpteronSSE3,
2647     CK_AMDFAM10,
2648     //@}
2649
2650     /// \name Bobcat
2651     /// Bobcat architecture processors.
2652     //@{
2653     CK_BTVER1,
2654     CK_BTVER2,
2655     //@}
2656
2657     /// \name Bulldozer
2658     /// Bulldozer architecture processors.
2659     //@{
2660     CK_BDVER1,
2661     CK_BDVER2,
2662     CK_BDVER3,
2663     CK_BDVER4,
2664     //@}
2665
2666     /// \name zen
2667     /// Zen architecture processors.
2668     //@{
2669     CK_ZNVER1,
2670     //@}
2671
2672     /// This specification is deprecated and will be removed in the future.
2673     /// Users should prefer \see CK_K8.
2674     // FIXME: Warn on this when the CPU is set to it.
2675     //@{
2676     CK_x86_64,
2677     //@}
2678
2679     /// \name Geode
2680     /// Geode processors.
2681     //@{
2682     CK_Geode
2683     //@}
2684   } CPU = CK_Generic;
2685
2686   CPUKind getCPUKind(StringRef CPU) const {
2687     return llvm::StringSwitch<CPUKind>(CPU)
2688         .Case("i386", CK_i386)
2689         .Case("i486", CK_i486)
2690         .Case("winchip-c6", CK_WinChipC6)
2691         .Case("winchip2", CK_WinChip2)
2692         .Case("c3", CK_C3)
2693         .Case("i586", CK_i586)
2694         .Case("pentium", CK_Pentium)
2695         .Case("pentium-mmx", CK_PentiumMMX)
2696         .Case("i686", CK_i686)
2697         .Case("pentiumpro", CK_PentiumPro)
2698         .Case("pentium2", CK_Pentium2)
2699         .Case("pentium3", CK_Pentium3)
2700         .Case("pentium3m", CK_Pentium3M)
2701         .Case("pentium-m", CK_PentiumM)
2702         .Case("c3-2", CK_C3_2)
2703         .Case("yonah", CK_Yonah)
2704         .Case("pentium4", CK_Pentium4)
2705         .Case("pentium4m", CK_Pentium4M)
2706         .Case("prescott", CK_Prescott)
2707         .Case("nocona", CK_Nocona)
2708         .Case("core2", CK_Core2)
2709         .Case("penryn", CK_Penryn)
2710         .Case("bonnell", CK_Bonnell)
2711         .Case("atom", CK_Bonnell) // Legacy name.
2712         .Case("silvermont", CK_Silvermont)
2713         .Case("slm", CK_Silvermont) // Legacy name.
2714         .Case("nehalem", CK_Nehalem)
2715         .Case("corei7", CK_Nehalem) // Legacy name.
2716         .Case("westmere", CK_Westmere)
2717         .Case("sandybridge", CK_SandyBridge)
2718         .Case("corei7-avx", CK_SandyBridge) // Legacy name.
2719         .Case("ivybridge", CK_IvyBridge)
2720         .Case("core-avx-i", CK_IvyBridge) // Legacy name.
2721         .Case("haswell", CK_Haswell)
2722         .Case("core-avx2", CK_Haswell) // Legacy name.
2723         .Case("broadwell", CK_Broadwell)
2724         .Case("skylake", CK_SkylakeClient)
2725         .Case("skylake-avx512", CK_SkylakeServer)
2726         .Case("skx", CK_SkylakeServer) // Legacy name.
2727         .Case("cannonlake", CK_Cannonlake)
2728         .Case("knl", CK_KNL)
2729         .Case("lakemont", CK_Lakemont)
2730         .Case("k6", CK_K6)
2731         .Case("k6-2", CK_K6_2)
2732         .Case("k6-3", CK_K6_3)
2733         .Case("athlon", CK_Athlon)
2734         .Case("athlon-tbird", CK_AthlonThunderbird)
2735         .Case("athlon-4", CK_Athlon4)
2736         .Case("athlon-xp", CK_AthlonXP)
2737         .Case("athlon-mp", CK_AthlonMP)
2738         .Case("athlon64", CK_Athlon64)
2739         .Case("athlon64-sse3", CK_Athlon64SSE3)
2740         .Case("athlon-fx", CK_AthlonFX)
2741         .Case("k8", CK_K8)
2742         .Case("k8-sse3", CK_K8SSE3)
2743         .Case("opteron", CK_Opteron)
2744         .Case("opteron-sse3", CK_OpteronSSE3)
2745         .Case("barcelona", CK_AMDFAM10)
2746         .Case("amdfam10", CK_AMDFAM10)
2747         .Case("btver1", CK_BTVER1)
2748         .Case("btver2", CK_BTVER2)
2749         .Case("bdver1", CK_BDVER1)
2750         .Case("bdver2", CK_BDVER2)
2751         .Case("bdver3", CK_BDVER3)
2752         .Case("bdver4", CK_BDVER4)
2753         .Case("znver1", CK_ZNVER1)
2754         .Case("x86-64", CK_x86_64)
2755         .Case("geode", CK_Geode)
2756         .Default(CK_Generic);
2757   }
2758
2759   enum FPMathKind {
2760     FP_Default,
2761     FP_SSE,
2762     FP_387
2763   } FPMath = FP_Default;
2764
2765 public:
2766   X86TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
2767       : TargetInfo(Triple) {
2768     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
2769   }
2770   unsigned getFloatEvalMethod() const override {
2771     // X87 evaluates with 80 bits "long double" precision.
2772     return SSELevel == NoSSE ? 2 : 0;
2773   }
2774   ArrayRef<const char *> getGCCRegNames() const override {
2775     return llvm::makeArrayRef(GCCRegNames);
2776   }
2777   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
2778     return None;
2779   }
2780   ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override {
2781     return llvm::makeArrayRef(AddlRegNames);
2782   }
2783   bool validateCpuSupports(StringRef Name) const override;
2784   bool validateAsmConstraint(const char *&Name,
2785                              TargetInfo::ConstraintInfo &info) const override;
2786
2787   bool validateGlobalRegisterVariable(StringRef RegName,
2788                                       unsigned RegSize,
2789                                       bool &HasSizeMismatch) const override {
2790     // esp and ebp are the only 32-bit registers the x86 backend can currently
2791     // handle.
2792     if (RegName.equals("esp") || RegName.equals("ebp")) {
2793       // Check that the register size is 32-bit.
2794       HasSizeMismatch = RegSize != 32;
2795       return true;
2796     }
2797
2798     return false;
2799   }
2800
2801   bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
2802
2803   bool validateInputSize(StringRef Constraint, unsigned Size) const override;
2804
2805   virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
2806
2807   std::string convertConstraint(const char *&Constraint) const override;
2808   const char *getClobbers() const override {
2809     return "~{dirflag},~{fpsr},~{flags}";
2810   }
2811
2812   StringRef getConstraintRegister(const StringRef &Constraint,
2813                                   const StringRef &Expression) const override {
2814     StringRef::iterator I, E;
2815     for (I = Constraint.begin(), E = Constraint.end(); I != E; ++I) {
2816       if (isalpha(*I))
2817         break;
2818     }
2819     if (I == E)
2820       return "";
2821     switch (*I) {
2822     // For the register constraints, return the matching register name
2823     case 'a':
2824       return "ax";
2825     case 'b':
2826       return "bx";
2827     case 'c':
2828       return "cx";
2829     case 'd':
2830       return "dx";
2831     case 'S':
2832       return "si";
2833     case 'D':
2834       return "di";
2835     // In case the constraint is 'r' we need to return Expression
2836     case 'r':
2837       return Expression;
2838     default:
2839       // Default value if there is no constraint for the register
2840       return "";
2841     }
2842     return "";
2843   }
2844
2845   void getTargetDefines(const LangOptions &Opts,
2846                         MacroBuilder &Builder) const override;
2847   static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
2848                           bool Enabled);
2849   static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
2850                           bool Enabled);
2851   static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2852                           bool Enabled);
2853   void setFeatureEnabled(llvm::StringMap<bool> &Features,
2854                          StringRef Name, bool Enabled) const override {
2855     setFeatureEnabledImpl(Features, Name, Enabled);
2856   }
2857   // This exists purely to cut down on the number of virtual calls in
2858   // initFeatureMap which calls this repeatedly.
2859   static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2860                                     StringRef Name, bool Enabled);
2861   bool
2862   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
2863                  StringRef CPU,
2864                  const std::vector<std::string> &FeaturesVec) const override;
2865   bool hasFeature(StringRef Feature) const override;
2866   bool handleTargetFeatures(std::vector<std::string> &Features,
2867                             DiagnosticsEngine &Diags) override;
2868   StringRef getABI() const override {
2869     if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX512F)
2870       return "avx512";
2871     if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
2872       return "avx";
2873     if (getTriple().getArch() == llvm::Triple::x86 &&
2874              MMX3DNowLevel == NoMMX3DNow)
2875       return "no-mmx";
2876     return "";
2877   }
2878   bool setCPU(const std::string &Name) override {
2879     CPU = getCPUKind(Name);
2880
2881     // Perform any per-CPU checks necessary to determine if this CPU is
2882     // acceptable.
2883     // FIXME: This results in terrible diagnostics. Clang just says the CPU is
2884     // invalid without explaining *why*.
2885     switch (CPU) {
2886     case CK_Generic:
2887       // No processor selected!
2888       return false;
2889
2890     case CK_i386:
2891     case CK_i486:
2892     case CK_WinChipC6:
2893     case CK_WinChip2:
2894     case CK_C3:
2895     case CK_i586:
2896     case CK_Pentium:
2897     case CK_PentiumMMX:
2898     case CK_i686:
2899     case CK_PentiumPro:
2900     case CK_Pentium2:
2901     case CK_Pentium3:
2902     case CK_Pentium3M:
2903     case CK_PentiumM:
2904     case CK_Yonah:
2905     case CK_C3_2:
2906     case CK_Pentium4:
2907     case CK_Pentium4M:
2908     case CK_Lakemont:
2909     case CK_Prescott:
2910     case CK_K6:
2911     case CK_K6_2:
2912     case CK_K6_3:
2913     case CK_Athlon:
2914     case CK_AthlonThunderbird:
2915     case CK_Athlon4:
2916     case CK_AthlonXP:
2917     case CK_AthlonMP:
2918     case CK_Geode:
2919       // Only accept certain architectures when compiling in 32-bit mode.
2920       if (getTriple().getArch() != llvm::Triple::x86)
2921         return false;
2922
2923       // Fallthrough
2924     case CK_Nocona:
2925     case CK_Core2:
2926     case CK_Penryn:
2927     case CK_Bonnell:
2928     case CK_Silvermont:
2929     case CK_Nehalem:
2930     case CK_Westmere:
2931     case CK_SandyBridge:
2932     case CK_IvyBridge:
2933     case CK_Haswell:
2934     case CK_Broadwell:
2935     case CK_SkylakeClient:
2936     case CK_SkylakeServer:
2937     case CK_Cannonlake:
2938     case CK_KNL:
2939     case CK_Athlon64:
2940     case CK_Athlon64SSE3:
2941     case CK_AthlonFX:
2942     case CK_K8:
2943     case CK_K8SSE3:
2944     case CK_Opteron:
2945     case CK_OpteronSSE3:
2946     case CK_AMDFAM10:
2947     case CK_BTVER1:
2948     case CK_BTVER2:
2949     case CK_BDVER1:
2950     case CK_BDVER2:
2951     case CK_BDVER3:
2952     case CK_BDVER4:
2953     case CK_ZNVER1:
2954     case CK_x86_64:
2955       return true;
2956     }
2957     llvm_unreachable("Unhandled CPU kind");
2958   }
2959
2960   bool setFPMath(StringRef Name) override;
2961
2962   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
2963     // Most of the non-ARM calling conventions are i386 conventions.
2964     switch (CC) {
2965     case CC_X86ThisCall:
2966     case CC_X86FastCall:
2967     case CC_X86StdCall:
2968     case CC_X86VectorCall:
2969     case CC_X86RegCall:
2970     case CC_C:
2971     case CC_Swift:
2972     case CC_X86Pascal:
2973     case CC_IntelOclBicc:
2974       return CCCR_OK;
2975     default:
2976       return CCCR_Warning;
2977     }
2978   }
2979
2980   CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
2981     return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
2982   }
2983
2984   bool hasSjLjLowering() const override {
2985     return true;
2986   }
2987
2988   void setSupportedOpenCLOpts() override {
2989     getSupportedOpenCLOpts().supportAll();
2990   }
2991 };
2992
2993 bool X86TargetInfo::setFPMath(StringRef Name) {
2994   if (Name == "387") {
2995     FPMath = FP_387;
2996     return true;
2997   }
2998   if (Name == "sse") {
2999     FPMath = FP_SSE;
3000     return true;
3001   }
3002   return false;
3003 }
3004
3005 bool X86TargetInfo::initFeatureMap(
3006     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
3007     const std::vector<std::string> &FeaturesVec) const {
3008   // FIXME: This *really* should not be here.
3009   // X86_64 always has SSE2.
3010   if (getTriple().getArch() == llvm::Triple::x86_64)
3011     setFeatureEnabledImpl(Features, "sse2", true);
3012
3013   const CPUKind Kind = getCPUKind(CPU);
3014
3015   // Enable X87 for all X86 processors but Lakemont.
3016   if (Kind != CK_Lakemont)
3017     setFeatureEnabledImpl(Features, "x87", true);
3018
3019   switch (Kind) {
3020   case CK_Generic:
3021   case CK_i386:
3022   case CK_i486:
3023   case CK_i586:
3024   case CK_Pentium:
3025   case CK_i686:
3026   case CK_PentiumPro:
3027   case CK_Lakemont:
3028     break;
3029   case CK_PentiumMMX:
3030   case CK_Pentium2:
3031   case CK_K6:
3032   case CK_WinChipC6:
3033     setFeatureEnabledImpl(Features, "mmx", true);
3034     break;
3035   case CK_Pentium3:
3036   case CK_Pentium3M:
3037   case CK_C3_2:
3038     setFeatureEnabledImpl(Features, "sse", true);
3039     setFeatureEnabledImpl(Features, "fxsr", true);
3040     break;
3041   case CK_PentiumM:
3042   case CK_Pentium4:
3043   case CK_Pentium4M:
3044   case CK_x86_64:
3045     setFeatureEnabledImpl(Features, "sse2", true);
3046     setFeatureEnabledImpl(Features, "fxsr", true);
3047     break;
3048   case CK_Yonah:
3049   case CK_Prescott:
3050   case CK_Nocona:
3051     setFeatureEnabledImpl(Features, "sse3", true);
3052     setFeatureEnabledImpl(Features, "fxsr", true);
3053     setFeatureEnabledImpl(Features, "cx16", true);
3054     break;
3055   case CK_Core2:
3056   case CK_Bonnell:
3057     setFeatureEnabledImpl(Features, "ssse3", true);
3058     setFeatureEnabledImpl(Features, "fxsr", true);
3059     setFeatureEnabledImpl(Features, "cx16", true);
3060     break;
3061   case CK_Penryn:
3062     setFeatureEnabledImpl(Features, "sse4.1", true);
3063     setFeatureEnabledImpl(Features, "fxsr", true);
3064     setFeatureEnabledImpl(Features, "cx16", true);
3065     break;
3066   case CK_Cannonlake:
3067     setFeatureEnabledImpl(Features, "avx512ifma", true);
3068     setFeatureEnabledImpl(Features, "avx512vbmi", true);
3069     setFeatureEnabledImpl(Features, "sha", true);
3070     setFeatureEnabledImpl(Features, "umip", true);
3071     // FALLTHROUGH
3072   case CK_SkylakeServer:
3073     setFeatureEnabledImpl(Features, "avx512f", true);
3074     setFeatureEnabledImpl(Features, "avx512cd", true);
3075     setFeatureEnabledImpl(Features, "avx512dq", true);
3076     setFeatureEnabledImpl(Features, "avx512bw", true);
3077     setFeatureEnabledImpl(Features, "avx512vl", true);
3078     setFeatureEnabledImpl(Features, "pku", true);
3079     setFeatureEnabledImpl(Features, "pcommit", true);
3080     setFeatureEnabledImpl(Features, "clwb", true);
3081     // FALLTHROUGH
3082   case CK_SkylakeClient:
3083     setFeatureEnabledImpl(Features, "xsavec", true);
3084     setFeatureEnabledImpl(Features, "xsaves", true);
3085     setFeatureEnabledImpl(Features, "mpx", true);
3086     setFeatureEnabledImpl(Features, "sgx", true);
3087     setFeatureEnabledImpl(Features, "clflushopt", true);
3088     // FALLTHROUGH
3089   case CK_Broadwell:
3090     setFeatureEnabledImpl(Features, "rdseed", true);
3091     setFeatureEnabledImpl(Features, "adx", true);
3092     // FALLTHROUGH
3093   case CK_Haswell:
3094     setFeatureEnabledImpl(Features, "avx2", true);
3095     setFeatureEnabledImpl(Features, "lzcnt", true);
3096     setFeatureEnabledImpl(Features, "bmi", true);
3097     setFeatureEnabledImpl(Features, "bmi2", true);
3098     setFeatureEnabledImpl(Features, "rtm", true);
3099     setFeatureEnabledImpl(Features, "fma", true);
3100     setFeatureEnabledImpl(Features, "movbe", true);
3101     // FALLTHROUGH
3102   case CK_IvyBridge:
3103     setFeatureEnabledImpl(Features, "rdrnd", true);
3104     setFeatureEnabledImpl(Features, "f16c", true);
3105     setFeatureEnabledImpl(Features, "fsgsbase", true);
3106     // FALLTHROUGH
3107   case CK_SandyBridge:
3108     setFeatureEnabledImpl(Features, "avx", true);
3109     setFeatureEnabledImpl(Features, "xsave", true);
3110     setFeatureEnabledImpl(Features, "xsaveopt", true);
3111     // FALLTHROUGH
3112   case CK_Westmere:
3113   case CK_Silvermont:
3114     setFeatureEnabledImpl(Features, "aes", true);
3115     setFeatureEnabledImpl(Features, "pclmul", true);
3116     // FALLTHROUGH
3117   case CK_Nehalem:
3118     setFeatureEnabledImpl(Features, "sse4.2", true);
3119     setFeatureEnabledImpl(Features, "fxsr", true);
3120     setFeatureEnabledImpl(Features, "cx16", true);
3121     break;
3122   case CK_KNL:
3123     setFeatureEnabledImpl(Features, "avx512f", true);
3124     setFeatureEnabledImpl(Features, "avx512cd", true);
3125     setFeatureEnabledImpl(Features, "avx512er", true);
3126     setFeatureEnabledImpl(Features, "avx512pf", true);
3127     setFeatureEnabledImpl(Features, "prefetchwt1", true);
3128     setFeatureEnabledImpl(Features, "fxsr", true);
3129     setFeatureEnabledImpl(Features, "rdseed", true);
3130     setFeatureEnabledImpl(Features, "adx", true);
3131     setFeatureEnabledImpl(Features, "lzcnt", true);
3132     setFeatureEnabledImpl(Features, "bmi", true);
3133     setFeatureEnabledImpl(Features, "bmi2", true);
3134     setFeatureEnabledImpl(Features, "rtm", true);
3135     setFeatureEnabledImpl(Features, "fma", true);
3136     setFeatureEnabledImpl(Features, "rdrnd", true);
3137     setFeatureEnabledImpl(Features, "f16c", true);
3138     setFeatureEnabledImpl(Features, "fsgsbase", true);
3139     setFeatureEnabledImpl(Features, "aes", true);
3140     setFeatureEnabledImpl(Features, "pclmul", true);
3141     setFeatureEnabledImpl(Features, "cx16", true);
3142     setFeatureEnabledImpl(Features, "xsaveopt", true);
3143     setFeatureEnabledImpl(Features, "xsave", true);
3144     setFeatureEnabledImpl(Features, "movbe", true);
3145     break;
3146   case CK_K6_2:
3147   case CK_K6_3:
3148   case CK_WinChip2:
3149   case CK_C3:
3150     setFeatureEnabledImpl(Features, "3dnow", true);
3151     break;
3152   case CK_Athlon:
3153   case CK_AthlonThunderbird:
3154   case CK_Geode:
3155     setFeatureEnabledImpl(Features, "3dnowa", true);
3156     break;
3157   case CK_Athlon4:
3158   case CK_AthlonXP:
3159   case CK_AthlonMP:
3160     setFeatureEnabledImpl(Features, "sse", true);
3161     setFeatureEnabledImpl(Features, "3dnowa", true);
3162     setFeatureEnabledImpl(Features, "fxsr", true);
3163     break;
3164   case CK_K8:
3165   case CK_Opteron:
3166   case CK_Athlon64:
3167   case CK_AthlonFX:
3168     setFeatureEnabledImpl(Features, "sse2", true);
3169     setFeatureEnabledImpl(Features, "3dnowa", true);
3170     setFeatureEnabledImpl(Features, "fxsr", true);
3171     break;
3172   case CK_AMDFAM10:
3173     setFeatureEnabledImpl(Features, "sse4a", true);
3174     setFeatureEnabledImpl(Features, "lzcnt", true);
3175     setFeatureEnabledImpl(Features, "popcnt", true);
3176     // FALLTHROUGH
3177   case CK_K8SSE3:
3178   case CK_OpteronSSE3:
3179   case CK_Athlon64SSE3:
3180     setFeatureEnabledImpl(Features, "sse3", true);
3181     setFeatureEnabledImpl(Features, "3dnowa", true);
3182     setFeatureEnabledImpl(Features, "fxsr", true);
3183     break;
3184   case CK_BTVER2:
3185     setFeatureEnabledImpl(Features, "avx", true);
3186     setFeatureEnabledImpl(Features, "aes", true);
3187     setFeatureEnabledImpl(Features, "pclmul", true);
3188     setFeatureEnabledImpl(Features, "bmi", true);
3189     setFeatureEnabledImpl(Features, "f16c", true);
3190     setFeatureEnabledImpl(Features, "xsaveopt", true);
3191     // FALLTHROUGH
3192   case CK_BTVER1:
3193     setFeatureEnabledImpl(Features, "ssse3", true);
3194     setFeatureEnabledImpl(Features, "sse4a", true);
3195     setFeatureEnabledImpl(Features, "lzcnt", true);
3196     setFeatureEnabledImpl(Features, "popcnt", true);
3197     setFeatureEnabledImpl(Features, "prfchw", true);
3198     setFeatureEnabledImpl(Features, "cx16", true);
3199     setFeatureEnabledImpl(Features, "fxsr", true);
3200     break;
3201   case CK_ZNVER1:
3202     setFeatureEnabledImpl(Features, "adx", true);
3203     setFeatureEnabledImpl(Features, "aes", true);
3204     setFeatureEnabledImpl(Features, "avx2", true);
3205     setFeatureEnabledImpl(Features, "bmi", true);
3206     setFeatureEnabledImpl(Features, "bmi2", true);
3207     setFeatureEnabledImpl(Features, "clflushopt", true);
3208     setFeatureEnabledImpl(Features, "cx16", true);
3209     setFeatureEnabledImpl(Features, "f16c", true);
3210     setFeatureEnabledImpl(Features, "fma", true);
3211     setFeatureEnabledImpl(Features, "fsgsbase", true);
3212     setFeatureEnabledImpl(Features, "fxsr", true);
3213     setFeatureEnabledImpl(Features, "lzcnt", true);
3214     setFeatureEnabledImpl(Features, "mwaitx", true);
3215     setFeatureEnabledImpl(Features, "movbe", true);
3216     setFeatureEnabledImpl(Features, "pclmul", true);
3217     setFeatureEnabledImpl(Features, "popcnt", true);
3218     setFeatureEnabledImpl(Features, "prfchw", true);
3219     setFeatureEnabledImpl(Features, "rdrnd", true);
3220     setFeatureEnabledImpl(Features, "rdseed", true);
3221     setFeatureEnabledImpl(Features, "sha", true);
3222     setFeatureEnabledImpl(Features, "sse4a", true);
3223     setFeatureEnabledImpl(Features, "xsave", true);
3224     setFeatureEnabledImpl(Features, "xsavec", true);
3225     setFeatureEnabledImpl(Features, "xsaveopt", true);
3226     setFeatureEnabledImpl(Features, "xsaves", true);
3227     break;
3228   case CK_BDVER4:
3229     setFeatureEnabledImpl(Features, "avx2", true);
3230     setFeatureEnabledImpl(Features, "bmi2", true);
3231     setFeatureEnabledImpl(Features, "mwaitx", true);
3232     // FALLTHROUGH
3233   case CK_BDVER3:
3234     setFeatureEnabledImpl(Features, "fsgsbase", true);
3235     setFeatureEnabledImpl(Features, "xsaveopt", true);
3236     // FALLTHROUGH
3237   case CK_BDVER2:
3238     setFeatureEnabledImpl(Features, "bmi", true);
3239     setFeatureEnabledImpl(Features, "fma", true);
3240     setFeatureEnabledImpl(Features, "f16c", true);
3241     setFeatureEnabledImpl(Features, "tbm", true);
3242     // FALLTHROUGH
3243   case CK_BDVER1:
3244     // xop implies avx, sse4a and fma4.
3245     setFeatureEnabledImpl(Features, "xop", true);
3246     setFeatureEnabledImpl(Features, "lzcnt", true);
3247     setFeatureEnabledImpl(Features, "aes", true);
3248     setFeatureEnabledImpl(Features, "pclmul", true);
3249     setFeatureEnabledImpl(Features, "prfchw", true);
3250     setFeatureEnabledImpl(Features, "cx16", true);
3251     setFeatureEnabledImpl(Features, "fxsr", true);
3252     setFeatureEnabledImpl(Features, "xsave", true);
3253     break;
3254   }
3255   if (!TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec))
3256     return false;
3257
3258   // Can't do this earlier because we need to be able to explicitly enable
3259   // or disable these features and the things that they depend upon.
3260
3261   // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
3262   auto I = Features.find("sse4.2");
3263   if (I != Features.end() && I->getValue() &&
3264       std::find(FeaturesVec.begin(), FeaturesVec.end(), "-popcnt") ==
3265           FeaturesVec.end())
3266     Features["popcnt"] = true;
3267
3268   // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
3269   I = Features.find("3dnow");
3270   if (I != Features.end() && I->getValue() &&
3271       std::find(FeaturesVec.begin(), FeaturesVec.end(), "-prfchw") ==
3272           FeaturesVec.end())
3273     Features["prfchw"] = true;
3274
3275   // Additionally, if SSE is enabled and mmx is not explicitly disabled,
3276   // then enable MMX.
3277   I = Features.find("sse");
3278   if (I != Features.end() && I->getValue() &&
3279       std::find(FeaturesVec.begin(), FeaturesVec.end(), "-mmx") ==
3280           FeaturesVec.end())
3281     Features["mmx"] = true;
3282
3283   return true;
3284 }
3285
3286 void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
3287                                 X86SSEEnum Level, bool Enabled) {
3288   if (Enabled) {
3289     switch (Level) {
3290     case AVX512F:
3291       Features["avx512f"] = true;
3292     case AVX2:
3293       Features["avx2"] = true;
3294     case AVX:
3295       Features["avx"] = true;
3296       Features["xsave"] = true;
3297     case SSE42:
3298       Features["sse4.2"] = true;
3299     case SSE41:
3300       Features["sse4.1"] = true;
3301     case SSSE3:
3302       Features["ssse3"] = true;
3303     case SSE3:
3304       Features["sse3"] = true;
3305     case SSE2:
3306       Features["sse2"] = true;
3307     case SSE1:
3308       Features["sse"] = true;
3309     case NoSSE:
3310       break;
3311     }
3312     return;
3313   }
3314
3315   switch (Level) {
3316   case NoSSE:
3317   case SSE1:
3318     Features["sse"] = false;
3319   case SSE2:
3320     Features["sse2"] = Features["pclmul"] = Features["aes"] =
3321       Features["sha"] = false;
3322   case SSE3:
3323     Features["sse3"] = false;
3324     setXOPLevel(Features, NoXOP, false);
3325   case SSSE3:
3326     Features["ssse3"] = false;
3327   case SSE41:
3328     Features["sse4.1"] = false;
3329   case SSE42:
3330     Features["sse4.2"] = false;
3331   case AVX:
3332     Features["fma"] = Features["avx"] = Features["f16c"] = Features["xsave"] =
3333       Features["xsaveopt"] = false;
3334     setXOPLevel(Features, FMA4, false);
3335   case AVX2:
3336     Features["avx2"] = false;
3337   case AVX512F:
3338     Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
3339       Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] =
3340       Features["avx512vl"] = Features["avx512vbmi"] =
3341       Features["avx512ifma"] = false;
3342   }
3343 }
3344
3345 void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
3346                                 MMX3DNowEnum Level, bool Enabled) {
3347   if (Enabled) {
3348     switch (Level) {
3349     case AMD3DNowAthlon:
3350       Features["3dnowa"] = true;
3351     case AMD3DNow:
3352       Features["3dnow"] = true;
3353     case MMX:
3354       Features["mmx"] = true;
3355     case NoMMX3DNow:
3356       break;
3357     }
3358     return;
3359   }
3360
3361   switch (Level) {
3362   case NoMMX3DNow:
3363   case MMX:
3364     Features["mmx"] = false;
3365   case AMD3DNow:
3366     Features["3dnow"] = false;
3367   case AMD3DNowAthlon:
3368     Features["3dnowa"] = false;
3369   }
3370 }
3371
3372 void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
3373                                 bool Enabled) {
3374   if (Enabled) {
3375     switch (Level) {
3376     case XOP:
3377       Features["xop"] = true;
3378     case FMA4:
3379       Features["fma4"] = true;
3380       setSSELevel(Features, AVX, true);
3381     case SSE4A:
3382       Features["sse4a"] = true;
3383       setSSELevel(Features, SSE3, true);
3384     case NoXOP:
3385       break;
3386     }
3387     return;
3388   }
3389
3390   switch (Level) {
3391   case NoXOP:
3392   case SSE4A:
3393     Features["sse4a"] = false;
3394   case FMA4:
3395     Features["fma4"] = false;
3396   case XOP:
3397     Features["xop"] = false;
3398   }
3399 }
3400
3401 void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
3402                                           StringRef Name, bool Enabled) {
3403   // This is a bit of a hack to deal with the sse4 target feature when used
3404   // as part of the target attribute. We handle sse4 correctly everywhere
3405   // else. See below for more information on how we handle the sse4 options.
3406   if (Name != "sse4")
3407     Features[Name] = Enabled;
3408
3409   if (Name == "mmx") {
3410     setMMXLevel(Features, MMX, Enabled);
3411   } else if (Name == "sse") {
3412     setSSELevel(Features, SSE1, Enabled);
3413   } else if (Name == "sse2") {
3414     setSSELevel(Features, SSE2, Enabled);
3415   } else if (Name == "sse3") {
3416     setSSELevel(Features, SSE3, Enabled);
3417   } else if (Name == "ssse3") {
3418     setSSELevel(Features, SSSE3, Enabled);
3419   } else if (Name == "sse4.2") {
3420     setSSELevel(Features, SSE42, Enabled);
3421   } else if (Name == "sse4.1") {
3422     setSSELevel(Features, SSE41, Enabled);
3423   } else if (Name == "3dnow") {
3424     setMMXLevel(Features, AMD3DNow, Enabled);
3425   } else if (Name == "3dnowa") {
3426     setMMXLevel(Features, AMD3DNowAthlon, Enabled);
3427   } else if (Name == "aes") {
3428     if (Enabled)
3429       setSSELevel(Features, SSE2, Enabled);
3430   } else if (Name == "pclmul") {
3431     if (Enabled)
3432       setSSELevel(Features, SSE2, Enabled);
3433   } else if (Name == "avx") {
3434     setSSELevel(Features, AVX, Enabled);
3435   } else if (Name == "avx2") {
3436     setSSELevel(Features, AVX2, Enabled);
3437   } else if (Name == "avx512f") {
3438     setSSELevel(Features, AVX512F, Enabled);
3439   } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf" ||
3440              Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl" ||
3441              Name == "avx512vbmi" || Name == "avx512ifma") {
3442     if (Enabled)
3443       setSSELevel(Features, AVX512F, Enabled);
3444     // Enable BWI instruction if VBMI is being enabled.
3445     if (Name == "avx512vbmi" && Enabled)
3446       Features["avx512bw"] = true;
3447     // Also disable VBMI if BWI is being disabled.
3448     if (Name == "avx512bw" && !Enabled)
3449       Features["avx512vbmi"] = false;
3450   } else if (Name == "fma") {
3451     if (Enabled)
3452       setSSELevel(Features, AVX, Enabled);
3453   } else if (Name == "fma4") {
3454     setXOPLevel(Features, FMA4, Enabled);
3455   } else if (Name == "xop") {
3456     setXOPLevel(Features, XOP, Enabled);
3457   } else if (Name == "sse4a") {
3458     setXOPLevel(Features, SSE4A, Enabled);
3459   } else if (Name == "f16c") {
3460     if (Enabled)
3461       setSSELevel(Features, AVX, Enabled);
3462   } else if (Name == "sha") {
3463     if (Enabled)
3464       setSSELevel(Features, SSE2, Enabled);
3465   } else if (Name == "sse4") {
3466     // We can get here via the __target__ attribute since that's not controlled
3467     // via the -msse4/-mno-sse4 command line alias. Handle this the same way
3468     // here - turn on the sse4.2 if enabled, turn off the sse4.1 level if
3469     // disabled.
3470     if (Enabled)
3471       setSSELevel(Features, SSE42, Enabled);
3472     else
3473       setSSELevel(Features, SSE41, Enabled);
3474   } else if (Name == "xsave") {
3475     if (!Enabled)
3476       Features["xsaveopt"] = false;
3477   } else if (Name == "xsaveopt" || Name == "xsavec" || Name == "xsaves") {
3478     if (Enabled)
3479       Features["xsave"] = true;
3480   }
3481 }
3482
3483 /// handleTargetFeatures - Perform initialization based on the user
3484 /// configured set of features.
3485 bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
3486                                          DiagnosticsEngine &Diags) {
3487   for (const auto &Feature : Features) {
3488     if (Feature[0] != '+')
3489       continue;
3490
3491     if (Feature == "+aes") {
3492       HasAES = true;
3493     } else if (Feature == "+pclmul") {
3494       HasPCLMUL = true;
3495     } else if (Feature == "+lzcnt") {
3496       HasLZCNT = true;
3497     } else if (Feature == "+rdrnd") {
3498       HasRDRND = true;
3499     } else if (Feature == "+fsgsbase") {
3500       HasFSGSBASE = true;
3501     } else if (Feature == "+bmi") {
3502       HasBMI = true;
3503     } else if (Feature == "+bmi2") {
3504       HasBMI2 = true;
3505     } else if (Feature == "+popcnt") {
3506       HasPOPCNT = true;
3507     } else if (Feature == "+rtm") {
3508       HasRTM = true;
3509     } else if (Feature == "+prfchw") {
3510       HasPRFCHW = true;
3511     } else if (Feature == "+rdseed") {
3512       HasRDSEED = true;
3513     } else if (Feature == "+adx") {
3514       HasADX = true;
3515     } else if (Feature == "+tbm") {
3516       HasTBM = true;
3517     } else if (Feature == "+fma") {
3518       HasFMA = true;
3519     } else if (Feature == "+f16c") {
3520       HasF16C = true;
3521     } else if (Feature == "+avx512cd") {
3522       HasAVX512CD = true;
3523     } else if (Feature == "+avx512er") {
3524       HasAVX512ER = true;
3525     } else if (Feature == "+avx512pf") {
3526       HasAVX512PF = true;
3527     } else if (Feature == "+avx512dq") {
3528       HasAVX512DQ = true;
3529     } else if (Feature == "+avx512bw") {
3530       HasAVX512BW = true;
3531     } else if (Feature == "+avx512vl") {
3532       HasAVX512VL = true;
3533     } else if (Feature == "+avx512vbmi") {
3534       HasAVX512VBMI = true;
3535     } else if (Feature == "+avx512ifma") {
3536       HasAVX512IFMA = true;
3537     } else if (Feature == "+sha") {
3538       HasSHA = true;
3539     } else if (Feature == "+mpx") {
3540       HasMPX = true;
3541     } else if (Feature == "+movbe") {
3542       HasMOVBE = true;
3543     } else if (Feature == "+sgx") {
3544       HasSGX = true;
3545     } else if (Feature == "+cx16") {
3546       HasCX16 = true;
3547     } else if (Feature == "+fxsr") {
3548       HasFXSR = true;
3549     } else if (Feature == "+xsave") {
3550       HasXSAVE = true;
3551     } else if (Feature == "+xsaveopt") {
3552       HasXSAVEOPT = true;
3553     } else if (Feature == "+xsavec") {
3554       HasXSAVEC = true;
3555     } else if (Feature == "+xsaves") {
3556       HasXSAVES = true;
3557     } else if (Feature == "+mwaitx") {
3558       HasMWAITX = true;
3559     } else if (Feature == "+pku") {
3560       HasPKU = true;
3561     } else if (Feature == "+clflushopt") {
3562       HasCLFLUSHOPT = true;
3563     } else if (Feature == "+pcommit") {
3564       HasPCOMMIT = true;
3565     } else if (Feature == "+clwb") {
3566       HasCLWB = true;
3567     } else if (Feature == "+umip") {
3568       HasUMIP = true;
3569     } else if (Feature == "+prefetchwt1") {
3570       HasPREFETCHWT1 = true;
3571     }
3572
3573     X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
3574       .Case("+avx512f", AVX512F)
3575       .Case("+avx2", AVX2)
3576       .Case("+avx", AVX)
3577       .Case("+sse4.2", SSE42)
3578       .Case("+sse4.1", SSE41)
3579       .Case("+ssse3", SSSE3)
3580       .Case("+sse3", SSE3)
3581       .Case("+sse2", SSE2)
3582       .Case("+sse", SSE1)
3583       .Default(NoSSE);
3584     SSELevel = std::max(SSELevel, Level);
3585
3586     MMX3DNowEnum ThreeDNowLevel =
3587       llvm::StringSwitch<MMX3DNowEnum>(Feature)
3588         .Case("+3dnowa", AMD3DNowAthlon)
3589         .Case("+3dnow", AMD3DNow)
3590         .Case("+mmx", MMX)
3591         .Default(NoMMX3DNow);
3592     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
3593
3594     XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
3595         .Case("+xop", XOP)
3596         .Case("+fma4", FMA4)
3597         .Case("+sse4a", SSE4A)
3598         .Default(NoXOP);
3599     XOPLevel = std::max(XOPLevel, XLevel);
3600   }
3601
3602   // LLVM doesn't have a separate switch for fpmath, so only accept it if it
3603   // matches the selected sse level.
3604   if ((FPMath == FP_SSE && SSELevel < SSE1) ||
3605       (FPMath == FP_387 && SSELevel >= SSE1)) {
3606     Diags.Report(diag::err_target_unsupported_fpmath) <<
3607       (FPMath == FP_SSE ? "sse" : "387");
3608     return false;
3609   }
3610
3611   SimdDefaultAlign =
3612       hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
3613   return true;
3614 }
3615
3616 /// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
3617 /// definitions for this particular subtarget.
3618 void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
3619                                      MacroBuilder &Builder) const {
3620   // Target identification.
3621   if (getTriple().getArch() == llvm::Triple::x86_64) {
3622     Builder.defineMacro("__amd64__");
3623     Builder.defineMacro("__amd64");
3624     Builder.defineMacro("__x86_64");
3625     Builder.defineMacro("__x86_64__");
3626     if (getTriple().getArchName() == "x86_64h") {
3627       Builder.defineMacro("__x86_64h");
3628       Builder.defineMacro("__x86_64h__");
3629     }
3630   } else {
3631     DefineStd(Builder, "i386", Opts);
3632   }
3633
3634   // Subtarget options.
3635   // FIXME: We are hard-coding the tune parameters based on the CPU, but they
3636   // truly should be based on -mtune options.
3637   switch (CPU) {
3638   case CK_Generic:
3639     break;
3640   case CK_i386:
3641     // The rest are coming from the i386 define above.
3642     Builder.defineMacro("__tune_i386__");
3643     break;
3644   case CK_i486:
3645   case CK_WinChipC6:
3646   case CK_WinChip2:
3647   case CK_C3:
3648     defineCPUMacros(Builder, "i486");
3649     break;
3650   case CK_PentiumMMX:
3651     Builder.defineMacro("__pentium_mmx__");
3652     Builder.defineMacro("__tune_pentium_mmx__");
3653     // Fallthrough
3654   case CK_i586:
3655   case CK_Pentium:
3656     defineCPUMacros(Builder, "i586");
3657     defineCPUMacros(Builder, "pentium");
3658     break;
3659   case CK_Pentium3:
3660   case CK_Pentium3M:
3661   case CK_PentiumM:
3662     Builder.defineMacro("__tune_pentium3__");
3663     // Fallthrough
3664   case CK_Pentium2:
3665   case CK_C3_2:
3666     Builder.defineMacro("__tune_pentium2__");
3667     // Fallthrough
3668   case CK_PentiumPro:
3669     Builder.defineMacro("__tune_i686__");
3670     Builder.defineMacro("__tune_pentiumpro__");
3671     // Fallthrough
3672   case CK_i686:
3673     Builder.defineMacro("__i686");
3674     Builder.defineMacro("__i686__");
3675     // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
3676     Builder.defineMacro("__pentiumpro");
3677     Builder.defineMacro("__pentiumpro__");
3678     break;
3679   case CK_Pentium4:
3680   case CK_Pentium4M:
3681     defineCPUMacros(Builder, "pentium4");
3682     break;
3683   case CK_Yonah:
3684   case CK_Prescott:
3685   case CK_Nocona:
3686     defineCPUMacros(Builder, "nocona");
3687     break;
3688   case CK_Core2:
3689   case CK_Penryn:
3690     defineCPUMacros(Builder, "core2");
3691     break;
3692   case CK_Bonnell:
3693     defineCPUMacros(Builder, "atom");
3694     break;
3695   case CK_Silvermont:
3696     defineCPUMacros(Builder, "slm");
3697     break;
3698   case CK_Nehalem:
3699   case CK_Westmere:
3700   case CK_SandyBridge:
3701   case CK_IvyBridge:
3702   case CK_Haswell:
3703   case CK_Broadwell:
3704   case CK_SkylakeClient:
3705     // FIXME: Historically, we defined this legacy name, it would be nice to
3706     // remove it at some point. We've never exposed fine-grained names for
3707     // recent primary x86 CPUs, and we should keep it that way.
3708     defineCPUMacros(Builder, "corei7");
3709     break;
3710   case CK_SkylakeServer:
3711     defineCPUMacros(Builder, "skx");
3712     break;
3713   case CK_Cannonlake:
3714     break;
3715   case CK_KNL:
3716     defineCPUMacros(Builder, "knl");
3717     break;
3718   case CK_Lakemont:
3719     Builder.defineMacro("__tune_lakemont__");
3720     break;
3721   case CK_K6_2:
3722     Builder.defineMacro("__k6_2__");
3723     Builder.defineMacro("__tune_k6_2__");
3724     // Fallthrough
3725   case CK_K6_3:
3726     if (CPU != CK_K6_2) {  // In case of fallthrough
3727       // FIXME: GCC may be enabling these in cases where some other k6
3728       // architecture is specified but -m3dnow is explicitly provided. The
3729       // exact semantics need to be determined and emulated here.
3730       Builder.defineMacro("__k6_3__");
3731       Builder.defineMacro("__tune_k6_3__");
3732     }
3733     // Fallthrough
3734   case CK_K6:
3735     defineCPUMacros(Builder, "k6");
3736     break;
3737   case CK_Athlon:
3738   case CK_AthlonThunderbird:
3739   case CK_Athlon4:
3740   case CK_AthlonXP:
3741   case CK_AthlonMP:
3742     defineCPUMacros(Builder, "athlon");
3743     if (SSELevel != NoSSE) {
3744       Builder.defineMacro("__athlon_sse__");
3745       Builder.defineMacro("__tune_athlon_sse__");
3746     }
3747     break;
3748   case CK_K8:
3749   case CK_K8SSE3:
3750   case CK_x86_64:
3751   case CK_Opteron:
3752   case CK_OpteronSSE3:
3753   case CK_Athlon64:
3754   case CK_Athlon64SSE3:
3755   case CK_AthlonFX:
3756     defineCPUMacros(Builder, "k8");
3757     break;
3758   case CK_AMDFAM10:
3759     defineCPUMacros(Builder, "amdfam10");
3760     break;
3761   case CK_BTVER1:
3762     defineCPUMacros(Builder, "btver1");
3763     break;
3764   case CK_BTVER2:
3765     defineCPUMacros(Builder, "btver2");
3766     break;
3767   case CK_BDVER1:
3768     defineCPUMacros(Builder, "bdver1");
3769     break;
3770   case CK_BDVER2:
3771     defineCPUMacros(Builder, "bdver2");
3772     break;
3773   case CK_BDVER3:
3774     defineCPUMacros(Builder, "bdver3");
3775     break;
3776   case CK_BDVER4:
3777     defineCPUMacros(Builder, "bdver4");
3778     break;
3779   case CK_ZNVER1:
3780     defineCPUMacros(Builder, "znver1");
3781     break;
3782   case CK_Geode:
3783     defineCPUMacros(Builder, "geode");
3784     break;
3785   }
3786
3787   // Target properties.
3788   Builder.defineMacro("__REGISTER_PREFIX__", "");
3789
3790   // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
3791   // functions in glibc header files that use FP Stack inline asm which the
3792   // backend can't deal with (PR879).
3793   Builder.defineMacro("__NO_MATH_INLINES");
3794
3795   if (HasAES)
3796     Builder.defineMacro("__AES__");
3797
3798   if (HasPCLMUL)
3799     Builder.defineMacro("__PCLMUL__");
3800
3801   if (HasLZCNT)
3802     Builder.defineMacro("__LZCNT__");
3803
3804   if (HasRDRND)
3805     Builder.defineMacro("__RDRND__");
3806
3807   if (HasFSGSBASE)
3808     Builder.defineMacro("__FSGSBASE__");
3809
3810   if (HasBMI)
3811     Builder.defineMacro("__BMI__");
3812
3813   if (HasBMI2)
3814     Builder.defineMacro("__BMI2__");
3815
3816   if (HasPOPCNT)
3817     Builder.defineMacro("__POPCNT__");
3818
3819   if (HasRTM)
3820     Builder.defineMacro("__RTM__");
3821
3822   if (HasPRFCHW)
3823     Builder.defineMacro("__PRFCHW__");
3824
3825   if (HasRDSEED)
3826     Builder.defineMacro("__RDSEED__");
3827
3828   if (HasADX)
3829     Builder.defineMacro("__ADX__");
3830
3831   if (HasTBM)
3832     Builder.defineMacro("__TBM__");
3833
3834   if (HasMWAITX)
3835     Builder.defineMacro("__MWAITX__");
3836
3837   switch (XOPLevel) {
3838   case XOP:
3839     Builder.defineMacro("__XOP__");
3840   case FMA4:
3841     Builder.defineMacro("__FMA4__");
3842   case SSE4A:
3843     Builder.defineMacro("__SSE4A__");
3844   case NoXOP:
3845     break;
3846   }
3847
3848   if (HasFMA)
3849     Builder.defineMacro("__FMA__");
3850
3851   if (HasF16C)
3852     Builder.defineMacro("__F16C__");
3853
3854   if (HasAVX512CD)
3855     Builder.defineMacro("__AVX512CD__");
3856   if (HasAVX512ER)
3857     Builder.defineMacro("__AVX512ER__");
3858   if (HasAVX512PF)
3859     Builder.defineMacro("__AVX512PF__");
3860   if (HasAVX512DQ)
3861     Builder.defineMacro("__AVX512DQ__");
3862   if (HasAVX512BW)
3863     Builder.defineMacro("__AVX512BW__");
3864   if (HasAVX512VL)
3865     Builder.defineMacro("__AVX512VL__");
3866   if (HasAVX512VBMI)
3867     Builder.defineMacro("__AVX512VBMI__");
3868   if (HasAVX512IFMA)
3869     Builder.defineMacro("__AVX512IFMA__");
3870
3871   if (HasSHA)
3872     Builder.defineMacro("__SHA__");
3873
3874   if (HasFXSR)
3875     Builder.defineMacro("__FXSR__");
3876   if (HasXSAVE)
3877     Builder.defineMacro("__XSAVE__");
3878   if (HasXSAVEOPT)
3879     Builder.defineMacro("__XSAVEOPT__");
3880   if (HasXSAVEC)
3881     Builder.defineMacro("__XSAVEC__");
3882   if (HasXSAVES)
3883     Builder.defineMacro("__XSAVES__");
3884   if (HasPKU)
3885     Builder.defineMacro("__PKU__");
3886   if (HasCX16)
3887     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
3888
3889   // Each case falls through to the previous one here.
3890   switch (SSELevel) {
3891   case AVX512F:
3892     Builder.defineMacro("__AVX512F__");
3893   case AVX2:
3894     Builder.defineMacro("__AVX2__");
3895   case AVX:
3896     Builder.defineMacro("__AVX__");
3897   case SSE42:
3898     Builder.defineMacro("__SSE4_2__");
3899   case SSE41:
3900     Builder.defineMacro("__SSE4_1__");
3901   case SSSE3:
3902     Builder.defineMacro("__SSSE3__");
3903   case SSE3:
3904     Builder.defineMacro("__SSE3__");
3905   case SSE2:
3906     Builder.defineMacro("__SSE2__");
3907     Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
3908   case SSE1:
3909     Builder.defineMacro("__SSE__");
3910     Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
3911   case NoSSE:
3912     break;
3913   }
3914
3915   if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
3916     switch (SSELevel) {
3917     case AVX512F:
3918     case AVX2:
3919     case AVX:
3920     case SSE42:
3921     case SSE41:
3922     case SSSE3:
3923     case SSE3:
3924     case SSE2:
3925       Builder.defineMacro("_M_IX86_FP", Twine(2));
3926       break;
3927     case SSE1:
3928       Builder.defineMacro("_M_IX86_FP", Twine(1));
3929       break;
3930     default:
3931       Builder.defineMacro("_M_IX86_FP", Twine(0));
3932     }
3933   }
3934
3935   // Each case falls through to the previous one here.
3936   switch (MMX3DNowLevel) {
3937   case AMD3DNowAthlon:
3938     Builder.defineMacro("__3dNOW_A__");
3939   case AMD3DNow:
3940     Builder.defineMacro("__3dNOW__");
3941   case MMX:
3942     Builder.defineMacro("__MMX__");
3943   case NoMMX3DNow:
3944     break;
3945   }
3946
3947   if (CPU >= CK_i486) {
3948     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3949     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3950     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3951   }
3952   if (CPU >= CK_i586)
3953     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
3954 }
3955
3956 bool X86TargetInfo::hasFeature(StringRef Feature) const {
3957   return llvm::StringSwitch<bool>(Feature)
3958       .Case("aes", HasAES)
3959       .Case("avx", SSELevel >= AVX)
3960       .Case("avx2", SSELevel >= AVX2)
3961       .Case("avx512f", SSELevel >= AVX512F)
3962       .Case("avx512cd", HasAVX512CD)
3963       .Case("avx512er", HasAVX512ER)
3964       .Case("avx512pf", HasAVX512PF)
3965       .Case("avx512dq", HasAVX512DQ)
3966       .Case("avx512bw", HasAVX512BW)
3967       .Case("avx512vl", HasAVX512VL)
3968       .Case("avx512vbmi", HasAVX512VBMI)
3969       .Case("avx512ifma", HasAVX512IFMA)
3970       .Case("bmi", HasBMI)
3971       .Case("bmi2", HasBMI2)
3972       .Case("clflushopt", HasCLFLUSHOPT)
3973       .Case("clwb", HasCLWB)
3974       .Case("cx16", HasCX16)
3975       .Case("f16c", HasF16C)
3976       .Case("fma", HasFMA)
3977       .Case("fma4", XOPLevel >= FMA4)
3978       .Case("fsgsbase", HasFSGSBASE)
3979       .Case("fxsr", HasFXSR)
3980       .Case("lzcnt", HasLZCNT)
3981       .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
3982       .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3983       .Case("mmx", MMX3DNowLevel >= MMX)
3984       .Case("movbe", HasMOVBE)
3985       .Case("mpx", HasMPX)
3986       .Case("pclmul", HasPCLMUL)
3987       .Case("pcommit", HasPCOMMIT)
3988       .Case("pku", HasPKU)
3989       .Case("popcnt", HasPOPCNT)
3990       .Case("prefetchwt1", HasPREFETCHWT1)
3991       .Case("prfchw", HasPRFCHW)
3992       .Case("rdrnd", HasRDRND)
3993       .Case("rdseed", HasRDSEED)
3994       .Case("rtm", HasRTM)
3995       .Case("sgx", HasSGX)
3996       .Case("sha", HasSHA)
3997       .Case("sse", SSELevel >= SSE1)
3998       .Case("sse2", SSELevel >= SSE2)
3999       .Case("sse3", SSELevel >= SSE3)
4000       .Case("ssse3", SSELevel >= SSSE3)
4001       .Case("sse4.1", SSELevel >= SSE41)
4002       .Case("sse4.2", SSELevel >= SSE42)
4003       .Case("sse4a", XOPLevel >= SSE4A)
4004       .Case("tbm", HasTBM)
4005       .Case("umip", HasUMIP)
4006       .Case("x86", true)
4007       .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
4008       .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
4009       .Case("xop", XOPLevel >= XOP)
4010       .Case("xsave", HasXSAVE)
4011       .Case("xsavec", HasXSAVEC)
4012       .Case("xsaves", HasXSAVES)
4013       .Case("xsaveopt", HasXSAVEOPT)
4014       .Default(false);
4015 }
4016
4017 // We can't use a generic validation scheme for the features accepted here
4018 // versus subtarget features accepted in the target attribute because the
4019 // bitfield structure that's initialized in the runtime only supports the
4020 // below currently rather than the full range of subtarget features. (See
4021 // X86TargetInfo::hasFeature for a somewhat comprehensive list).
4022 bool X86TargetInfo::validateCpuSupports(StringRef FeatureStr) const {
4023   return llvm::StringSwitch<bool>(FeatureStr)
4024       .Case("cmov", true)
4025       .Case("mmx", true)
4026       .Case("popcnt", true)
4027       .Case("sse", true)
4028       .Case("sse2", true)
4029       .Case("sse3", true)
4030       .Case("ssse3", true)
4031       .Case("sse4.1", true)
4032       .Case("sse4.2", true)
4033       .Case("avx", true)
4034       .Case("avx2", true)
4035       .Case("sse4a", true)
4036       .Case("fma4", true)
4037       .Case("xop", true)
4038       .Case("fma", true)
4039       .Case("avx512f", true)
4040       .Case("bmi", true)
4041       .Case("bmi2", true)
4042       .Case("aes", true)
4043       .Case("pclmul", true)
4044       .Case("avx512vl", true)
4045       .Case("avx512bw", true)
4046       .Case("avx512dq", true)
4047       .Case("avx512cd", true)
4048       .Case("avx512er", true)
4049       .Case("avx512pf", true)
4050       .Case("avx512vbmi", true)
4051       .Case("avx512ifma", true)
4052       .Default(false);
4053 }
4054
4055 bool
4056 X86TargetInfo::validateAsmConstraint(const char *&Name,
4057                                      TargetInfo::ConstraintInfo &Info) const {
4058   switch (*Name) {
4059   default: return false;
4060   // Constant constraints.
4061   case 'e': // 32-bit signed integer constant for use with sign-extending x86_64
4062             // instructions.
4063   case 'Z': // 32-bit unsigned integer constant for use with zero-extending
4064             // x86_64 instructions.
4065   case 's':
4066     Info.setRequiresImmediate();
4067     return true;
4068   case 'I':
4069     Info.setRequiresImmediate(0, 31);
4070     return true;
4071   case 'J':
4072     Info.setRequiresImmediate(0, 63);
4073     return true;
4074   case 'K':
4075     Info.setRequiresImmediate(-128, 127);
4076     return true;
4077   case 'L':
4078     Info.setRequiresImmediate({ int(0xff), int(0xffff), int(0xffffffff) });
4079     return true;
4080   case 'M':
4081     Info.setRequiresImmediate(0, 3);
4082     return true;
4083   case 'N':
4084     Info.setRequiresImmediate(0, 255);
4085     return true;
4086   case 'O':
4087     Info.setRequiresImmediate(0, 127);
4088     return true;
4089   // Register constraints.
4090   case 'Y': // 'Y' is the first character for several 2-character constraints.
4091     // Shift the pointer to the second character of the constraint.
4092     Name++;
4093     switch (*Name) {
4094     default:
4095       return false;
4096     case '0': // First SSE register.
4097     case 't': // Any SSE register, when SSE2 is enabled.
4098     case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
4099     case 'm': // Any MMX register, when inter-unit moves enabled.
4100     case 'k': // AVX512 arch mask registers: k1-k7.
4101       Info.setAllowsRegister();
4102       return true;
4103     }
4104   case 'f': // Any x87 floating point stack register.
4105     // Constraint 'f' cannot be used for output operands.
4106     if (Info.ConstraintStr[0] == '=')
4107       return false;
4108     Info.setAllowsRegister();
4109     return true;
4110   case 'a': // eax.
4111   case 'b': // ebx.
4112   case 'c': // ecx.
4113   case 'd': // edx.
4114   case 'S': // esi.
4115   case 'D': // edi.
4116   case 'A': // edx:eax.
4117   case 't': // Top of floating point stack.
4118   case 'u': // Second from top of floating point stack.
4119   case 'q': // Any register accessible as [r]l: a, b, c, and d.
4120   case 'y': // Any MMX register.
4121   case 'v': // Any {X,Y,Z}MM register (Arch & context dependent)
4122   case 'x': // Any SSE register.
4123   case 'k': // Any AVX512 mask register (same as Yk, additionaly allows k0
4124             // for intermideate k reg operations).
4125   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
4126   case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
4127   case 'l': // "Index" registers: any general register that can be used as an
4128             // index in a base+index memory access.
4129     Info.setAllowsRegister();
4130     return true;
4131   // Floating point constant constraints.
4132   case 'C': // SSE floating point constant.
4133   case 'G': // x87 floating point constant.
4134     return true;
4135   }
4136 }
4137
4138 bool X86TargetInfo::validateOutputSize(StringRef Constraint,
4139                                        unsigned Size) const {
4140   // Strip off constraint modifiers.
4141   while (Constraint[0] == '=' ||
4142          Constraint[0] == '+' ||
4143          Constraint[0] == '&')
4144     Constraint = Constraint.substr(1);
4145
4146   return validateOperandSize(Constraint, Size);
4147 }
4148
4149 bool X86TargetInfo::validateInputSize(StringRef Constraint,
4150                                       unsigned Size) const {
4151   return validateOperandSize(Constraint, Size);
4152 }
4153
4154 bool X86TargetInfo::validateOperandSize(StringRef Constraint,
4155                                         unsigned Size) const {
4156   switch (Constraint[0]) {
4157   default: break;
4158   case 'k':
4159   // Registers k0-k7 (AVX512) size limit is 64 bit.
4160   case 'y':
4161     return Size <= 64;
4162   case 'f':
4163   case 't':
4164   case 'u':
4165     return Size <= 128;
4166   case 'v':
4167   case 'x':
4168     if (SSELevel >= AVX512F)
4169       // 512-bit zmm registers can be used if target supports AVX512F.
4170       return Size <= 512U;
4171     else if (SSELevel >= AVX)
4172       // 256-bit ymm registers can be used if target supports AVX.
4173       return Size <= 256U;
4174     return Size <= 128U;
4175   case 'Y':
4176     // 'Y' is the first character for several 2-character constraints.
4177     switch (Constraint[1]) {
4178     default: break;
4179     case 'm':
4180       // 'Ym' is synonymous with 'y'.
4181     case 'k':
4182       return Size <= 64;
4183     case 'i':
4184     case 't':
4185       // 'Yi' and 'Yt' are synonymous with 'x' when SSE2 is enabled.
4186       if (SSELevel >= AVX512F)
4187         return Size <= 512U;
4188       else if (SSELevel >= AVX)
4189         return Size <= 256U;
4190       return SSELevel >= SSE2 && Size <= 128U;
4191     }
4192
4193   }
4194
4195   return true;
4196 }
4197
4198 std::string
4199 X86TargetInfo::convertConstraint(const char *&Constraint) const {
4200   switch (*Constraint) {
4201   case 'a': return std::string("{ax}");
4202   case 'b': return std::string("{bx}");
4203   case 'c': return std::string("{cx}");
4204   case 'd': return std::string("{dx}");
4205   case 'S': return std::string("{si}");
4206   case 'D': return std::string("{di}");
4207   case 'p': // address
4208     return std::string("im");
4209   case 't': // top of floating point stack.
4210     return std::string("{st}");
4211   case 'u': // second from top of floating point stack.
4212     return std::string("{st(1)}"); // second from top of floating point stack.
4213   case 'Y':
4214     switch (Constraint[1]) {
4215     default:
4216       // Break from inner switch and fall through (copy single char),
4217       // continue parsing after copying the current constraint into
4218       // the return string.
4219       break;
4220     case 'k':
4221       // "^" hints llvm that this is a 2 letter constraint.
4222       // "Constraint++" is used to promote the string iterator
4223       // to the next constraint.
4224       return std::string("^") + std::string(Constraint++, 2);
4225     }
4226     LLVM_FALLTHROUGH;
4227   default:
4228     return std::string(1, *Constraint);
4229   }
4230 }
4231
4232 // X86-32 generic target
4233 class X86_32TargetInfo : public X86TargetInfo {
4234 public:
4235   X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4236       : X86TargetInfo(Triple, Opts) {
4237     DoubleAlign = LongLongAlign = 32;
4238     LongDoubleWidth = 96;
4239     LongDoubleAlign = 32;
4240     SuitableAlign = 128;
4241     resetDataLayout("e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128");
4242     SizeType = UnsignedInt;
4243     PtrDiffType = SignedInt;
4244     IntPtrType = SignedInt;
4245     RegParmMax = 3;
4246
4247     // Use fpret for all types.
4248     RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
4249                              (1 << TargetInfo::Double) |
4250                              (1 << TargetInfo::LongDouble));
4251
4252     // x86-32 has atomics up to 8 bytes
4253     // FIXME: Check that we actually have cmpxchg8b before setting
4254     // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
4255     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4256   }
4257   BuiltinVaListKind getBuiltinVaListKind() const override {
4258     return TargetInfo::CharPtrBuiltinVaList;
4259   }
4260
4261   int getEHDataRegisterNumber(unsigned RegNo) const override {
4262     if (RegNo == 0) return 0;
4263     if (RegNo == 1) return 2;
4264     return -1;
4265   }
4266   bool validateOperandSize(StringRef Constraint,
4267                            unsigned Size) const override {
4268     switch (Constraint[0]) {
4269     default: break;
4270     case 'R':
4271     case 'q':
4272     case 'Q':
4273     case 'a':
4274     case 'b':
4275     case 'c':
4276     case 'd':
4277     case 'S':
4278     case 'D':
4279       return Size <= 32;
4280     case 'A':
4281       return Size <= 64;
4282     }
4283
4284     return X86TargetInfo::validateOperandSize(Constraint, Size);
4285   }
4286   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
4287     return llvm::makeArrayRef(BuiltinInfoX86, clang::X86::LastX86CommonBuiltin -
4288                                                   Builtin::FirstTSBuiltin + 1);
4289   }
4290 };
4291
4292 class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
4293 public:
4294   NetBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4295       : NetBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {}
4296
4297   unsigned getFloatEvalMethod() const override {
4298     unsigned Major, Minor, Micro;
4299     getTriple().getOSVersion(Major, Minor, Micro);
4300     // New NetBSD uses the default rounding mode.
4301     if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
4302       return X86_32TargetInfo::getFloatEvalMethod();
4303     // NetBSD before 6.99.26 defaults to "double" rounding.
4304     return 1;
4305   }
4306 };
4307
4308 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
4309 public:
4310   OpenBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4311       : OpenBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {
4312     SizeType = UnsignedLong;
4313     IntPtrType = SignedLong;
4314     PtrDiffType = SignedLong;
4315   }
4316 };
4317
4318 class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
4319 public:
4320   BitrigI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4321       : BitrigTargetInfo<X86_32TargetInfo>(Triple, Opts) {
4322     SizeType = UnsignedLong;
4323     IntPtrType = SignedLong;
4324     PtrDiffType = SignedLong;
4325   }
4326 };
4327
4328 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
4329 public:
4330   DarwinI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4331       : DarwinTargetInfo<X86_32TargetInfo>(Triple, Opts) {
4332     LongDoubleWidth = 128;
4333     LongDoubleAlign = 128;
4334     SuitableAlign = 128;
4335     MaxVectorAlign = 256;
4336     // The watchOS simulator uses the builtin bool type for Objective-C.
4337     llvm::Triple T = llvm::Triple(Triple);
4338     if (T.isWatchOS())
4339       UseSignedCharForObjCBool = false;
4340     SizeType = UnsignedLong;
4341     IntPtrType = SignedLong;
4342     resetDataLayout("e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128");
4343     HasAlignMac68kSupport = true;
4344   }
4345
4346   bool handleTargetFeatures(std::vector<std::string> &Features,
4347                             DiagnosticsEngine &Diags) override {
4348     if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
4349                                                                   Diags))
4350       return false;
4351     // We now know the features we have: we can decide how to align vectors.
4352     MaxVectorAlign =
4353         hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
4354     return true;
4355   }
4356 };
4357
4358 // x86-32 Windows target
4359 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
4360 public:
4361   WindowsX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4362       : WindowsTargetInfo<X86_32TargetInfo>(Triple, Opts) {
4363     WCharType = UnsignedShort;
4364     DoubleAlign = LongLongAlign = 64;
4365     bool IsWinCOFF =
4366         getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
4367     resetDataLayout(IsWinCOFF
4368                         ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
4369                         : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
4370   }
4371   void getTargetDefines(const LangOptions &Opts,
4372                         MacroBuilder &Builder) const override {
4373     WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
4374   }
4375 };
4376
4377 // x86-32 Windows Visual Studio target
4378 class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
4379 public:
4380   MicrosoftX86_32TargetInfo(const llvm::Triple &Triple,
4381                             const TargetOptions &Opts)
4382       : WindowsX86_32TargetInfo(Triple, Opts) {
4383     LongDoubleWidth = LongDoubleAlign = 64;
4384     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
4385   }
4386   void getTargetDefines(const LangOptions &Opts,
4387                         MacroBuilder &Builder) const override {
4388     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
4389     WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
4390     // The value of the following reflects processor type.
4391     // 300=386, 400=486, 500=Pentium, 600=Blend (default)
4392     // We lost the original triple, so we use the default.
4393     Builder.defineMacro("_M_IX86", "600");
4394   }
4395 };
4396
4397 static void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
4398   // Mingw and cygwin define __declspec(a) to __attribute__((a)).  Clang
4399   // supports __declspec natively under -fms-extensions, but we define a no-op
4400   // __declspec macro anyway for pre-processor compatibility.
4401   if (Opts.MicrosoftExt)
4402     Builder.defineMacro("__declspec", "__declspec");
4403   else
4404     Builder.defineMacro("__declspec(a)", "__attribute__((a))");
4405
4406   if (!Opts.MicrosoftExt) {
4407     // Provide macros for all the calling convention keywords.  Provide both
4408     // single and double underscore prefixed variants.  These are available on
4409     // x64 as well as x86, even though they have no effect.
4410     const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
4411     for (const char *CC : CCs) {
4412       std::string GCCSpelling = "__attribute__((__";
4413       GCCSpelling += CC;
4414       GCCSpelling += "__))";
4415       Builder.defineMacro(Twine("_") + CC, GCCSpelling);
4416       Builder.defineMacro(Twine("__") + CC, GCCSpelling);
4417     }
4418   }
4419 }
4420
4421 static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
4422   Builder.defineMacro("__MSVCRT__");
4423   Builder.defineMacro("__MINGW32__");
4424   addCygMingDefines(Opts, Builder);
4425 }
4426
4427 // x86-32 MinGW target
4428 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
4429 public:
4430   MinGWX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4431       : WindowsX86_32TargetInfo(Triple, Opts) {}
4432   void getTargetDefines(const LangOptions &Opts,
4433                         MacroBuilder &Builder) const override {
4434     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
4435     DefineStd(Builder, "WIN32", Opts);
4436     DefineStd(Builder, "WINNT", Opts);
4437     Builder.defineMacro("_X86_");
4438     addMinGWDefines(Opts, Builder);
4439   }
4440 };
4441
4442 // x86-32 Cygwin target
4443 class CygwinX86_32TargetInfo : public X86_32TargetInfo {
4444 public:
4445   CygwinX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4446       : X86_32TargetInfo(Triple, Opts) {
4447     WCharType = UnsignedShort;
4448     DoubleAlign = LongLongAlign = 64;
4449     resetDataLayout("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
4450   }
4451   void getTargetDefines(const LangOptions &Opts,
4452                         MacroBuilder &Builder) const override {
4453     X86_32TargetInfo::getTargetDefines(Opts, Builder);
4454     Builder.defineMacro("_X86_");
4455     Builder.defineMacro("__CYGWIN__");
4456     Builder.defineMacro("__CYGWIN32__");
4457     addCygMingDefines(Opts, Builder);
4458     DefineStd(Builder, "unix", Opts);
4459     if (Opts.CPlusPlus)
4460       Builder.defineMacro("_GNU_SOURCE");
4461   }
4462 };
4463
4464 // x86-32 Haiku target
4465 class HaikuX86_32TargetInfo : public HaikuTargetInfo<X86_32TargetInfo> {
4466 public:
4467   HaikuX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4468     : HaikuTargetInfo<X86_32TargetInfo>(Triple, Opts) {
4469   }
4470   void getTargetDefines(const LangOptions &Opts,
4471                         MacroBuilder &Builder) const override {
4472     HaikuTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
4473     Builder.defineMacro("__INTEL__");
4474   }
4475 };
4476
4477 // X86-32 MCU target
4478 class MCUX86_32TargetInfo : public X86_32TargetInfo {
4479 public:
4480   MCUX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4481       : X86_32TargetInfo(Triple, Opts) {
4482     LongDoubleWidth = 64;
4483     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
4484     resetDataLayout("e-m:e-p:32:32-i64:32-f64:32-f128:32-n8:16:32-a:0:32-S32");
4485     WIntType = UnsignedInt;
4486   }
4487
4488   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
4489     // On MCU we support only C calling convention.
4490     return CC == CC_C ? CCCR_OK : CCCR_Warning;
4491   }
4492
4493   void getTargetDefines(const LangOptions &Opts,
4494                         MacroBuilder &Builder) const override {
4495     X86_32TargetInfo::getTargetDefines(Opts, Builder);
4496     Builder.defineMacro("__iamcu");
4497     Builder.defineMacro("__iamcu__");
4498   }
4499
4500   bool allowsLargerPreferedTypeAlignment() const override {
4501     return false;
4502   }
4503 };
4504
4505 // RTEMS Target
4506 template<typename Target>
4507 class RTEMSTargetInfo : public OSTargetInfo<Target> {
4508 protected:
4509   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4510                     MacroBuilder &Builder) const override {
4511     // RTEMS defines; list based off of gcc output
4512
4513     Builder.defineMacro("__rtems__");
4514     Builder.defineMacro("__ELF__");
4515   }
4516
4517 public:
4518   RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4519       : OSTargetInfo<Target>(Triple, Opts) {
4520     switch (Triple.getArch()) {
4521     default:
4522     case llvm::Triple::x86:
4523       // this->MCountName = ".mcount";
4524       break;
4525     case llvm::Triple::mips:
4526     case llvm::Triple::mipsel:
4527     case llvm::Triple::ppc:
4528     case llvm::Triple::ppc64:
4529     case llvm::Triple::ppc64le:
4530       // this->MCountName = "_mcount";
4531       break;
4532     case llvm::Triple::arm:
4533       // this->MCountName = "__mcount";
4534       break;
4535     }
4536   }
4537 };
4538
4539 // x86-32 RTEMS target
4540 class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
4541 public:
4542   RTEMSX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4543       : X86_32TargetInfo(Triple, Opts) {
4544     SizeType = UnsignedLong;
4545     IntPtrType = SignedLong;
4546     PtrDiffType = SignedLong;
4547   }
4548   void getTargetDefines(const LangOptions &Opts,
4549                         MacroBuilder &Builder) const override {
4550     X86_32TargetInfo::getTargetDefines(Opts, Builder);
4551     Builder.defineMacro("__INTEL__");
4552     Builder.defineMacro("__rtems__");
4553   }
4554 };
4555
4556 // x86-64 generic target
4557 class X86_64TargetInfo : public X86TargetInfo {
4558 public:
4559   X86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4560       : X86TargetInfo(Triple, Opts) {
4561     const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
4562     bool IsWinCOFF =
4563         getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
4564     LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
4565     LongDoubleWidth = 128;
4566     LongDoubleAlign = 128;
4567     LargeArrayMinWidth = 128;
4568     LargeArrayAlign = 128;
4569     SuitableAlign = 128;
4570     SizeType    = IsX32 ? UnsignedInt      : UnsignedLong;
4571     PtrDiffType = IsX32 ? SignedInt        : SignedLong;
4572     IntPtrType  = IsX32 ? SignedInt        : SignedLong;
4573     IntMaxType  = IsX32 ? SignedLongLong   : SignedLong;
4574     Int64Type   = IsX32 ? SignedLongLong   : SignedLong;
4575     RegParmMax = 6;
4576
4577     // Pointers are 32-bit in x32.
4578     resetDataLayout(IsX32
4579                         ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
4580                         : IsWinCOFF ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
4581                                     : "e-m:e-i64:64-f80:128-n8:16:32:64-S128");
4582
4583     // Use fpret only for long double.
4584     RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
4585
4586     // Use fp2ret for _Complex long double.
4587     ComplexLongDoubleUsesFP2Ret = true;
4588
4589     // Make __builtin_ms_va_list available.
4590     HasBuiltinMSVaList = true;
4591
4592     // x86-64 has atomics up to 16 bytes.
4593     MaxAtomicPromoteWidth = 128;
4594     MaxAtomicInlineWidth = 128;
4595   }
4596   BuiltinVaListKind getBuiltinVaListKind() const override {
4597     return TargetInfo::X86_64ABIBuiltinVaList;
4598   }
4599
4600   int getEHDataRegisterNumber(unsigned RegNo) const override {
4601     if (RegNo == 0) return 0;
4602     if (RegNo == 1) return 1;
4603     return -1;
4604   }
4605
4606   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
4607     switch (CC) {
4608     case CC_C:
4609     case CC_Swift:
4610     case CC_X86VectorCall:
4611     case CC_IntelOclBicc:
4612     case CC_X86_64Win64:
4613     case CC_PreserveMost:
4614     case CC_PreserveAll:
4615     case CC_X86RegCall:
4616       return CCCR_OK;
4617     default:
4618       return CCCR_Warning;
4619     }
4620   }
4621
4622   CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
4623     return CC_C;
4624   }
4625
4626   // for x32 we need it here explicitly
4627   bool hasInt128Type() const override { return true; }
4628   unsigned getUnwindWordWidth() const override { return 64; }
4629   unsigned getRegisterWidth() const override { return 64; }
4630
4631   bool validateGlobalRegisterVariable(StringRef RegName,
4632                                       unsigned RegSize,
4633                                       bool &HasSizeMismatch) const override {
4634     // rsp and rbp are the only 64-bit registers the x86 backend can currently
4635     // handle.
4636     if (RegName.equals("rsp") || RegName.equals("rbp")) {
4637       // Check that the register size is 64-bit.
4638       HasSizeMismatch = RegSize != 64;
4639       return true;
4640     }
4641
4642     // Check if the register is a 32-bit register the backend can handle.
4643     return X86TargetInfo::validateGlobalRegisterVariable(RegName, RegSize,
4644                                                          HasSizeMismatch);
4645   }
4646   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
4647     return llvm::makeArrayRef(BuiltinInfoX86,
4648                               X86::LastTSBuiltin - Builtin::FirstTSBuiltin);
4649   }
4650 };
4651
4652 // x86-64 Windows target
4653 class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
4654 public:
4655   WindowsX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4656       : WindowsTargetInfo<X86_64TargetInfo>(Triple, Opts) {
4657     WCharType = UnsignedShort;
4658     LongWidth = LongAlign = 32;
4659     DoubleAlign = LongLongAlign = 64;
4660     IntMaxType = SignedLongLong;
4661     Int64Type = SignedLongLong;
4662     SizeType = UnsignedLongLong;
4663     PtrDiffType = SignedLongLong;
4664     IntPtrType = SignedLongLong;
4665   }
4666
4667   void getTargetDefines(const LangOptions &Opts,
4668                                 MacroBuilder &Builder) const override {
4669     WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
4670     Builder.defineMacro("_WIN64");
4671   }
4672
4673   BuiltinVaListKind getBuiltinVaListKind() const override {
4674     return TargetInfo::CharPtrBuiltinVaList;
4675   }
4676
4677   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
4678     switch (CC) {
4679     case CC_X86StdCall:
4680     case CC_X86ThisCall:
4681     case CC_X86FastCall:
4682       return CCCR_Ignore;
4683     case CC_C:
4684     case CC_X86VectorCall:
4685     case CC_IntelOclBicc:
4686     case CC_X86_64SysV:
4687     case CC_Swift:
4688     case CC_X86RegCall:
4689       return CCCR_OK;
4690     default:
4691       return CCCR_Warning;
4692     }
4693   }
4694 };
4695
4696 // x86-64 Windows Visual Studio target
4697 class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
4698 public:
4699   MicrosoftX86_64TargetInfo(const llvm::Triple &Triple,
4700                             const TargetOptions &Opts)
4701       : WindowsX86_64TargetInfo(Triple, Opts) {
4702     LongDoubleWidth = LongDoubleAlign = 64;
4703     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
4704   }
4705   void getTargetDefines(const LangOptions &Opts,
4706                         MacroBuilder &Builder) const override {
4707     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4708     WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
4709     Builder.defineMacro("_M_X64", "100");
4710     Builder.defineMacro("_M_AMD64", "100");
4711   }
4712 };
4713
4714 // x86-64 MinGW target
4715 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
4716 public:
4717   MinGWX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4718       : WindowsX86_64TargetInfo(Triple, Opts) {
4719     // Mingw64 rounds long double size and alignment up to 16 bytes, but sticks
4720     // with x86 FP ops. Weird.
4721     LongDoubleWidth = LongDoubleAlign = 128;
4722     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
4723   }
4724
4725   void getTargetDefines(const LangOptions &Opts,
4726                         MacroBuilder &Builder) const override {
4727     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4728     DefineStd(Builder, "WIN64", Opts);
4729     Builder.defineMacro("__MINGW64__");
4730     addMinGWDefines(Opts, Builder);
4731
4732     // GCC defines this macro when it is using __gxx_personality_seh0.
4733     if (!Opts.SjLjExceptions)
4734       Builder.defineMacro("__SEH__");
4735   }
4736 };
4737
4738 // x86-64 Cygwin target
4739 class CygwinX86_64TargetInfo : public X86_64TargetInfo {
4740 public:
4741   CygwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4742       : X86_64TargetInfo(Triple, Opts) {
4743     TLSSupported = false;
4744     WCharType = UnsignedShort;
4745   }
4746   void getTargetDefines(const LangOptions &Opts,
4747                         MacroBuilder &Builder) const override {
4748     X86_64TargetInfo::getTargetDefines(Opts, Builder);
4749     Builder.defineMacro("__x86_64__");
4750     Builder.defineMacro("__CYGWIN__");
4751     Builder.defineMacro("__CYGWIN64__");
4752     addCygMingDefines(Opts, Builder);
4753     DefineStd(Builder, "unix", Opts);
4754     if (Opts.CPlusPlus)
4755       Builder.defineMacro("_GNU_SOURCE");
4756
4757     // GCC defines this macro when it is using __gxx_personality_seh0.
4758     if (!Opts.SjLjExceptions)
4759       Builder.defineMacro("__SEH__");
4760   }
4761 };
4762
4763 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
4764 public:
4765   DarwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4766       : DarwinTargetInfo<X86_64TargetInfo>(Triple, Opts) {
4767     Int64Type = SignedLongLong;
4768     // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
4769     llvm::Triple T = llvm::Triple(Triple);
4770     if (T.isiOS())
4771       UseSignedCharForObjCBool = false;
4772     resetDataLayout("e-m:o-i64:64-f80:128-n8:16:32:64-S128");
4773   }
4774
4775   bool handleTargetFeatures(std::vector<std::string> &Features,
4776                             DiagnosticsEngine &Diags) override {
4777     if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
4778                                                                   Diags))
4779       return false;
4780     // We now know the features we have: we can decide how to align vectors.
4781     MaxVectorAlign =
4782         hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
4783     return true;
4784   }
4785 };
4786
4787 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
4788 public:
4789   OpenBSDX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4790       : OpenBSDTargetInfo<X86_64TargetInfo>(Triple, Opts) {
4791     IntMaxType = SignedLongLong;
4792     Int64Type = SignedLongLong;
4793   }
4794 };
4795
4796 class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
4797 public:
4798   BitrigX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4799       : BitrigTargetInfo<X86_64TargetInfo>(Triple, Opts) {
4800     IntMaxType = SignedLongLong;
4801     Int64Type = SignedLongLong;
4802   }
4803 };
4804
4805 class ARMTargetInfo : public TargetInfo {
4806   // Possible FPU choices.
4807   enum FPUMode {
4808     VFP2FPU = (1 << 0),
4809     VFP3FPU = (1 << 1),
4810     VFP4FPU = (1 << 2),
4811     NeonFPU = (1 << 3),
4812     FPARMV8 = (1 << 4)
4813   };
4814
4815   // Possible HWDiv features.
4816   enum HWDivMode {
4817     HWDivThumb = (1 << 0),
4818     HWDivARM = (1 << 1)
4819   };
4820
4821   static bool FPUModeIsVFP(FPUMode Mode) {
4822     return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
4823   }
4824
4825   static const TargetInfo::GCCRegAlias GCCRegAliases[];
4826   static const char * const GCCRegNames[];
4827
4828   std::string ABI, CPU;
4829
4830   StringRef CPUProfile;
4831   StringRef CPUAttr;
4832
4833   enum {
4834     FP_Default,
4835     FP_VFP,
4836     FP_Neon
4837   } FPMath;
4838
4839   unsigned ArchISA;
4840   unsigned ArchKind = llvm::ARM::AK_ARMV4T;
4841   unsigned ArchProfile;
4842   unsigned ArchVersion;
4843
4844   unsigned FPU : 5;
4845
4846   unsigned IsAAPCS : 1;
4847   unsigned HWDiv : 2;
4848
4849   // Initialized via features.
4850   unsigned SoftFloat : 1;
4851   unsigned SoftFloatABI : 1;
4852
4853   unsigned CRC : 1;
4854   unsigned Crypto : 1;
4855   unsigned DSP : 1;
4856   unsigned Unaligned : 1;
4857
4858   enum {
4859     LDREX_B = (1 << 0), /// byte (8-bit)
4860     LDREX_H = (1 << 1), /// half (16-bit)
4861     LDREX_W = (1 << 2), /// word (32-bit)
4862     LDREX_D = (1 << 3), /// double (64-bit)
4863   };
4864
4865   uint32_t LDREX;
4866
4867   // ACLE 6.5.1 Hardware floating point
4868   enum {
4869     HW_FP_HP = (1 << 1), /// half (16-bit)
4870     HW_FP_SP = (1 << 2), /// single (32-bit)
4871     HW_FP_DP = (1 << 3), /// double (64-bit)
4872   };
4873   uint32_t HW_FP;
4874
4875   static const Builtin::Info BuiltinInfo[];
4876
4877   void setABIAAPCS() {
4878     IsAAPCS = true;
4879
4880     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
4881     const llvm::Triple &T = getTriple();
4882
4883     // size_t is unsigned long on MachO-derived environments, NetBSD,
4884     // OpenBSD and Bitrig.
4885     if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
4886         T.getOS() == llvm::Triple::OpenBSD ||
4887         T.getOS() == llvm::Triple::Bitrig)
4888       SizeType = UnsignedLong;
4889     else
4890       SizeType = UnsignedInt;
4891
4892     switch (T.getOS()) {
4893     case llvm::Triple::NetBSD:
4894     case llvm::Triple::OpenBSD:
4895       WCharType = SignedInt;
4896       break;
4897     case llvm::Triple::Win32:
4898       WCharType = UnsignedShort;
4899       break;
4900     case llvm::Triple::Linux:
4901     default:
4902       // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
4903       WCharType = UnsignedInt;
4904       break;
4905     }
4906
4907     UseBitFieldTypeAlignment = true;
4908
4909     ZeroLengthBitfieldBoundary = 0;
4910
4911     // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
4912     // so set preferred for small types to 32.
4913     if (T.isOSBinFormatMachO()) {
4914       resetDataLayout(BigEndian
4915                           ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4916                           : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
4917     } else if (T.isOSWindows()) {
4918       assert(!BigEndian && "Windows on ARM does not support big endian");
4919       resetDataLayout("e"
4920                       "-m:w"
4921                       "-p:32:32"
4922                       "-i64:64"
4923                       "-v128:64:128"
4924                       "-a:0:32"
4925                       "-n32"
4926                       "-S64");
4927     } else if (T.isOSNaCl()) {
4928       assert(!BigEndian && "NaCl on ARM does not support big endian");
4929       resetDataLayout("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128");
4930     } else {
4931       resetDataLayout(BigEndian
4932                           ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4933                           : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
4934     }
4935
4936     // FIXME: Enumerated types are variable width in straight AAPCS.
4937   }
4938
4939   void setABIAPCS(bool IsAAPCS16) {
4940     const llvm::Triple &T = getTriple();
4941
4942     IsAAPCS = false;
4943
4944     if (IsAAPCS16)
4945       DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
4946     else
4947       DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
4948
4949     // size_t is unsigned int on FreeBSD.
4950     if (T.getOS() == llvm::Triple::FreeBSD)
4951       SizeType = UnsignedInt;
4952     else
4953       SizeType = UnsignedLong;
4954
4955     // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
4956     WCharType = SignedInt;
4957
4958     // Do not respect the alignment of bit-field types when laying out
4959     // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
4960     UseBitFieldTypeAlignment = false;
4961
4962     /// gcc forces the alignment to 4 bytes, regardless of the type of the
4963     /// zero length bitfield.  This corresponds to EMPTY_FIELD_BOUNDARY in
4964     /// gcc.
4965     ZeroLengthBitfieldBoundary = 32;
4966
4967     if (T.isOSBinFormatMachO() && IsAAPCS16) {
4968       assert(!BigEndian && "AAPCS16 does not support big-endian");
4969       resetDataLayout("e-m:o-p:32:32-i64:64-a:0:32-n32-S128");
4970     } else if (T.isOSBinFormatMachO())
4971       resetDataLayout(
4972           BigEndian
4973               ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4974               : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
4975     else
4976       resetDataLayout(
4977           BigEndian
4978               ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4979               : "e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
4980
4981     // FIXME: Override "preferred align" for double and long long.
4982   }
4983
4984   void setArchInfo() {
4985     StringRef ArchName = getTriple().getArchName();
4986
4987     ArchISA     = llvm::ARM::parseArchISA(ArchName);
4988     CPU         = llvm::ARM::getDefaultCPU(ArchName);
4989     unsigned AK = llvm::ARM::parseArch(ArchName);
4990     if (AK != llvm::ARM::AK_INVALID)
4991       ArchKind = AK;
4992     setArchInfo(ArchKind);
4993   }
4994
4995   void setArchInfo(unsigned Kind) {
4996     StringRef SubArch;
4997
4998     // cache TargetParser info
4999     ArchKind    = Kind;
5000     SubArch     = llvm::ARM::getSubArch(ArchKind);
5001     ArchProfile = llvm::ARM::parseArchProfile(SubArch);
5002     ArchVersion = llvm::ARM::parseArchVersion(SubArch);
5003
5004     // cache CPU related strings
5005     CPUAttr    = getCPUAttr();
5006     CPUProfile = getCPUProfile();
5007   }
5008
5009   void setAtomic() {
5010     // when triple does not specify a sub arch,
5011     // then we are not using inline atomics
5012     bool ShouldUseInlineAtomic =
5013                    (ArchISA == llvm::ARM::IK_ARM   && ArchVersion >= 6) ||
5014                    (ArchISA == llvm::ARM::IK_THUMB && ArchVersion >= 7);
5015     // Cortex M does not support 8 byte atomics, while general Thumb2 does.
5016     if (ArchProfile == llvm::ARM::PK_M) {
5017       MaxAtomicPromoteWidth = 32;
5018       if (ShouldUseInlineAtomic)
5019         MaxAtomicInlineWidth = 32;
5020     }
5021     else {
5022       MaxAtomicPromoteWidth = 64;
5023       if (ShouldUseInlineAtomic)
5024         MaxAtomicInlineWidth = 64;
5025     }
5026   }
5027
5028   bool isThumb() const {
5029     return (ArchISA == llvm::ARM::IK_THUMB);
5030   }
5031
5032   bool supportsThumb() const {
5033     return CPUAttr.count('T') || ArchVersion >= 6;
5034   }
5035
5036   bool supportsThumb2() const {
5037     return CPUAttr.equals("6T2") ||
5038            (ArchVersion >= 7 && !CPUAttr.equals("8M_BASE"));
5039   }
5040
5041   StringRef getCPUAttr() const {
5042     // For most sub-arches, the build attribute CPU name is enough.
5043     // For Cortex variants, it's slightly different.
5044     switch(ArchKind) {
5045     default:
5046       return llvm::ARM::getCPUAttr(ArchKind);
5047     case llvm::ARM::AK_ARMV6M:
5048       return "6M";
5049     case llvm::ARM::AK_ARMV7S:
5050       return "7S";
5051     case llvm::ARM::AK_ARMV7A:
5052       return "7A";
5053     case llvm::ARM::AK_ARMV7R:
5054       return "7R";
5055     case llvm::ARM::AK_ARMV7M:
5056       return "7M";
5057     case llvm::ARM::AK_ARMV7EM:
5058       return "7EM";
5059     case llvm::ARM::AK_ARMV8A:
5060       return "8A";
5061     case llvm::ARM::AK_ARMV8_1A:
5062       return "8_1A";
5063     case llvm::ARM::AK_ARMV8_2A:
5064       return "8_2A";
5065     case llvm::ARM::AK_ARMV8MBaseline:
5066       return "8M_BASE";
5067     case llvm::ARM::AK_ARMV8MMainline:
5068       return "8M_MAIN";
5069     case llvm::ARM::AK_ARMV8R:
5070       return "8R";
5071     }
5072   }
5073
5074   StringRef getCPUProfile() const {
5075     switch(ArchProfile) {
5076     case llvm::ARM::PK_A:
5077       return "A";
5078     case llvm::ARM::PK_R:
5079       return "R";
5080     case llvm::ARM::PK_M:
5081       return "M";
5082     default:
5083       return "";
5084     }
5085   }
5086
5087 public:
5088   ARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5089       : TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(true), LDREX(0),
5090         HW_FP(0) {
5091
5092     switch (getTriple().getOS()) {
5093     case llvm::Triple::NetBSD:
5094     case llvm::Triple::OpenBSD:
5095       PtrDiffType = SignedLong;
5096       break;
5097     default:
5098       PtrDiffType = SignedInt;
5099       break;
5100     }
5101
5102     // Cache arch related info.
5103     setArchInfo();
5104
5105     // {} in inline assembly are neon specifiers, not assembly variant
5106     // specifiers.
5107     NoAsmVariants = true;
5108
5109     // FIXME: This duplicates code from the driver that sets the -target-abi
5110     // option - this code is used if -target-abi isn't passed and should
5111     // be unified in some way.
5112     if (Triple.isOSBinFormatMachO()) {
5113       // The backend is hardwired to assume AAPCS for M-class processors, ensure
5114       // the frontend matches that.
5115       if (Triple.getEnvironment() == llvm::Triple::EABI ||
5116           Triple.getOS() == llvm::Triple::UnknownOS ||
5117           ArchProfile == llvm::ARM::PK_M) {
5118         setABI("aapcs");
5119       } else if (Triple.isWatchABI()) {
5120         setABI("aapcs16");
5121       } else {
5122         setABI("apcs-gnu");
5123       }
5124     } else if (Triple.isOSWindows()) {
5125       // FIXME: this is invalid for WindowsCE
5126       setABI("aapcs");
5127     } else {
5128       // Select the default based on the platform.
5129       switch (Triple.getEnvironment()) {
5130       case llvm::Triple::Android:
5131       case llvm::Triple::GNUEABI:
5132       case llvm::Triple::GNUEABIHF:
5133       case llvm::Triple::MuslEABI:
5134       case llvm::Triple::MuslEABIHF:
5135         setABI("aapcs-linux");
5136         break;
5137       case llvm::Triple::EABIHF:
5138       case llvm::Triple::EABI:
5139         setABI("aapcs");
5140         break;
5141       case llvm::Triple::GNU:
5142         setABI("apcs-gnu");
5143       break;
5144       default:
5145         if (Triple.getOS() == llvm::Triple::NetBSD)
5146           setABI("apcs-gnu");
5147         else
5148           setABI("aapcs");
5149         break;
5150       }
5151     }
5152
5153     // ARM targets default to using the ARM C++ ABI.
5154     TheCXXABI.set(TargetCXXABI::GenericARM);
5155
5156     // ARM has atomics up to 8 bytes
5157     setAtomic();
5158
5159     // Do force alignment of members that follow zero length bitfields.  If
5160     // the alignment of the zero-length bitfield is greater than the member
5161     // that follows it, `bar', `bar' will be aligned as the  type of the
5162     // zero length bitfield.
5163     UseZeroLengthBitfieldAlignment = true;
5164
5165     if (Triple.getOS() == llvm::Triple::Linux ||
5166         Triple.getOS() == llvm::Triple::UnknownOS)
5167       this->MCountName =
5168           Opts.EABIVersion == "gnu" ? "\01__gnu_mcount_nc" : "\01mcount";
5169   }
5170
5171   StringRef getABI() const override { return ABI; }
5172
5173   bool setABI(const std::string &Name) override {
5174     ABI = Name;
5175
5176     // The defaults (above) are for AAPCS, check if we need to change them.
5177     //
5178     // FIXME: We need support for -meabi... we could just mangle it into the
5179     // name.
5180     if (Name == "apcs-gnu" || Name == "aapcs16") {
5181       setABIAPCS(Name == "aapcs16");
5182       return true;
5183     }
5184     if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
5185       setABIAAPCS();
5186       return true;
5187     }
5188     return false;
5189   }
5190
5191   // FIXME: This should be based on Arch attributes, not CPU names.
5192   bool
5193   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
5194                  StringRef CPU,
5195                  const std::vector<std::string> &FeaturesVec) const override {
5196
5197     std::vector<StringRef> TargetFeatures;
5198     unsigned Arch = llvm::ARM::parseArch(getTriple().getArchName());
5199
5200     // get default FPU features
5201     unsigned FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
5202     llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
5203
5204     // get default Extension features
5205     unsigned Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
5206     llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
5207
5208     for (auto Feature : TargetFeatures)
5209       if (Feature[0] == '+')
5210         Features[Feature.drop_front(1)] = true;
5211
5212     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
5213   }
5214
5215   bool handleTargetFeatures(std::vector<std::string> &Features,
5216                             DiagnosticsEngine &Diags) override {
5217     FPU = 0;
5218     CRC = 0;
5219     Crypto = 0;
5220     DSP = 0;
5221     Unaligned = 1;
5222     SoftFloat = SoftFloatABI = false;
5223     HWDiv = 0;
5224
5225     // This does not diagnose illegal cases like having both
5226     // "+vfpv2" and "+vfpv3" or having "+neon" and "+fp-only-sp".
5227     uint32_t HW_FP_remove = 0;
5228     for (const auto &Feature : Features) {
5229       if (Feature == "+soft-float") {
5230         SoftFloat = true;
5231       } else if (Feature == "+soft-float-abi") {
5232         SoftFloatABI = true;
5233       } else if (Feature == "+vfp2") {
5234         FPU |= VFP2FPU;
5235         HW_FP |= HW_FP_SP | HW_FP_DP;
5236       } else if (Feature == "+vfp3") {
5237         FPU |= VFP3FPU;
5238         HW_FP |= HW_FP_SP | HW_FP_DP;
5239       } else if (Feature == "+vfp4") {
5240         FPU |= VFP4FPU;
5241         HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
5242       } else if (Feature == "+fp-armv8") {
5243         FPU |= FPARMV8;
5244         HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
5245       } else if (Feature == "+neon") {
5246         FPU |= NeonFPU;
5247         HW_FP |= HW_FP_SP | HW_FP_DP;
5248       } else if (Feature == "+hwdiv") {
5249         HWDiv |= HWDivThumb;
5250       } else if (Feature == "+hwdiv-arm") {
5251         HWDiv |= HWDivARM;
5252       } else if (Feature == "+crc") {
5253         CRC = 1;
5254       } else if (Feature == "+crypto") {
5255         Crypto = 1;
5256       } else if (Feature == "+dsp") {
5257         DSP = 1;
5258       } else if (Feature == "+fp-only-sp") {
5259         HW_FP_remove |= HW_FP_DP;
5260       } else if (Feature == "+strict-align") {
5261         Unaligned = 0;
5262       } else if (Feature == "+fp16") {
5263         HW_FP |= HW_FP_HP;
5264       }
5265     }
5266     HW_FP &= ~HW_FP_remove;
5267
5268     switch (ArchVersion) {
5269     case 6:
5270       if (ArchProfile == llvm::ARM::PK_M)
5271         LDREX = 0;
5272       else if (ArchKind == llvm::ARM::AK_ARMV6K)
5273         LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5274       else
5275         LDREX = LDREX_W;
5276       break;
5277     case 7:
5278       if (ArchProfile == llvm::ARM::PK_M)
5279         LDREX = LDREX_W | LDREX_H | LDREX_B ;
5280       else
5281         LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5282       break;
5283     case 8:
5284       LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5285     }
5286
5287     if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
5288       Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
5289       return false;
5290     }
5291
5292     if (FPMath == FP_Neon)
5293       Features.push_back("+neonfp");
5294     else if (FPMath == FP_VFP)
5295       Features.push_back("-neonfp");
5296
5297     // Remove front-end specific options which the backend handles differently.
5298     auto Feature =
5299         std::find(Features.begin(), Features.end(), "+soft-float-abi");
5300     if (Feature != Features.end())
5301       Features.erase(Feature);
5302
5303     return true;
5304   }
5305
5306   bool hasFeature(StringRef Feature) const override {
5307     return llvm::StringSwitch<bool>(Feature)
5308         .Case("arm", true)
5309         .Case("aarch32", true)
5310         .Case("softfloat", SoftFloat)
5311         .Case("thumb", isThumb())
5312         .Case("neon", (FPU & NeonFPU) && !SoftFloat)
5313         .Case("hwdiv", HWDiv & HWDivThumb)
5314         .Case("hwdiv-arm", HWDiv & HWDivARM)
5315         .Default(false);
5316   }
5317
5318   bool setCPU(const std::string &Name) override {
5319     if (Name != "generic")
5320       setArchInfo(llvm::ARM::parseCPUArch(Name));
5321
5322     if (ArchKind == llvm::ARM::AK_INVALID)
5323       return false;
5324     setAtomic();
5325     CPU = Name;
5326     return true;
5327   }
5328
5329   bool setFPMath(StringRef Name) override;
5330
5331   void getTargetDefines(const LangOptions &Opts,
5332                         MacroBuilder &Builder) const override {
5333     // Target identification.
5334     Builder.defineMacro("__arm");
5335     Builder.defineMacro("__arm__");
5336     // For bare-metal none-eabi.
5337     if (getTriple().getOS() == llvm::Triple::UnknownOS &&
5338         getTriple().getEnvironment() == llvm::Triple::EABI)
5339       Builder.defineMacro("__ELF__");
5340
5341     // Target properties.
5342     Builder.defineMacro("__REGISTER_PREFIX__", "");
5343
5344     // Unfortunately, __ARM_ARCH_7K__ is now more of an ABI descriptor. The CPU
5345     // happens to be Cortex-A7 though, so it should still get __ARM_ARCH_7A__.
5346     if (getTriple().isWatchABI())
5347       Builder.defineMacro("__ARM_ARCH_7K__", "2");
5348
5349     if (!CPUAttr.empty())
5350       Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");
5351
5352     // ACLE 6.4.1 ARM/Thumb instruction set architecture
5353     // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
5354     Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
5355
5356     if (ArchVersion >= 8) {
5357       // ACLE 6.5.7 Crypto Extension
5358       if (Crypto)
5359         Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
5360       // ACLE 6.5.8 CRC32 Extension
5361       if (CRC)
5362         Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
5363       // ACLE 6.5.10 Numeric Maximum and Minimum
5364       Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
5365       // ACLE 6.5.9 Directed Rounding
5366       Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
5367     }
5368
5369     // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA.  It
5370     // is not defined for the M-profile.
5371     // NOTE that the default profile is assumed to be 'A'
5372     if (CPUProfile.empty() || ArchProfile != llvm::ARM::PK_M)
5373       Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
5374
5375     // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supports the original
5376     // Thumb ISA (including v6-M and v8-M Baseline).  It is set to 2 if the
5377     // core supports the Thumb-2 ISA as found in the v6T2 architecture and all
5378     // v7 and v8 architectures excluding v8-M Baseline.
5379     if (supportsThumb2())
5380       Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
5381     else if (supportsThumb())
5382       Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
5383
5384     // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
5385     // instruction set such as ARM or Thumb.
5386     Builder.defineMacro("__ARM_32BIT_STATE", "1");
5387
5388     // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
5389
5390     // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
5391     if (!CPUProfile.empty())
5392       Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
5393
5394     // ACLE 6.4.3 Unaligned access supported in hardware
5395     if (Unaligned)
5396       Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
5397
5398     // ACLE 6.4.4 LDREX/STREX
5399     if (LDREX)
5400       Builder.defineMacro("__ARM_FEATURE_LDREX", "0x" + llvm::utohexstr(LDREX));
5401
5402     // ACLE 6.4.5 CLZ
5403     if (ArchVersion == 5 ||
5404        (ArchVersion == 6 && CPUProfile != "M") ||
5405         ArchVersion >  6)
5406       Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
5407
5408     // ACLE 6.5.1 Hardware Floating Point
5409     if (HW_FP)
5410       Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
5411
5412     // ACLE predefines.
5413     Builder.defineMacro("__ARM_ACLE", "200");
5414
5415     // FP16 support (we currently only support IEEE format).
5416     Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
5417     Builder.defineMacro("__ARM_FP16_ARGS", "1");
5418
5419     // ACLE 6.5.3 Fused multiply-accumulate (FMA)
5420     if (ArchVersion >= 7 && (FPU & VFP4FPU))
5421       Builder.defineMacro("__ARM_FEATURE_FMA", "1");
5422
5423     // Subtarget options.
5424
5425     // FIXME: It's more complicated than this and we don't really support
5426     // interworking.
5427     // Windows on ARM does not "support" interworking
5428     if (5 <= ArchVersion && ArchVersion <= 8 && !getTriple().isOSWindows())
5429       Builder.defineMacro("__THUMB_INTERWORK__");
5430
5431     if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
5432       // Embedded targets on Darwin follow AAPCS, but not EABI.
5433       // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
5434       if (!getTriple().isOSBinFormatMachO() && !getTriple().isOSWindows())
5435         Builder.defineMacro("__ARM_EABI__");
5436       Builder.defineMacro("__ARM_PCS", "1");
5437     }
5438
5439     if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp" ||
5440         ABI == "aapcs16")
5441       Builder.defineMacro("__ARM_PCS_VFP", "1");
5442
5443     if (SoftFloat)
5444       Builder.defineMacro("__SOFTFP__");
5445
5446     if (ArchKind == llvm::ARM::AK_XSCALE)
5447       Builder.defineMacro("__XSCALE__");
5448
5449     if (isThumb()) {
5450       Builder.defineMacro("__THUMBEL__");
5451       Builder.defineMacro("__thumb__");
5452       if (supportsThumb2())
5453         Builder.defineMacro("__thumb2__");
5454     }
5455
5456     // ACLE 6.4.9 32-bit SIMD instructions
5457     if (ArchVersion >= 6 && (CPUProfile != "M" || CPUAttr == "7EM"))
5458       Builder.defineMacro("__ARM_FEATURE_SIMD32", "1");
5459
5460     // ACLE 6.4.10 Hardware Integer Divide
5461     if (((HWDiv & HWDivThumb) && isThumb()) ||
5462         ((HWDiv & HWDivARM) && !isThumb())) {
5463       Builder.defineMacro("__ARM_FEATURE_IDIV", "1");
5464       Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
5465     }
5466
5467     // Note, this is always on in gcc, even though it doesn't make sense.
5468     Builder.defineMacro("__APCS_32__");
5469
5470     if (FPUModeIsVFP((FPUMode) FPU)) {
5471       Builder.defineMacro("__VFP_FP__");
5472       if (FPU & VFP2FPU)
5473         Builder.defineMacro("__ARM_VFPV2__");
5474       if (FPU & VFP3FPU)
5475         Builder.defineMacro("__ARM_VFPV3__");
5476       if (FPU & VFP4FPU)
5477         Builder.defineMacro("__ARM_VFPV4__");
5478       if (FPU & FPARMV8)
5479         Builder.defineMacro("__ARM_FPV5__");
5480     }
5481
5482     // This only gets set when Neon instructions are actually available, unlike
5483     // the VFP define, hence the soft float and arch check. This is subtly
5484     // different from gcc, we follow the intent which was that it should be set
5485     // when Neon instructions are actually available.
5486     if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
5487       Builder.defineMacro("__ARM_NEON", "1");
5488       Builder.defineMacro("__ARM_NEON__");
5489       // current AArch32 NEON implementations do not support double-precision
5490       // floating-point even when it is present in VFP.
5491       Builder.defineMacro("__ARM_NEON_FP",
5492                           "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
5493     }
5494
5495     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
5496                         Opts.ShortWChar ? "2" : "4");
5497
5498     Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
5499                         Opts.ShortEnums ? "1" : "4");
5500
5501     if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {
5502       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
5503       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
5504       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
5505       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
5506     }
5507
5508     // ACLE 6.4.7 DSP instructions
5509     if (DSP) {
5510       Builder.defineMacro("__ARM_FEATURE_DSP", "1");
5511     }
5512
5513     // ACLE 6.4.8 Saturation instructions
5514     bool SAT = false;
5515     if ((ArchVersion == 6 && CPUProfile != "M") || ArchVersion > 6 ) {
5516       Builder.defineMacro("__ARM_FEATURE_SAT", "1");
5517       SAT = true;
5518     }
5519
5520     // ACLE 6.4.6 Q (saturation) flag
5521     if (DSP || SAT)
5522       Builder.defineMacro("__ARM_FEATURE_QBIT", "1");
5523
5524     if (Opts.UnsafeFPMath)
5525       Builder.defineMacro("__ARM_FP_FAST", "1");
5526
5527     if (ArchKind == llvm::ARM::AK_ARMV8_1A)
5528       Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
5529   }
5530
5531   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
5532     return llvm::makeArrayRef(BuiltinInfo,
5533                              clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin);
5534   }
5535   bool isCLZForZeroUndef() const override { return false; }
5536   BuiltinVaListKind getBuiltinVaListKind() const override {
5537     return IsAAPCS
5538                ? AAPCSABIBuiltinVaList
5539                : (getTriple().isWatchABI() ? TargetInfo::CharPtrBuiltinVaList
5540                                            : TargetInfo::VoidPtrBuiltinVaList);
5541   }
5542   ArrayRef<const char *> getGCCRegNames() const override;
5543   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
5544   bool validateAsmConstraint(const char *&Name,
5545                              TargetInfo::ConstraintInfo &Info) const override {
5546     switch (*Name) {
5547     default: break;
5548     case 'l': // r0-r7
5549     case 'h': // r8-r15
5550     case 't': // VFP Floating point register single precision
5551     case 'w': // VFP Floating point register double precision
5552       Info.setAllowsRegister();
5553       return true;
5554     case 'I':
5555     case 'J':
5556     case 'K':
5557     case 'L':
5558     case 'M':
5559       // FIXME
5560       return true;
5561     case 'Q': // A memory address that is a single base register.
5562       Info.setAllowsMemory();
5563       return true;
5564     case 'U': // a memory reference...
5565       switch (Name[1]) {
5566       case 'q': // ...ARMV4 ldrsb
5567       case 'v': // ...VFP load/store (reg+constant offset)
5568       case 'y': // ...iWMMXt load/store
5569       case 't': // address valid for load/store opaque types wider
5570                 // than 128-bits
5571       case 'n': // valid address for Neon doubleword vector load/store
5572       case 'm': // valid address for Neon element and structure load/store
5573       case 's': // valid address for non-offset loads/stores of quad-word
5574                 // values in four ARM registers
5575         Info.setAllowsMemory();
5576         Name++;
5577         return true;
5578       }
5579     }
5580     return false;
5581   }
5582   std::string convertConstraint(const char *&Constraint) const override {
5583     std::string R;
5584     switch (*Constraint) {
5585     case 'U':   // Two-character constraint; add "^" hint for later parsing.
5586       R = std::string("^") + std::string(Constraint, 2);
5587       Constraint++;
5588       break;
5589     case 'p': // 'p' should be translated to 'r' by default.
5590       R = std::string("r");
5591       break;
5592     default:
5593       return std::string(1, *Constraint);
5594     }
5595     return R;
5596   }
5597   bool
5598   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
5599                              std::string &SuggestedModifier) const override {
5600     bool isOutput = (Constraint[0] == '=');
5601     bool isInOut = (Constraint[0] == '+');
5602
5603     // Strip off constraint modifiers.
5604     while (Constraint[0] == '=' ||
5605            Constraint[0] == '+' ||
5606            Constraint[0] == '&')
5607       Constraint = Constraint.substr(1);
5608
5609     switch (Constraint[0]) {
5610     default: break;
5611     case 'r': {
5612       switch (Modifier) {
5613       default:
5614         return (isInOut || isOutput || Size <= 64);
5615       case 'q':
5616         // A register of size 32 cannot fit a vector type.
5617         return false;
5618       }
5619     }
5620     }
5621
5622     return true;
5623   }
5624   const char *getClobbers() const override {
5625     // FIXME: Is this really right?
5626     return "";
5627   }
5628
5629   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
5630     switch (CC) {
5631     case CC_AAPCS:
5632     case CC_AAPCS_VFP:
5633     case CC_Swift:
5634       return CCCR_OK;
5635     default:
5636       return CCCR_Warning;
5637     }
5638   }
5639
5640   int getEHDataRegisterNumber(unsigned RegNo) const override {
5641     if (RegNo == 0) return 0;
5642     if (RegNo == 1) return 1;
5643     return -1;
5644   }
5645
5646   bool hasSjLjLowering() const override {
5647     return true;
5648   }
5649 };
5650
5651 bool ARMTargetInfo::setFPMath(StringRef Name) {
5652   if (Name == "neon") {
5653     FPMath = FP_Neon;
5654     return true;
5655   } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
5656              Name == "vfp4") {
5657     FPMath = FP_VFP;
5658     return true;
5659   }
5660   return false;
5661 }
5662
5663 const char * const ARMTargetInfo::GCCRegNames[] = {
5664   // Integer registers
5665   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5666   "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
5667
5668   // Float registers
5669   "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
5670   "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
5671   "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
5672   "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
5673
5674   // Double registers
5675   "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
5676   "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
5677   "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
5678   "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
5679
5680   // Quad registers
5681   "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
5682   "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
5683 };
5684
5685 ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const {
5686   return llvm::makeArrayRef(GCCRegNames);
5687 }
5688
5689 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
5690   { { "a1" }, "r0" },
5691   { { "a2" }, "r1" },
5692   { { "a3" }, "r2" },
5693   { { "a4" }, "r3" },
5694   { { "v1" }, "r4" },
5695   { { "v2" }, "r5" },
5696   { { "v3" }, "r6" },
5697   { { "v4" }, "r7" },
5698   { { "v5" }, "r8" },
5699   { { "v6", "rfp" }, "r9" },
5700   { { "sl" }, "r10" },
5701   { { "fp" }, "r11" },
5702   { { "ip" }, "r12" },
5703   { { "r13" }, "sp" },
5704   { { "r14" }, "lr" },
5705   { { "r15" }, "pc" },
5706   // The S, D and Q registers overlap, but aren't really aliases; we
5707   // don't want to substitute one of these for a different-sized one.
5708 };
5709
5710 ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const {
5711   return llvm::makeArrayRef(GCCRegAliases);
5712 }
5713
5714 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
5715 #define BUILTIN(ID, TYPE, ATTRS) \
5716   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5717 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5718   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
5719 #include "clang/Basic/BuiltinsNEON.def"
5720
5721 #define BUILTIN(ID, TYPE, ATTRS) \
5722   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5723 #define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
5724   { #ID, TYPE, ATTRS, nullptr, LANG, nullptr },
5725 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5726   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
5727 #define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
5728   { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
5729 #include "clang/Basic/BuiltinsARM.def"
5730 };
5731
5732 class ARMleTargetInfo : public ARMTargetInfo {
5733 public:
5734   ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5735       : ARMTargetInfo(Triple, Opts) {}
5736   void getTargetDefines(const LangOptions &Opts,
5737                         MacroBuilder &Builder) const override {
5738     Builder.defineMacro("__ARMEL__");
5739     ARMTargetInfo::getTargetDefines(Opts, Builder);
5740   }
5741 };
5742
5743 class ARMbeTargetInfo : public ARMTargetInfo {
5744 public:
5745   ARMbeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5746       : ARMTargetInfo(Triple, Opts) {}
5747   void getTargetDefines(const LangOptions &Opts,
5748                         MacroBuilder &Builder) const override {
5749     Builder.defineMacro("__ARMEB__");
5750     Builder.defineMacro("__ARM_BIG_ENDIAN");
5751     ARMTargetInfo::getTargetDefines(Opts, Builder);
5752   }
5753 };
5754
5755 class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
5756   const llvm::Triple Triple;
5757 public:
5758   WindowsARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5759       : WindowsTargetInfo<ARMleTargetInfo>(Triple, Opts), Triple(Triple) {
5760     WCharType = UnsignedShort;
5761     SizeType = UnsignedInt;
5762   }
5763   void getVisualStudioDefines(const LangOptions &Opts,
5764                               MacroBuilder &Builder) const {
5765     WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
5766
5767     // FIXME: this is invalid for WindowsCE
5768     Builder.defineMacro("_M_ARM_NT", "1");
5769     Builder.defineMacro("_M_ARMT", "_M_ARM");
5770     Builder.defineMacro("_M_THUMB", "_M_ARM");
5771
5772     assert((Triple.getArch() == llvm::Triple::arm ||
5773             Triple.getArch() == llvm::Triple::thumb) &&
5774            "invalid architecture for Windows ARM target info");
5775     unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5776     Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
5777
5778     // TODO map the complete set of values
5779     // 31: VFPv3 40: VFPv4
5780     Builder.defineMacro("_M_ARM_FP", "31");
5781   }
5782   BuiltinVaListKind getBuiltinVaListKind() const override {
5783     return TargetInfo::CharPtrBuiltinVaList;
5784   }
5785   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
5786     switch (CC) {
5787     case CC_X86StdCall:
5788     case CC_X86ThisCall:
5789     case CC_X86FastCall:
5790     case CC_X86VectorCall:
5791       return CCCR_Ignore;
5792     case CC_C:
5793       return CCCR_OK;
5794     default:
5795       return CCCR_Warning;
5796     }
5797   }
5798 };
5799
5800 // Windows ARM + Itanium C++ ABI Target
5801 class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
5802 public:
5803   ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple,
5804                                 const TargetOptions &Opts)
5805       : WindowsARMTargetInfo(Triple, Opts) {
5806     TheCXXABI.set(TargetCXXABI::GenericARM);
5807   }
5808
5809   void getTargetDefines(const LangOptions &Opts,
5810                         MacroBuilder &Builder) const override {
5811     WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5812
5813     if (Opts.MSVCCompat)
5814       WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5815   }
5816 };
5817
5818 // Windows ARM, MS (C++) ABI
5819 class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
5820 public:
5821   MicrosoftARMleTargetInfo(const llvm::Triple &Triple,
5822                            const TargetOptions &Opts)
5823       : WindowsARMTargetInfo(Triple, Opts) {
5824     TheCXXABI.set(TargetCXXABI::Microsoft);
5825   }
5826
5827   void getTargetDefines(const LangOptions &Opts,
5828                         MacroBuilder &Builder) const override {
5829     WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5830     WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5831   }
5832 };
5833
5834 // ARM MinGW target
5835 class MinGWARMTargetInfo : public WindowsARMTargetInfo {
5836 public:
5837   MinGWARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5838       : WindowsARMTargetInfo(Triple, Opts) {
5839     TheCXXABI.set(TargetCXXABI::GenericARM);
5840   }
5841
5842   void getTargetDefines(const LangOptions &Opts,
5843                         MacroBuilder &Builder) const override {
5844     WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5845     DefineStd(Builder, "WIN32", Opts);
5846     DefineStd(Builder, "WINNT", Opts);
5847     Builder.defineMacro("_ARM_");
5848     addMinGWDefines(Opts, Builder);
5849   }
5850 };
5851
5852 // ARM Cygwin target
5853 class CygwinARMTargetInfo : public ARMleTargetInfo {
5854 public:
5855   CygwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5856       : ARMleTargetInfo(Triple, Opts) {
5857     TLSSupported = false;
5858     WCharType = UnsignedShort;
5859     DoubleAlign = LongLongAlign = 64;
5860     resetDataLayout("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
5861   }
5862   void getTargetDefines(const LangOptions &Opts,
5863                         MacroBuilder &Builder) const override {
5864     ARMleTargetInfo::getTargetDefines(Opts, Builder);
5865     Builder.defineMacro("_ARM_");
5866     Builder.defineMacro("__CYGWIN__");
5867     Builder.defineMacro("__CYGWIN32__");
5868     DefineStd(Builder, "unix", Opts);
5869     if (Opts.CPlusPlus)
5870       Builder.defineMacro("_GNU_SOURCE");
5871   }
5872 };
5873
5874 class DarwinARMTargetInfo : public DarwinTargetInfo<ARMleTargetInfo> {
5875 protected:
5876   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
5877                     MacroBuilder &Builder) const override {
5878     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
5879   }
5880
5881 public:
5882   DarwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5883       : DarwinTargetInfo<ARMleTargetInfo>(Triple, Opts) {
5884     HasAlignMac68kSupport = true;
5885     // iOS always has 64-bit atomic instructions.
5886     // FIXME: This should be based off of the target features in
5887     // ARMleTargetInfo.
5888     MaxAtomicInlineWidth = 64;
5889
5890     if (Triple.isWatchABI()) {
5891       // Darwin on iOS uses a variant of the ARM C++ ABI.
5892       TheCXXABI.set(TargetCXXABI::WatchOS);
5893
5894       // The 32-bit ABI is silent on what ptrdiff_t should be, but given that
5895       // size_t is long, it's a bit weird for it to be int.
5896       PtrDiffType = SignedLong;
5897
5898       // BOOL should be a real boolean on the new ABI
5899       UseSignedCharForObjCBool = false;
5900     } else
5901       TheCXXABI.set(TargetCXXABI::iOS);
5902   }
5903 };
5904
5905 class AArch64TargetInfo : public TargetInfo {
5906   virtual void setDataLayout() = 0;
5907   static const TargetInfo::GCCRegAlias GCCRegAliases[];
5908   static const char *const GCCRegNames[];
5909
5910   enum FPUModeEnum {
5911     FPUMode,
5912     NeonMode
5913   };
5914
5915   unsigned FPU;
5916   unsigned CRC;
5917   unsigned Crypto;
5918   unsigned Unaligned;
5919   unsigned V8_1A;
5920
5921   static const Builtin::Info BuiltinInfo[];
5922
5923   std::string ABI;
5924
5925 public:
5926   AArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5927       : TargetInfo(Triple), ABI("aapcs") {
5928     if (getTriple().getOS() == llvm::Triple::NetBSD) {
5929       WCharType = SignedInt;
5930
5931       // NetBSD apparently prefers consistency across ARM targets to consistency
5932       // across 64-bit targets.
5933       Int64Type = SignedLongLong;
5934       IntMaxType = SignedLongLong;
5935     } else {
5936       WCharType = UnsignedInt;
5937       Int64Type = SignedLong;
5938       IntMaxType = SignedLong;
5939     }
5940
5941     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
5942     MaxVectorAlign = 128;
5943     MaxAtomicInlineWidth = 128;
5944     MaxAtomicPromoteWidth = 128;
5945
5946     LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
5947     LongDoubleFormat = &llvm::APFloat::IEEEquad();
5948
5949     // {} in inline assembly are neon specifiers, not assembly variant
5950     // specifiers.
5951     NoAsmVariants = true;
5952
5953     // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
5954     // contributes to the alignment of the containing aggregate in the same way
5955     // a plain (non bit-field) member of that type would, without exception for
5956     // zero-sized or anonymous bit-fields."
5957     assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
5958     UseZeroLengthBitfieldAlignment = true;
5959
5960     // AArch64 targets default to using the ARM C++ ABI.
5961     TheCXXABI.set(TargetCXXABI::GenericAArch64);
5962
5963     if (Triple.getOS() == llvm::Triple::Linux ||
5964         Triple.getOS() == llvm::Triple::UnknownOS)
5965       this->MCountName = Opts.EABIVersion == "gnu" ? "\01_mcount" : "mcount";
5966   }
5967
5968   StringRef getABI() const override { return ABI; }
5969   bool setABI(const std::string &Name) override {
5970     if (Name != "aapcs" && Name != "darwinpcs")
5971       return false;
5972
5973     ABI = Name;
5974     return true;
5975   }
5976
5977   bool setCPU(const std::string &Name) override {
5978     return Name == "generic" ||
5979            llvm::AArch64::parseCPUArch(Name) !=
5980            static_cast<unsigned>(llvm::AArch64::ArchKind::AK_INVALID);
5981   }
5982
5983   void getTargetDefines(const LangOptions &Opts,
5984                         MacroBuilder &Builder) const override {
5985     // Target identification.
5986     Builder.defineMacro("__aarch64__");
5987
5988     // Target properties.
5989     Builder.defineMacro("_LP64");
5990     Builder.defineMacro("__LP64__");
5991
5992     // ACLE predefines. Many can only have one possible value on v8 AArch64.
5993     Builder.defineMacro("__ARM_ACLE", "200");
5994     Builder.defineMacro("__ARM_ARCH", "8");
5995     Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
5996
5997     Builder.defineMacro("__ARM_64BIT_STATE", "1");
5998     Builder.defineMacro("__ARM_PCS_AAPCS64", "1");
5999     Builder.defineMacro("__ARM_ARCH_ISA_A64", "1");
6000
6001     Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
6002     Builder.defineMacro("__ARM_FEATURE_FMA", "1");
6003     Builder.defineMacro("__ARM_FEATURE_LDREX", "0xF");
6004     Builder.defineMacro("__ARM_FEATURE_IDIV", "1"); // As specified in ACLE
6005     Builder.defineMacro("__ARM_FEATURE_DIV");  // For backwards compatibility
6006     Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
6007     Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
6008
6009     Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
6010
6011     // 0xe implies support for half, single and double precision operations.
6012     Builder.defineMacro("__ARM_FP", "0xE");
6013
6014     // PCS specifies this for SysV variants, which is all we support. Other ABIs
6015     // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
6016     Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
6017     Builder.defineMacro("__ARM_FP16_ARGS", "1");
6018
6019     if (Opts.UnsafeFPMath)
6020       Builder.defineMacro("__ARM_FP_FAST", "1");
6021
6022     Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
6023
6024     Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
6025                         Opts.ShortEnums ? "1" : "4");
6026
6027     if (FPU == NeonMode) {
6028       Builder.defineMacro("__ARM_NEON", "1");
6029       // 64-bit NEON supports half, single and double precision operations.
6030       Builder.defineMacro("__ARM_NEON_FP", "0xE");
6031     }
6032
6033     if (CRC)
6034       Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
6035
6036     if (Crypto)
6037       Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
6038
6039     if (Unaligned)
6040       Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
6041
6042     if (V8_1A)
6043       Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
6044
6045     // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8) builtins work.
6046     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
6047     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
6048     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
6049     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
6050   }
6051
6052   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6053     return llvm::makeArrayRef(BuiltinInfo,
6054                        clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin);
6055   }
6056
6057   bool hasFeature(StringRef Feature) const override {
6058     return Feature == "aarch64" ||
6059       Feature == "arm64" ||
6060       Feature == "arm" ||
6061       (Feature == "neon" && FPU == NeonMode);
6062   }
6063
6064   bool handleTargetFeatures(std::vector<std::string> &Features,
6065                             DiagnosticsEngine &Diags) override {
6066     FPU = FPUMode;
6067     CRC = 0;
6068     Crypto = 0;
6069     Unaligned = 1;
6070     V8_1A = 0;
6071
6072     for (const auto &Feature : Features) {
6073       if (Feature == "+neon")
6074         FPU = NeonMode;
6075       if (Feature == "+crc")
6076         CRC = 1;
6077       if (Feature == "+crypto")
6078         Crypto = 1;
6079       if (Feature == "+strict-align")
6080         Unaligned = 0;
6081       if (Feature == "+v8.1a")
6082         V8_1A = 1;
6083     }
6084
6085     setDataLayout();
6086
6087     return true;
6088   }
6089
6090   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
6091     switch (CC) {
6092     case CC_C:
6093     case CC_Swift:
6094     case CC_PreserveMost:
6095     case CC_PreserveAll:
6096       return CCCR_OK;
6097     default:
6098       return CCCR_Warning;
6099     }
6100   }
6101
6102   bool isCLZForZeroUndef() const override { return false; }
6103
6104   BuiltinVaListKind getBuiltinVaListKind() const override {
6105     return TargetInfo::AArch64ABIBuiltinVaList;
6106   }
6107
6108   ArrayRef<const char *> getGCCRegNames() const override;
6109   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
6110
6111   bool validateAsmConstraint(const char *&Name,
6112                              TargetInfo::ConstraintInfo &Info) const override {
6113     switch (*Name) {
6114     default:
6115       return false;
6116     case 'w': // Floating point and SIMD registers (V0-V31)
6117       Info.setAllowsRegister();
6118       return true;
6119     case 'I': // Constant that can be used with an ADD instruction
6120     case 'J': // Constant that can be used with a SUB instruction
6121     case 'K': // Constant that can be used with a 32-bit logical instruction
6122     case 'L': // Constant that can be used with a 64-bit logical instruction
6123     case 'M': // Constant that can be used as a 32-bit MOV immediate
6124     case 'N': // Constant that can be used as a 64-bit MOV immediate
6125     case 'Y': // Floating point constant zero
6126     case 'Z': // Integer constant zero
6127       return true;
6128     case 'Q': // A memory reference with base register and no offset
6129       Info.setAllowsMemory();
6130       return true;
6131     case 'S': // A symbolic address
6132       Info.setAllowsRegister();
6133       return true;
6134     case 'U':
6135       // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
6136       // Utf: A memory address suitable for ldp/stp in TF mode.
6137       // Usa: An absolute symbolic address.
6138       // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
6139       llvm_unreachable("FIXME: Unimplemented support for U* constraints.");
6140     case 'z': // Zero register, wzr or xzr
6141       Info.setAllowsRegister();
6142       return true;
6143     case 'x': // Floating point and SIMD registers (V0-V15)
6144       Info.setAllowsRegister();
6145       return true;
6146     }
6147     return false;
6148   }
6149
6150   bool
6151   validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
6152                              std::string &SuggestedModifier) const override {
6153     // Strip off constraint modifiers.
6154     while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
6155       Constraint = Constraint.substr(1);
6156
6157     switch (Constraint[0]) {
6158     default:
6159       return true;
6160     case 'z':
6161     case 'r': {
6162       switch (Modifier) {
6163       case 'x':
6164       case 'w':
6165         // For now assume that the person knows what they're
6166         // doing with the modifier.
6167         return true;
6168       default:
6169         // By default an 'r' constraint will be in the 'x'
6170         // registers.
6171         if (Size == 64)
6172           return true;
6173
6174         SuggestedModifier = "w";
6175         return false;
6176       }
6177     }
6178     }
6179   }
6180
6181   const char *getClobbers() const override { return ""; }
6182
6183   int getEHDataRegisterNumber(unsigned RegNo) const override {
6184     if (RegNo == 0)
6185       return 0;
6186     if (RegNo == 1)
6187       return 1;
6188     return -1;
6189   }
6190 };
6191
6192 const char *const AArch64TargetInfo::GCCRegNames[] = {
6193   // 32-bit Integer registers
6194   "w0",  "w1",  "w2",  "w3",  "w4",  "w5",  "w6",  "w7",  "w8",  "w9",  "w10",
6195   "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
6196   "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
6197
6198   // 64-bit Integer registers
6199   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",  "x8",  "x9",  "x10",
6200   "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
6201   "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp",  "lr",  "sp",
6202
6203   // 32-bit floating point regsisters
6204   "s0",  "s1",  "s2",  "s3",  "s4",  "s5",  "s6",  "s7",  "s8",  "s9",  "s10",
6205   "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
6206   "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
6207
6208   // 64-bit floating point regsisters
6209   "d0",  "d1",  "d2",  "d3",  "d4",  "d5",  "d6",  "d7",  "d8",  "d9",  "d10",
6210   "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
6211   "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
6212
6213   // Vector registers
6214   "v0",  "v1",  "v2",  "v3",  "v4",  "v5",  "v6",  "v7",  "v8",  "v9",  "v10",
6215   "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
6216   "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
6217 };
6218
6219 ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const {
6220   return llvm::makeArrayRef(GCCRegNames);
6221 }
6222
6223 const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
6224   { { "w31" }, "wsp" },
6225   { { "x29" }, "fp" },
6226   { { "x30" }, "lr" },
6227   { { "x31" }, "sp" },
6228   // The S/D/Q and W/X registers overlap, but aren't really aliases; we
6229   // don't want to substitute one of these for a different-sized one.
6230 };
6231
6232 ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const {
6233   return llvm::makeArrayRef(GCCRegAliases);
6234 }
6235
6236 const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
6237 #define BUILTIN(ID, TYPE, ATTRS)                                               \
6238   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6239 #include "clang/Basic/BuiltinsNEON.def"
6240
6241 #define BUILTIN(ID, TYPE, ATTRS)                                               \
6242   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6243 #include "clang/Basic/BuiltinsAArch64.def"
6244 };
6245
6246 class AArch64leTargetInfo : public AArch64TargetInfo {
6247   void setDataLayout() override {
6248     if (getTriple().isOSBinFormatMachO())
6249       resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128");
6250     else
6251       resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
6252   }
6253
6254 public:
6255   AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6256       : AArch64TargetInfo(Triple, Opts) {
6257   }
6258   void getTargetDefines(const LangOptions &Opts,
6259                         MacroBuilder &Builder) const override {
6260     Builder.defineMacro("__AARCH64EL__");
6261     AArch64TargetInfo::getTargetDefines(Opts, Builder);
6262   }
6263 };
6264
6265 class AArch64beTargetInfo : public AArch64TargetInfo {
6266   void setDataLayout() override {
6267     assert(!getTriple().isOSBinFormatMachO());
6268     resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
6269   }
6270
6271 public:
6272   AArch64beTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6273       : AArch64TargetInfo(Triple, Opts) {}
6274   void getTargetDefines(const LangOptions &Opts,
6275                         MacroBuilder &Builder) const override {
6276     Builder.defineMacro("__AARCH64EB__");
6277     Builder.defineMacro("__AARCH_BIG_ENDIAN");
6278     Builder.defineMacro("__ARM_BIG_ENDIAN");
6279     AArch64TargetInfo::getTargetDefines(Opts, Builder);
6280   }
6281 };
6282
6283 class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
6284 protected:
6285   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
6286                     MacroBuilder &Builder) const override {
6287     Builder.defineMacro("__AARCH64_SIMD__");
6288     Builder.defineMacro("__ARM64_ARCH_8__");
6289     Builder.defineMacro("__ARM_NEON__");
6290     Builder.defineMacro("__LITTLE_ENDIAN__");
6291     Builder.defineMacro("__REGISTER_PREFIX__", "");
6292     Builder.defineMacro("__arm64", "1");
6293     Builder.defineMacro("__arm64__", "1");
6294
6295     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
6296   }
6297
6298 public:
6299   DarwinAArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6300       : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
6301     Int64Type = SignedLongLong;
6302     WCharType = SignedInt;
6303     UseSignedCharForObjCBool = false;
6304
6305     LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
6306     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
6307
6308     TheCXXABI.set(TargetCXXABI::iOS64);
6309   }
6310
6311   BuiltinVaListKind getBuiltinVaListKind() const override {
6312     return TargetInfo::CharPtrBuiltinVaList;
6313   }
6314 };
6315
6316 // Hexagon abstract base class
6317 class HexagonTargetInfo : public TargetInfo {
6318   static const Builtin::Info BuiltinInfo[];
6319   static const char * const GCCRegNames[];
6320   static const TargetInfo::GCCRegAlias GCCRegAliases[];
6321   std::string CPU;
6322   bool HasHVX, HasHVXDouble;
6323   bool UseLongCalls;
6324
6325 public:
6326   HexagonTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
6327       : TargetInfo(Triple) {
6328     // Specify the vector alignment explicitly. For v512x1, the calculated
6329     // alignment would be 512*alignment(i1), which is 512 bytes, instead of
6330     // the required minimum of 64 bytes.
6331     resetDataLayout("e-m:e-p:32:32:32-a:0-n16:32-"
6332         "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
6333         "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
6334     SizeType    = UnsignedInt;
6335     PtrDiffType = SignedInt;
6336     IntPtrType  = SignedInt;
6337
6338     // {} in inline assembly are packet specifiers, not assembly variant
6339     // specifiers.
6340     NoAsmVariants = true;
6341
6342     LargeArrayMinWidth = 64;
6343     LargeArrayAlign = 64;
6344     UseBitFieldTypeAlignment = true;
6345     ZeroLengthBitfieldBoundary = 32;
6346     HasHVX = HasHVXDouble = false;
6347     UseLongCalls = false;
6348   }
6349
6350   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6351     return llvm::makeArrayRef(BuiltinInfo,
6352                          clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin);
6353   }
6354
6355   bool validateAsmConstraint(const char *&Name,
6356                              TargetInfo::ConstraintInfo &Info) const override {
6357     switch (*Name) {
6358       case 'v':
6359       case 'q':
6360         if (HasHVX) {
6361           Info.setAllowsRegister();
6362           return true;
6363         }
6364         break;
6365       case 's':
6366         // Relocatable constant.
6367         return true;
6368     }
6369     return false;
6370   }
6371
6372   void getTargetDefines(const LangOptions &Opts,
6373                         MacroBuilder &Builder) const override;
6374
6375   bool isCLZForZeroUndef() const override { return false; }
6376
6377   bool hasFeature(StringRef Feature) const override {
6378     return llvm::StringSwitch<bool>(Feature)
6379       .Case("hexagon", true)
6380       .Case("hvx", HasHVX)
6381       .Case("hvx-double", HasHVXDouble)
6382       .Case("long-calls", UseLongCalls)
6383       .Default(false);
6384   }
6385
6386   bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
6387         StringRef CPU, const std::vector<std::string> &FeaturesVec)
6388         const override;
6389
6390   bool handleTargetFeatures(std::vector<std::string> &Features,
6391                             DiagnosticsEngine &Diags) override;
6392
6393   void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
6394                          bool Enabled) const override;
6395
6396   BuiltinVaListKind getBuiltinVaListKind() const override {
6397     return TargetInfo::CharPtrBuiltinVaList;
6398   }
6399   ArrayRef<const char *> getGCCRegNames() const override;
6400   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
6401   const char *getClobbers() const override {
6402     return "";
6403   }
6404
6405   static const char *getHexagonCPUSuffix(StringRef Name) {
6406     return llvm::StringSwitch<const char*>(Name)
6407       .Case("hexagonv4", "4")
6408       .Case("hexagonv5", "5")
6409       .Case("hexagonv55", "55")
6410       .Case("hexagonv60", "60")
6411       .Default(nullptr);
6412   }
6413
6414   bool setCPU(const std::string &Name) override {
6415     if (!getHexagonCPUSuffix(Name))
6416       return false;
6417     CPU = Name;
6418     return true;
6419   }
6420
6421   int getEHDataRegisterNumber(unsigned RegNo) const override {
6422     return RegNo < 2 ? RegNo : -1;
6423   }
6424 };
6425
6426 void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
6427                                          MacroBuilder &Builder) const {
6428   Builder.defineMacro("__qdsp6__", "1");
6429   Builder.defineMacro("__hexagon__", "1");
6430
6431   if (CPU == "hexagonv4") {
6432     Builder.defineMacro("__HEXAGON_V4__");
6433     Builder.defineMacro("__HEXAGON_ARCH__", "4");
6434     if (Opts.HexagonQdsp6Compat) {
6435       Builder.defineMacro("__QDSP6_V4__");
6436       Builder.defineMacro("__QDSP6_ARCH__", "4");
6437     }
6438   } else if (CPU == "hexagonv5") {
6439     Builder.defineMacro("__HEXAGON_V5__");
6440     Builder.defineMacro("__HEXAGON_ARCH__", "5");
6441     if(Opts.HexagonQdsp6Compat) {
6442       Builder.defineMacro("__QDSP6_V5__");
6443       Builder.defineMacro("__QDSP6_ARCH__", "5");
6444     }
6445   } else if (CPU == "hexagonv55") {
6446     Builder.defineMacro("__HEXAGON_V55__");
6447     Builder.defineMacro("__HEXAGON_ARCH__", "55");
6448     Builder.defineMacro("__QDSP6_V55__");
6449     Builder.defineMacro("__QDSP6_ARCH__", "55");
6450   } else if (CPU == "hexagonv60") {
6451     Builder.defineMacro("__HEXAGON_V60__");
6452     Builder.defineMacro("__HEXAGON_ARCH__", "60");
6453     Builder.defineMacro("__QDSP6_V60__");
6454     Builder.defineMacro("__QDSP6_ARCH__", "60");
6455   }
6456
6457   if (hasFeature("hvx")) {
6458     Builder.defineMacro("__HVX__");
6459     if (hasFeature("hvx-double"))
6460       Builder.defineMacro("__HVXDBL__");
6461   }
6462 }
6463
6464 bool HexagonTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features,
6465       DiagnosticsEngine &Diags, StringRef CPU,
6466       const std::vector<std::string> &FeaturesVec) const {
6467   // Default for v60: -hvx, -hvx-double.
6468   Features["hvx"] = false;
6469   Features["hvx-double"] = false;
6470   Features["long-calls"] = false;
6471
6472   return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
6473 }
6474
6475 bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
6476                                              DiagnosticsEngine &Diags) {
6477   for (auto &F : Features) {
6478     if (F == "+hvx")
6479       HasHVX = true;
6480     else if (F == "-hvx")
6481       HasHVX = HasHVXDouble = false;
6482     else if (F == "+hvx-double")
6483       HasHVX = HasHVXDouble = true;
6484     else if (F == "-hvx-double")
6485       HasHVXDouble = false;
6486
6487     if (F == "+long-calls")
6488       UseLongCalls = true;
6489     else if (F == "-long-calls")
6490       UseLongCalls = false;
6491   }
6492   return true;
6493 }
6494
6495 void HexagonTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
6496       StringRef Name, bool Enabled) const {
6497   if (Enabled) {
6498     if (Name == "hvx-double")
6499       Features["hvx"] = true;
6500   } else {
6501     if (Name == "hvx")
6502       Features["hvx-double"] = false;
6503   }
6504   Features[Name] = Enabled;
6505 }
6506
6507 const char *const HexagonTargetInfo::GCCRegNames[] = {
6508   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6509   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6510   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
6511   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
6512   "p0", "p1", "p2", "p3",
6513   "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
6514 };
6515
6516 ArrayRef<const char*> HexagonTargetInfo::getGCCRegNames() const {
6517   return llvm::makeArrayRef(GCCRegNames);
6518 }
6519
6520 const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
6521   { { "sp" }, "r29" },
6522   { { "fp" }, "r30" },
6523   { { "lr" }, "r31" },
6524 };
6525
6526 ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
6527   return llvm::makeArrayRef(GCCRegAliases);
6528 }
6529
6530
6531 const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
6532 #define BUILTIN(ID, TYPE, ATTRS) \
6533   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6534 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
6535   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
6536 #include "clang/Basic/BuiltinsHexagon.def"
6537 };
6538
6539 class LanaiTargetInfo : public TargetInfo {
6540   // Class for Lanai (32-bit).
6541   // The CPU profiles supported by the Lanai backend
6542   enum CPUKind {
6543     CK_NONE,
6544     CK_V11,
6545   } CPU;
6546
6547   static const TargetInfo::GCCRegAlias GCCRegAliases[];
6548   static const char *const GCCRegNames[];
6549
6550 public:
6551   LanaiTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
6552       : TargetInfo(Triple) {
6553     // Description string has to be kept in sync with backend.
6554     resetDataLayout("E"        // Big endian
6555                     "-m:e"     // ELF name manging
6556                     "-p:32:32" // 32 bit pointers, 32 bit aligned
6557                     "-i64:64"  // 64 bit integers, 64 bit aligned
6558                     "-a:0:32"  // 32 bit alignment of objects of aggregate type
6559                     "-n32"     // 32 bit native integer width
6560                     "-S64"     // 64 bit natural stack alignment
6561                     );
6562
6563     // Setting RegParmMax equal to what mregparm was set to in the old
6564     // toolchain
6565     RegParmMax = 4;
6566
6567     // Set the default CPU to V11
6568     CPU = CK_V11;
6569
6570     // Temporary approach to make everything at least word-aligned and allow for
6571     // safely casting between pointers with different alignment requirements.
6572     // TODO: Remove this when there are no more cast align warnings on the
6573     // firmware.
6574     MinGlobalAlign = 32;
6575   }
6576
6577   void getTargetDefines(const LangOptions &Opts,
6578                         MacroBuilder &Builder) const override {
6579     // Define __lanai__ when building for target lanai.
6580     Builder.defineMacro("__lanai__");
6581
6582     // Set define for the CPU specified.
6583     switch (CPU) {
6584     case CK_V11:
6585       Builder.defineMacro("__LANAI_V11__");
6586       break;
6587     case CK_NONE:
6588       llvm_unreachable("Unhandled target CPU");
6589     }
6590   }
6591
6592   bool setCPU(const std::string &Name) override {
6593     CPU = llvm::StringSwitch<CPUKind>(Name)
6594               .Case("v11", CK_V11)
6595               .Default(CK_NONE);
6596
6597     return CPU != CK_NONE;
6598   }
6599
6600   bool hasFeature(StringRef Feature) const override {
6601     return llvm::StringSwitch<bool>(Feature).Case("lanai", true).Default(false);
6602   }
6603
6604   ArrayRef<const char *> getGCCRegNames() const override;
6605
6606   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
6607
6608   BuiltinVaListKind getBuiltinVaListKind() const override {
6609     return TargetInfo::VoidPtrBuiltinVaList;
6610   }
6611
6612   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
6613
6614   bool validateAsmConstraint(const char *&Name,
6615                              TargetInfo::ConstraintInfo &info) const override {
6616     return false;
6617   }
6618
6619   const char *getClobbers() const override { return ""; }
6620 };
6621
6622 const char *const LanaiTargetInfo::GCCRegNames[] = {
6623     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",  "r8",  "r9",  "r10",
6624     "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21",
6625     "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"};
6626
6627 ArrayRef<const char *> LanaiTargetInfo::getGCCRegNames() const {
6628   return llvm::makeArrayRef(GCCRegNames);
6629 }
6630
6631 const TargetInfo::GCCRegAlias LanaiTargetInfo::GCCRegAliases[] = {
6632     {{"pc"}, "r2"},
6633     {{"sp"}, "r4"},
6634     {{"fp"}, "r5"},
6635     {{"rv"}, "r8"},
6636     {{"rr1"}, "r10"},
6637     {{"rr2"}, "r11"},
6638     {{"rca"}, "r15"},
6639 };
6640
6641 ArrayRef<TargetInfo::GCCRegAlias> LanaiTargetInfo::getGCCRegAliases() const {
6642   return llvm::makeArrayRef(GCCRegAliases);
6643 }
6644
6645 // Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
6646 class SparcTargetInfo : public TargetInfo {
6647   static const TargetInfo::GCCRegAlias GCCRegAliases[];
6648   static const char * const GCCRegNames[];
6649   bool SoftFloat;
6650 public:
6651   SparcTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
6652       : TargetInfo(Triple), SoftFloat(false) {}
6653
6654   int getEHDataRegisterNumber(unsigned RegNo) const override {
6655     if (RegNo == 0) return 24;
6656     if (RegNo == 1) return 25;
6657     return -1;
6658   }
6659
6660   bool handleTargetFeatures(std::vector<std::string> &Features,
6661                             DiagnosticsEngine &Diags) override {
6662     // Check if software floating point is enabled
6663     auto Feature = std::find(Features.begin(), Features.end(), "+soft-float");
6664     if (Feature != Features.end()) {
6665       SoftFloat = true;
6666     }
6667     return true;
6668   }
6669   void getTargetDefines(const LangOptions &Opts,
6670                         MacroBuilder &Builder) const override {
6671     DefineStd(Builder, "sparc", Opts);
6672     Builder.defineMacro("__REGISTER_PREFIX__", "");
6673
6674     if (SoftFloat)
6675       Builder.defineMacro("SOFT_FLOAT", "1");
6676   }
6677
6678   bool hasFeature(StringRef Feature) const override {
6679     return llvm::StringSwitch<bool>(Feature)
6680              .Case("softfloat", SoftFloat)
6681              .Case("sparc", true)
6682              .Default(false);
6683   }
6684
6685   bool hasSjLjLowering() const override {
6686     return true;
6687   }
6688
6689   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6690     // FIXME: Implement!
6691     return None;
6692   }
6693   BuiltinVaListKind getBuiltinVaListKind() const override {
6694     return TargetInfo::VoidPtrBuiltinVaList;
6695   }
6696   ArrayRef<const char *> getGCCRegNames() const override;
6697   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
6698   bool validateAsmConstraint(const char *&Name,
6699                              TargetInfo::ConstraintInfo &info) const override {
6700     // FIXME: Implement!
6701     switch (*Name) {
6702     case 'I': // Signed 13-bit constant
6703     case 'J': // Zero
6704     case 'K': // 32-bit constant with the low 12 bits clear
6705     case 'L': // A constant in the range supported by movcc (11-bit signed imm)
6706     case 'M': // A constant in the range supported by movrcc (19-bit signed imm)
6707     case 'N': // Same as 'K' but zext (required for SIMode)
6708     case 'O': // The constant 4096
6709       return true;
6710     }
6711     return false;
6712   }
6713   const char *getClobbers() const override {
6714     // FIXME: Implement!
6715     return "";
6716   }
6717
6718   // No Sparc V7 for now, the backend doesn't support it anyway.
6719   enum CPUKind {
6720     CK_GENERIC,
6721     CK_V8,
6722     CK_SUPERSPARC,
6723     CK_SPARCLITE,
6724     CK_F934,
6725     CK_HYPERSPARC,
6726     CK_SPARCLITE86X,
6727     CK_SPARCLET,
6728     CK_TSC701,
6729     CK_V9,
6730     CK_ULTRASPARC,
6731     CK_ULTRASPARC3,
6732     CK_NIAGARA,
6733     CK_NIAGARA2,
6734     CK_NIAGARA3,
6735     CK_NIAGARA4,
6736     CK_MYRIAD2100,
6737     CK_MYRIAD2150,
6738     CK_MYRIAD2450,
6739     CK_LEON2,
6740     CK_LEON2_AT697E,
6741     CK_LEON2_AT697F,
6742     CK_LEON3,
6743     CK_LEON3_UT699,
6744     CK_LEON3_GR712RC,
6745     CK_LEON4,
6746     CK_LEON4_GR740
6747   } CPU = CK_GENERIC;
6748
6749   enum CPUGeneration {
6750     CG_V8,
6751     CG_V9,
6752   };
6753
6754   CPUGeneration getCPUGeneration(CPUKind Kind) const {
6755     switch (Kind) {
6756     case CK_GENERIC:
6757     case CK_V8:
6758     case CK_SUPERSPARC:
6759     case CK_SPARCLITE:
6760     case CK_F934:
6761     case CK_HYPERSPARC:
6762     case CK_SPARCLITE86X:
6763     case CK_SPARCLET:
6764     case CK_TSC701:
6765     case CK_MYRIAD2100:
6766     case CK_MYRIAD2150:
6767     case CK_MYRIAD2450:
6768     case CK_LEON2:
6769     case CK_LEON2_AT697E:
6770     case CK_LEON2_AT697F:
6771     case CK_LEON3:
6772     case CK_LEON3_UT699:
6773     case CK_LEON3_GR712RC:
6774     case CK_LEON4:
6775     case CK_LEON4_GR740:
6776       return CG_V8;
6777     case CK_V9:
6778     case CK_ULTRASPARC:
6779     case CK_ULTRASPARC3:
6780     case CK_NIAGARA:
6781     case CK_NIAGARA2:
6782     case CK_NIAGARA3:
6783     case CK_NIAGARA4:
6784       return CG_V9;
6785     }
6786     llvm_unreachable("Unexpected CPU kind");
6787   }
6788
6789   CPUKind getCPUKind(StringRef Name) const {
6790     return llvm::StringSwitch<CPUKind>(Name)
6791         .Case("v8", CK_V8)
6792         .Case("supersparc", CK_SUPERSPARC)
6793         .Case("sparclite", CK_SPARCLITE)
6794         .Case("f934", CK_F934)
6795         .Case("hypersparc", CK_HYPERSPARC)
6796         .Case("sparclite86x", CK_SPARCLITE86X)
6797         .Case("sparclet", CK_SPARCLET)
6798         .Case("tsc701", CK_TSC701)
6799         .Case("v9", CK_V9)
6800         .Case("ultrasparc", CK_ULTRASPARC)
6801         .Case("ultrasparc3", CK_ULTRASPARC3)
6802         .Case("niagara", CK_NIAGARA)
6803         .Case("niagara2", CK_NIAGARA2)
6804         .Case("niagara3", CK_NIAGARA3)
6805         .Case("niagara4", CK_NIAGARA4)
6806         .Case("ma2100", CK_MYRIAD2100)
6807         .Case("ma2150", CK_MYRIAD2150)
6808         .Case("ma2450", CK_MYRIAD2450)
6809         // FIXME: the myriad2[.n] spellings are obsolete,
6810         // but a grace period is needed to allow updating dependent builds.
6811         .Case("myriad2", CK_MYRIAD2100)
6812         .Case("myriad2.1", CK_MYRIAD2100)
6813         .Case("myriad2.2", CK_MYRIAD2150)
6814         .Case("leon2", CK_LEON2)
6815         .Case("at697e", CK_LEON2_AT697E)
6816         .Case("at697f", CK_LEON2_AT697F)
6817         .Case("leon3", CK_LEON3)
6818         .Case("ut699", CK_LEON3_UT699)
6819         .Case("gr712rc", CK_LEON3_GR712RC)
6820         .Case("leon4", CK_LEON4)
6821         .Case("gr740", CK_LEON4_GR740)
6822         .Default(CK_GENERIC);
6823   }
6824
6825   bool setCPU(const std::string &Name) override {
6826     CPU = getCPUKind(Name);
6827     return CPU != CK_GENERIC;
6828   }
6829 };
6830
6831 const char * const SparcTargetInfo::GCCRegNames[] = {
6832   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6833   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6834   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
6835   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
6836 };
6837
6838 ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const {
6839   return llvm::makeArrayRef(GCCRegNames);
6840 }
6841
6842 const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
6843   { { "g0" }, "r0" },
6844   { { "g1" }, "r1" },
6845   { { "g2" }, "r2" },
6846   { { "g3" }, "r3" },
6847   { { "g4" }, "r4" },
6848   { { "g5" }, "r5" },
6849   { { "g6" }, "r6" },
6850   { { "g7" }, "r7" },
6851   { { "o0" }, "r8" },
6852   { { "o1" }, "r9" },
6853   { { "o2" }, "r10" },
6854   { { "o3" }, "r11" },
6855   { { "o4" }, "r12" },
6856   { { "o5" }, "r13" },
6857   { { "o6", "sp" }, "r14" },
6858   { { "o7" }, "r15" },
6859   { { "l0" }, "r16" },
6860   { { "l1" }, "r17" },
6861   { { "l2" }, "r18" },
6862   { { "l3" }, "r19" },
6863   { { "l4" }, "r20" },
6864   { { "l5" }, "r21" },
6865   { { "l6" }, "r22" },
6866   { { "l7" }, "r23" },
6867   { { "i0" }, "r24" },
6868   { { "i1" }, "r25" },
6869   { { "i2" }, "r26" },
6870   { { "i3" }, "r27" },
6871   { { "i4" }, "r28" },
6872   { { "i5" }, "r29" },
6873   { { "i6", "fp" }, "r30" },
6874   { { "i7" }, "r31" },
6875 };
6876
6877 ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const {
6878   return llvm::makeArrayRef(GCCRegAliases);
6879 }
6880
6881 // SPARC v8 is the 32-bit mode selected by Triple::sparc.
6882 class SparcV8TargetInfo : public SparcTargetInfo {
6883 public:
6884   SparcV8TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6885       : SparcTargetInfo(Triple, Opts) {
6886     resetDataLayout("E-m:e-p:32:32-i64:64-f128:64-n32-S64");
6887     // NetBSD / OpenBSD use long (same as llvm default); everyone else uses int.
6888     switch (getTriple().getOS()) {
6889     default:
6890       SizeType = UnsignedInt;
6891       IntPtrType = SignedInt;
6892       PtrDiffType = SignedInt;
6893       break;
6894     case llvm::Triple::NetBSD:
6895     case llvm::Triple::OpenBSD:
6896       SizeType = UnsignedLong;
6897       IntPtrType = SignedLong;
6898       PtrDiffType = SignedLong;
6899       break;
6900     }
6901     // Up to 32 bits are lock-free atomic, but we're willing to do atomic ops
6902     // on up to 64 bits.
6903     MaxAtomicPromoteWidth = 64;
6904     MaxAtomicInlineWidth = 32;
6905   }
6906
6907   void getTargetDefines(const LangOptions &Opts,
6908                         MacroBuilder &Builder) const override {
6909     SparcTargetInfo::getTargetDefines(Opts, Builder);
6910     switch (getCPUGeneration(CPU)) {
6911     case CG_V8:
6912       Builder.defineMacro("__sparcv8");
6913       if (getTriple().getOS() != llvm::Triple::Solaris)
6914         Builder.defineMacro("__sparcv8__");
6915       break;
6916     case CG_V9:
6917       Builder.defineMacro("__sparcv9");
6918       if (getTriple().getOS() != llvm::Triple::Solaris) {
6919         Builder.defineMacro("__sparcv9__");
6920         Builder.defineMacro("__sparc_v9__");
6921       }
6922       break;
6923     }
6924     if (getTriple().getVendor() == llvm::Triple::Myriad) {
6925       std::string MyriadArchValue, Myriad2Value;
6926       Builder.defineMacro("__sparc_v8__");
6927       Builder.defineMacro("__leon__");
6928       switch (CPU) {
6929       case CK_MYRIAD2150:
6930         MyriadArchValue = "__ma2150";
6931         Myriad2Value = "2";
6932         break;
6933       case CK_MYRIAD2450:
6934         MyriadArchValue = "__ma2450";
6935         Myriad2Value = "2";
6936         break;
6937       default:
6938         MyriadArchValue = "__ma2100";
6939         Myriad2Value = "1";
6940         break;
6941       }
6942       Builder.defineMacro(MyriadArchValue, "1");
6943       Builder.defineMacro(MyriadArchValue+"__", "1");
6944       Builder.defineMacro("__myriad2__", Myriad2Value);
6945       Builder.defineMacro("__myriad2", Myriad2Value);
6946     }
6947   }
6948
6949   bool hasSjLjLowering() const override {
6950     return true;
6951   }
6952 };
6953
6954 // SPARCV8el is the 32-bit little-endian mode selected by Triple::sparcel.
6955 class SparcV8elTargetInfo : public SparcV8TargetInfo {
6956  public:
6957    SparcV8elTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6958        : SparcV8TargetInfo(Triple, Opts) {
6959      resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32-S64");
6960   }
6961 };
6962
6963 // SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
6964 class SparcV9TargetInfo : public SparcTargetInfo {
6965 public:
6966   SparcV9TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6967       : SparcTargetInfo(Triple, Opts) {
6968     // FIXME: Support Sparc quad-precision long double?
6969     resetDataLayout("E-m:e-i64:64-n32:64-S128");
6970     // This is an LP64 platform.
6971     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6972
6973     // OpenBSD uses long long for int64_t and intmax_t.
6974     if (getTriple().getOS() == llvm::Triple::OpenBSD)
6975       IntMaxType = SignedLongLong;
6976     else
6977       IntMaxType = SignedLong;
6978     Int64Type = IntMaxType;
6979
6980     // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
6981     // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
6982     LongDoubleWidth = 128;
6983     LongDoubleAlign = 128;
6984     LongDoubleFormat = &llvm::APFloat::IEEEquad();
6985     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6986   }
6987
6988   void getTargetDefines(const LangOptions &Opts,
6989                         MacroBuilder &Builder) const override {
6990     SparcTargetInfo::getTargetDefines(Opts, Builder);
6991     Builder.defineMacro("__sparcv9");
6992     Builder.defineMacro("__arch64__");
6993     // Solaris doesn't need these variants, but the BSDs do.
6994     if (getTriple().getOS() != llvm::Triple::Solaris) {
6995       Builder.defineMacro("__sparc64__");
6996       Builder.defineMacro("__sparc_v9__");
6997       Builder.defineMacro("__sparcv9__");
6998     }
6999   }
7000
7001   bool setCPU(const std::string &Name) override {
7002     if (!SparcTargetInfo::setCPU(Name))
7003       return false;
7004     return getCPUGeneration(CPU) == CG_V9;
7005   }
7006 };
7007
7008 class SystemZTargetInfo : public TargetInfo {
7009   static const Builtin::Info BuiltinInfo[];
7010   static const char *const GCCRegNames[];
7011   std::string CPU;
7012   bool HasTransactionalExecution;
7013   bool HasVector;
7014
7015 public:
7016   SystemZTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7017       : TargetInfo(Triple), CPU("z10"), HasTransactionalExecution(false),
7018         HasVector(false) {
7019     IntMaxType = SignedLong;
7020     Int64Type = SignedLong;
7021     TLSSupported = true;
7022     IntWidth = IntAlign = 32;
7023     LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
7024     PointerWidth = PointerAlign = 64;
7025     LongDoubleWidth = 128;
7026     LongDoubleAlign = 64;
7027     LongDoubleFormat = &llvm::APFloat::IEEEquad();
7028     DefaultAlignForAttributeAligned = 64;
7029     MinGlobalAlign = 16;
7030     resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64");
7031     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7032   }
7033   void getTargetDefines(const LangOptions &Opts,
7034                         MacroBuilder &Builder) const override {
7035     Builder.defineMacro("__s390__");
7036     Builder.defineMacro("__s390x__");
7037     Builder.defineMacro("__zarch__");
7038     Builder.defineMacro("__LONG_DOUBLE_128__");
7039
7040     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
7041     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
7042     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
7043     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
7044
7045     if (HasTransactionalExecution)
7046       Builder.defineMacro("__HTM__");
7047     if (Opts.ZVector)
7048       Builder.defineMacro("__VEC__", "10301");
7049   }
7050   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7051     return llvm::makeArrayRef(BuiltinInfo,
7052                          clang::SystemZ::LastTSBuiltin-Builtin::FirstTSBuiltin);
7053   }
7054
7055   ArrayRef<const char *> getGCCRegNames() const override;
7056   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7057     // No aliases.
7058     return None;
7059   }
7060   bool validateAsmConstraint(const char *&Name,
7061                              TargetInfo::ConstraintInfo &info) const override;
7062   const char *getClobbers() const override {
7063     // FIXME: Is this really right?
7064     return "";
7065   }
7066   BuiltinVaListKind getBuiltinVaListKind() const override {
7067     return TargetInfo::SystemZBuiltinVaList;
7068   }
7069   bool setCPU(const std::string &Name) override {
7070     CPU = Name;
7071     bool CPUKnown = llvm::StringSwitch<bool>(Name)
7072       .Case("z10", true)
7073       .Case("arch8", true)
7074       .Case("z196", true)
7075       .Case("arch9", true)
7076       .Case("zEC12", true)
7077       .Case("arch10", true)
7078       .Case("z13", true)
7079       .Case("arch11", true)
7080       .Default(false);
7081
7082     return CPUKnown;
7083   }
7084   bool
7085   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
7086                  StringRef CPU,
7087                  const std::vector<std::string> &FeaturesVec) const override {
7088     if (CPU == "zEC12" || CPU == "arch10")
7089       Features["transactional-execution"] = true;
7090     if (CPU == "z13" || CPU == "arch11") {
7091       Features["transactional-execution"] = true;
7092       Features["vector"] = true;
7093     }
7094     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
7095   }
7096
7097   bool handleTargetFeatures(std::vector<std::string> &Features,
7098                             DiagnosticsEngine &Diags) override {
7099     HasTransactionalExecution = false;
7100     for (const auto &Feature : Features) {
7101       if (Feature == "+transactional-execution")
7102         HasTransactionalExecution = true;
7103       else if (Feature == "+vector")
7104         HasVector = true;
7105     }
7106     // If we use the vector ABI, vector types are 64-bit aligned.
7107     if (HasVector) {
7108       MaxVectorAlign = 64;
7109       resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64"
7110                       "-v128:64-a:8:16-n32:64");
7111     }
7112     return true;
7113   }
7114
7115   bool hasFeature(StringRef Feature) const override {
7116     return llvm::StringSwitch<bool>(Feature)
7117         .Case("systemz", true)
7118         .Case("htm", HasTransactionalExecution)
7119         .Case("vx", HasVector)
7120         .Default(false);
7121   }
7122
7123   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
7124     switch (CC) {
7125     case CC_C:
7126     case CC_Swift:
7127       return CCCR_OK;
7128     default:
7129       return CCCR_Warning;
7130     }
7131   }
7132
7133   StringRef getABI() const override {
7134     if (HasVector)
7135       return "vector";
7136     return "";
7137   }
7138
7139   bool useFloat128ManglingForLongDouble() const override {
7140     return true;
7141   }
7142 };
7143
7144 const Builtin::Info SystemZTargetInfo::BuiltinInfo[] = {
7145 #define BUILTIN(ID, TYPE, ATTRS)                                               \
7146   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7147 #define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE)                               \
7148   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
7149 #include "clang/Basic/BuiltinsSystemZ.def"
7150 };
7151
7152 const char *const SystemZTargetInfo::GCCRegNames[] = {
7153   "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
7154   "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
7155   "f0",  "f2",  "f4",  "f6",  "f1",  "f3",  "f5",  "f7",
7156   "f8",  "f10", "f12", "f14", "f9",  "f11", "f13", "f15"
7157 };
7158
7159 ArrayRef<const char *> SystemZTargetInfo::getGCCRegNames() const {
7160   return llvm::makeArrayRef(GCCRegNames);
7161 }
7162
7163 bool SystemZTargetInfo::
7164 validateAsmConstraint(const char *&Name,
7165                       TargetInfo::ConstraintInfo &Info) const {
7166   switch (*Name) {
7167   default:
7168     return false;
7169
7170   case 'a': // Address register
7171   case 'd': // Data register (equivalent to 'r')
7172   case 'f': // Floating-point register
7173     Info.setAllowsRegister();
7174     return true;
7175
7176   case 'I': // Unsigned 8-bit constant
7177   case 'J': // Unsigned 12-bit constant
7178   case 'K': // Signed 16-bit constant
7179   case 'L': // Signed 20-bit displacement (on all targets we support)
7180   case 'M': // 0x7fffffff
7181     return true;
7182
7183   case 'Q': // Memory with base and unsigned 12-bit displacement
7184   case 'R': // Likewise, plus an index
7185   case 'S': // Memory with base and signed 20-bit displacement
7186   case 'T': // Likewise, plus an index
7187     Info.setAllowsMemory();
7188     return true;
7189   }
7190 }
7191
7192 class MSP430TargetInfo : public TargetInfo {
7193   static const char *const GCCRegNames[];
7194
7195 public:
7196   MSP430TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7197       : TargetInfo(Triple) {
7198     TLSSupported = false;
7199     IntWidth = 16;
7200     IntAlign = 16;
7201     LongWidth = 32;
7202     LongLongWidth = 64;
7203     LongAlign = LongLongAlign = 16;
7204     PointerWidth = 16;
7205     PointerAlign = 16;
7206     SuitableAlign = 16;
7207     SizeType = UnsignedInt;
7208     IntMaxType = SignedLongLong;
7209     IntPtrType = SignedInt;
7210     PtrDiffType = SignedInt;
7211     SigAtomicType = SignedLong;
7212     resetDataLayout("e-m:e-p:16:16-i32:16:32-a:16-n8:16");
7213   }
7214   void getTargetDefines(const LangOptions &Opts,
7215                         MacroBuilder &Builder) const override {
7216     Builder.defineMacro("MSP430");
7217     Builder.defineMacro("__MSP430__");
7218     // FIXME: defines for different 'flavours' of MCU
7219   }
7220   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7221     // FIXME: Implement.
7222     return None;
7223   }
7224   bool hasFeature(StringRef Feature) const override {
7225     return Feature == "msp430";
7226   }
7227   ArrayRef<const char *> getGCCRegNames() const override;
7228   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7229     // No aliases.
7230     return None;
7231   }
7232   bool validateAsmConstraint(const char *&Name,
7233                              TargetInfo::ConstraintInfo &info) const override {
7234     // FIXME: implement
7235     switch (*Name) {
7236     case 'K': // the constant 1
7237     case 'L': // constant -1^20 .. 1^19
7238     case 'M': // constant 1-4:
7239       return true;
7240     }
7241     // No target constraints for now.
7242     return false;
7243   }
7244   const char *getClobbers() const override {
7245     // FIXME: Is this really right?
7246     return "";
7247   }
7248   BuiltinVaListKind getBuiltinVaListKind() const override {
7249     // FIXME: implement
7250     return TargetInfo::CharPtrBuiltinVaList;
7251   }
7252 };
7253
7254 const char *const MSP430TargetInfo::GCCRegNames[] = {
7255     "r0", "r1", "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
7256     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"};
7257
7258 ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
7259   return llvm::makeArrayRef(GCCRegNames);
7260 }
7261
7262 // LLVM and Clang cannot be used directly to output native binaries for
7263 // target, but is used to compile C code to llvm bitcode with correct
7264 // type and alignment information.
7265 //
7266 // TCE uses the llvm bitcode as input and uses it for generating customized
7267 // target processor and program binary. TCE co-design environment is
7268 // publicly available in http://tce.cs.tut.fi
7269
7270 static const unsigned TCEOpenCLAddrSpaceMap[] = {
7271     3, // opencl_global
7272     4, // opencl_local
7273     5, // opencl_constant
7274     // FIXME: generic has to be added to the target
7275     0, // opencl_generic
7276     0, // cuda_device
7277     0, // cuda_constant
7278     0  // cuda_shared
7279 };
7280
7281 class TCETargetInfo : public TargetInfo {
7282 public:
7283   TCETargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7284       : TargetInfo(Triple) {
7285     TLSSupported = false;
7286     IntWidth = 32;
7287     LongWidth = LongLongWidth = 32;
7288     PointerWidth = 32;
7289     IntAlign = 32;
7290     LongAlign = LongLongAlign = 32;
7291     PointerAlign = 32;
7292     SuitableAlign = 32;
7293     SizeType = UnsignedInt;
7294     IntMaxType = SignedLong;
7295     IntPtrType = SignedInt;
7296     PtrDiffType = SignedInt;
7297     FloatWidth = 32;
7298     FloatAlign = 32;
7299     DoubleWidth = 32;
7300     DoubleAlign = 32;
7301     LongDoubleWidth = 32;
7302     LongDoubleAlign = 32;
7303     FloatFormat = &llvm::APFloat::IEEEsingle();
7304     DoubleFormat = &llvm::APFloat::IEEEsingle();
7305     LongDoubleFormat = &llvm::APFloat::IEEEsingle();
7306     resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"
7307                     "i16:16:32-i32:32:32-i64:32:32-"
7308                     "f32:32:32-f64:32:32-v64:32:32-"
7309                     "v128:32:32-v256:32:32-v512:32:32-"
7310                     "v1024:32:32-a0:0:32-n32");
7311     AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
7312     UseAddrSpaceMapMangling = true;
7313   }
7314
7315   void getTargetDefines(const LangOptions &Opts,
7316                         MacroBuilder &Builder) const override {
7317     DefineStd(Builder, "tce", Opts);
7318     Builder.defineMacro("__TCE__");
7319     Builder.defineMacro("__TCE_V1__");
7320   }
7321   bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
7322
7323   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
7324   const char *getClobbers() const override { return ""; }
7325   BuiltinVaListKind getBuiltinVaListKind() const override {
7326     return TargetInfo::VoidPtrBuiltinVaList;
7327   }
7328   ArrayRef<const char *> getGCCRegNames() const override { return None; }
7329   bool validateAsmConstraint(const char *&Name,
7330                              TargetInfo::ConstraintInfo &info) const override {
7331     return true;
7332   }
7333   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7334     return None;
7335   }
7336 };
7337
7338 class TCELETargetInfo : public TCETargetInfo {
7339 public:
7340   TCELETargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7341       : TCETargetInfo(Triple, Opts) {
7342     BigEndian = false;
7343
7344     resetDataLayout("e-p:32:32:32-i1:8:8-i8:8:32-"
7345                     "i16:16:32-i32:32:32-i64:32:32-"
7346                     "f32:32:32-f64:32:32-v64:32:32-"
7347                     "v128:32:32-v256:32:32-v512:32:32-"
7348                     "v1024:32:32-a0:0:32-n32");
7349
7350   }
7351
7352   virtual void getTargetDefines(const LangOptions &Opts,
7353                                 MacroBuilder &Builder) const {
7354     DefineStd(Builder, "tcele", Opts);
7355     Builder.defineMacro("__TCE__");
7356     Builder.defineMacro("__TCE_V1__");
7357     Builder.defineMacro("__TCELE__");
7358     Builder.defineMacro("__TCELE_V1__");
7359   }
7360
7361 };
7362
7363 class BPFTargetInfo : public TargetInfo {
7364 public:
7365   BPFTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7366       : TargetInfo(Triple) {
7367     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
7368     SizeType    = UnsignedLong;
7369     PtrDiffType = SignedLong;
7370     IntPtrType  = SignedLong;
7371     IntMaxType  = SignedLong;
7372     Int64Type   = SignedLong;
7373     RegParmMax = 5;
7374     if (Triple.getArch() == llvm::Triple::bpfeb) {
7375       resetDataLayout("E-m:e-p:64:64-i64:64-n32:64-S128");
7376     } else {
7377       resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
7378     }
7379     MaxAtomicPromoteWidth = 64;
7380     MaxAtomicInlineWidth = 64;
7381     TLSSupported = false;
7382   }
7383   void getTargetDefines(const LangOptions &Opts,
7384                         MacroBuilder &Builder) const override {
7385     DefineStd(Builder, "bpf", Opts);
7386     Builder.defineMacro("__BPF__");
7387   }
7388   bool hasFeature(StringRef Feature) const override {
7389     return Feature == "bpf";
7390   }
7391
7392   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
7393   const char *getClobbers() const override {
7394     return "";
7395   }
7396   BuiltinVaListKind getBuiltinVaListKind() const override {
7397     return TargetInfo::VoidPtrBuiltinVaList;
7398   }
7399   ArrayRef<const char *> getGCCRegNames() const override {
7400     return None;
7401   }
7402   bool validateAsmConstraint(const char *&Name,
7403                              TargetInfo::ConstraintInfo &info) const override {
7404     return true;
7405   }
7406   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7407     return None;
7408   }
7409 };
7410
7411 class MipsTargetInfo : public TargetInfo {
7412   void setDataLayout() {
7413     StringRef Layout;
7414
7415     if (ABI == "o32")
7416       Layout = "m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
7417     else if (ABI == "n32")
7418       Layout = "m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7419     else if (ABI == "n64")
7420       Layout = "m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128";
7421     else
7422       llvm_unreachable("Invalid ABI");
7423
7424     if (BigEndian)
7425       resetDataLayout(("E-" + Layout).str());
7426     else
7427       resetDataLayout(("e-" + Layout).str());
7428   }
7429
7430
7431   static const Builtin::Info BuiltinInfo[];
7432   std::string CPU;
7433   bool IsMips16;
7434   bool IsMicromips;
7435   bool IsNan2008;
7436   bool IsSingleFloat;
7437   enum MipsFloatABI {
7438     HardFloat, SoftFloat
7439   } FloatABI;
7440   enum DspRevEnum {
7441     NoDSP, DSP1, DSP2
7442   } DspRev;
7443   bool HasMSA;
7444
7445 protected:
7446   bool HasFP64;
7447   std::string ABI;
7448
7449 public:
7450   MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7451       : TargetInfo(Triple), IsMips16(false), IsMicromips(false),
7452         IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
7453         DspRev(NoDSP), HasMSA(false), HasFP64(false) {
7454     TheCXXABI.set(TargetCXXABI::GenericMIPS);
7455
7456     setABI((getTriple().getArch() == llvm::Triple::mips ||
7457             getTriple().getArch() == llvm::Triple::mipsel)
7458                ? "o32"
7459                : "n64");
7460
7461     CPU = ABI == "o32" ? "mips32r2" : "mips64r2";
7462   }
7463
7464   bool isNaN2008Default() const {
7465     return CPU == "mips32r6" || CPU == "mips64r6";
7466   }
7467
7468   bool isFP64Default() const {
7469     return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
7470   }
7471
7472   bool isNan2008() const override {
7473     return IsNan2008;
7474   }
7475
7476   bool processorSupportsGPR64() const {
7477     return llvm::StringSwitch<bool>(CPU)
7478         .Case("mips3", true)
7479         .Case("mips4", true)
7480         .Case("mips5", true)
7481         .Case("mips64", true)
7482         .Case("mips64r2", true)
7483         .Case("mips64r3", true)
7484         .Case("mips64r5", true)
7485         .Case("mips64r6", true)
7486         .Case("octeon", true)
7487         .Default(false);
7488     return false;
7489   }
7490
7491   StringRef getABI() const override { return ABI; }
7492   bool setABI(const std::string &Name) override {
7493     if (Name == "o32") {
7494       setO32ABITypes();
7495       ABI = Name;
7496       return true;
7497     }
7498
7499     if (Name == "n32") {
7500       setN32ABITypes();
7501       ABI = Name;
7502       return true;
7503     }
7504     if (Name == "n64") {
7505       setN64ABITypes();
7506       ABI = Name;
7507       return true;
7508     }
7509     return false;
7510   }
7511
7512   void setO32ABITypes() {
7513     Int64Type = SignedLongLong;
7514     IntMaxType = Int64Type;
7515     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
7516     LongDoubleWidth = LongDoubleAlign = 64;
7517     LongWidth = LongAlign = 32;
7518     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
7519     PointerWidth = PointerAlign = 32;
7520     PtrDiffType = SignedInt;
7521     SizeType = UnsignedInt;
7522     SuitableAlign = 64;
7523   }
7524
7525   void setN32N64ABITypes() {
7526     LongDoubleWidth = LongDoubleAlign = 128;
7527     LongDoubleFormat = &llvm::APFloat::IEEEquad();
7528     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
7529       LongDoubleWidth = LongDoubleAlign = 64;
7530       LongDoubleFormat = &llvm::APFloat::IEEEdouble();
7531     }
7532     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7533     SuitableAlign = 128;
7534   }
7535
7536   void setN64ABITypes() {
7537     setN32N64ABITypes();
7538     Int64Type = SignedLong;
7539     IntMaxType = Int64Type;
7540     LongWidth = LongAlign = 64;
7541     PointerWidth = PointerAlign = 64;
7542     PtrDiffType = SignedLong;
7543     SizeType = UnsignedLong;
7544   }
7545
7546   void setN32ABITypes() {
7547     setN32N64ABITypes();
7548     Int64Type = SignedLongLong;
7549     IntMaxType = Int64Type;
7550     LongWidth = LongAlign = 32;
7551     PointerWidth = PointerAlign = 32;
7552     PtrDiffType = SignedInt;
7553     SizeType = UnsignedInt;
7554   }
7555
7556   bool setCPU(const std::string &Name) override {
7557     CPU = Name;
7558     return llvm::StringSwitch<bool>(Name)
7559         .Case("mips1", true)
7560         .Case("mips2", true)
7561         .Case("mips3", true)
7562         .Case("mips4", true)
7563         .Case("mips5", true)
7564         .Case("mips32", true)
7565         .Case("mips32r2", true)
7566         .Case("mips32r3", true)
7567         .Case("mips32r5", true)
7568         .Case("mips32r6", true)
7569         .Case("mips64", true)
7570         .Case("mips64r2", true)
7571         .Case("mips64r3", true)
7572         .Case("mips64r5", true)
7573         .Case("mips64r6", true)
7574         .Case("octeon", true)
7575         .Case("p5600", true)
7576         .Default(false);
7577   }
7578   const std::string& getCPU() const { return CPU; }
7579   bool
7580   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
7581                  StringRef CPU,
7582                  const std::vector<std::string> &FeaturesVec) const override {
7583     if (CPU.empty())
7584       CPU = getCPU();
7585     if (CPU == "octeon")
7586       Features["mips64r2"] = Features["cnmips"] = true;
7587     else
7588       Features[CPU] = true;
7589     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
7590   }
7591
7592   void getTargetDefines(const LangOptions &Opts,
7593                         MacroBuilder &Builder) const override {
7594     if (BigEndian) {
7595       DefineStd(Builder, "MIPSEB", Opts);
7596       Builder.defineMacro("_MIPSEB");
7597     } else {
7598       DefineStd(Builder, "MIPSEL", Opts);
7599       Builder.defineMacro("_MIPSEL");
7600     }
7601
7602     Builder.defineMacro("__mips__");
7603     Builder.defineMacro("_mips");
7604     if (Opts.GNUMode)
7605       Builder.defineMacro("mips");
7606
7607     if (ABI == "o32") {
7608       Builder.defineMacro("__mips", "32");
7609       Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
7610     } else {
7611       Builder.defineMacro("__mips", "64");
7612       Builder.defineMacro("__mips64");
7613       Builder.defineMacro("__mips64__");
7614       Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
7615     }
7616
7617     const std::string ISARev = llvm::StringSwitch<std::string>(getCPU())
7618                                    .Cases("mips32", "mips64", "1")
7619                                    .Cases("mips32r2", "mips64r2", "2")
7620                                    .Cases("mips32r3", "mips64r3", "3")
7621                                    .Cases("mips32r5", "mips64r5", "5")
7622                                    .Cases("mips32r6", "mips64r6", "6")
7623                                    .Default("");
7624     if (!ISARev.empty())
7625       Builder.defineMacro("__mips_isa_rev", ISARev);
7626
7627     if (ABI == "o32") {
7628       Builder.defineMacro("__mips_o32");
7629       Builder.defineMacro("_ABIO32", "1");
7630       Builder.defineMacro("_MIPS_SIM", "_ABIO32");
7631     } else if (ABI == "n32") {
7632       Builder.defineMacro("__mips_n32");
7633       Builder.defineMacro("_ABIN32", "2");
7634       Builder.defineMacro("_MIPS_SIM", "_ABIN32");
7635     } else if (ABI == "n64") {
7636       Builder.defineMacro("__mips_n64");
7637       Builder.defineMacro("_ABI64", "3");
7638       Builder.defineMacro("_MIPS_SIM", "_ABI64");
7639     } else
7640       llvm_unreachable("Invalid ABI.");
7641
7642     Builder.defineMacro("__REGISTER_PREFIX__", "");
7643
7644     switch (FloatABI) {
7645     case HardFloat:
7646       Builder.defineMacro("__mips_hard_float", Twine(1));
7647       break;
7648     case SoftFloat:
7649       Builder.defineMacro("__mips_soft_float", Twine(1));
7650       break;
7651     }
7652
7653     if (IsSingleFloat)
7654       Builder.defineMacro("__mips_single_float", Twine(1));
7655
7656     Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
7657     Builder.defineMacro("_MIPS_FPSET",
7658                         Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
7659
7660     if (IsMips16)
7661       Builder.defineMacro("__mips16", Twine(1));
7662
7663     if (IsMicromips)
7664       Builder.defineMacro("__mips_micromips", Twine(1));
7665
7666     if (IsNan2008)
7667       Builder.defineMacro("__mips_nan2008", Twine(1));
7668
7669     switch (DspRev) {
7670     default:
7671       break;
7672     case DSP1:
7673       Builder.defineMacro("__mips_dsp_rev", Twine(1));
7674       Builder.defineMacro("__mips_dsp", Twine(1));
7675       break;
7676     case DSP2:
7677       Builder.defineMacro("__mips_dsp_rev", Twine(2));
7678       Builder.defineMacro("__mips_dspr2", Twine(1));
7679       Builder.defineMacro("__mips_dsp", Twine(1));
7680       break;
7681     }
7682
7683     if (HasMSA)
7684       Builder.defineMacro("__mips_msa", Twine(1));
7685
7686     Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
7687     Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
7688     Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
7689
7690     Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
7691     Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
7692
7693     // These shouldn't be defined for MIPS-I but there's no need to check
7694     // for that since MIPS-I isn't supported.
7695     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
7696     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
7697     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
7698
7699     // 32-bit MIPS processors don't have the necessary lld/scd instructions
7700     // found in 64-bit processors. In the case of O32 on a 64-bit processor,
7701     // the instructions exist but using them violates the ABI since they
7702     // require 64-bit GPRs and O32 only supports 32-bit GPRs.
7703     if (ABI == "n32" || ABI == "n64")
7704       Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
7705   }
7706
7707   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7708     return llvm::makeArrayRef(BuiltinInfo,
7709                           clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
7710   }
7711   bool hasFeature(StringRef Feature) const override {
7712     return llvm::StringSwitch<bool>(Feature)
7713       .Case("mips", true)
7714       .Case("fp64", HasFP64)
7715       .Default(false);
7716   }
7717   BuiltinVaListKind getBuiltinVaListKind() const override {
7718     return TargetInfo::VoidPtrBuiltinVaList;
7719   }
7720   ArrayRef<const char *> getGCCRegNames() const override {
7721     static const char *const GCCRegNames[] = {
7722       // CPU register names
7723       // Must match second column of GCCRegAliases
7724       "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
7725       "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
7726       "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
7727       "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31",
7728       // Floating point register names
7729       "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
7730       "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
7731       "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
7732       "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
7733       // Hi/lo and condition register names
7734       "hi",   "lo",   "",     "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
7735       "$fcc5","$fcc6","$fcc7","$ac1hi","$ac1lo","$ac2hi","$ac2lo",
7736       "$ac3hi","$ac3lo",
7737       // MSA register names
7738       "$w0",  "$w1",  "$w2",  "$w3",  "$w4",  "$w5",  "$w6",  "$w7",
7739       "$w8",  "$w9",  "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
7740       "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
7741       "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
7742       // MSA control register names
7743       "$msair",      "$msacsr", "$msaaccess", "$msasave", "$msamodify",
7744       "$msarequest", "$msamap", "$msaunmap"
7745     };
7746     return llvm::makeArrayRef(GCCRegNames);
7747   }
7748   bool validateAsmConstraint(const char *&Name,
7749                              TargetInfo::ConstraintInfo &Info) const override {
7750     switch (*Name) {
7751     default:
7752       return false;
7753     case 'r': // CPU registers.
7754     case 'd': // Equivalent to "r" unless generating MIPS16 code.
7755     case 'y': // Equivalent to "r", backward compatibility only.
7756     case 'f': // floating-point registers.
7757     case 'c': // $25 for indirect jumps
7758     case 'l': // lo register
7759     case 'x': // hilo register pair
7760       Info.setAllowsRegister();
7761       return true;
7762     case 'I': // Signed 16-bit constant
7763     case 'J': // Integer 0
7764     case 'K': // Unsigned 16-bit constant
7765     case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui)
7766     case 'M': // Constants not loadable via lui, addiu, or ori
7767     case 'N': // Constant -1 to -65535
7768     case 'O': // A signed 15-bit constant
7769     case 'P': // A constant between 1 go 65535
7770       return true;
7771     case 'R': // An address that can be used in a non-macro load or store
7772       Info.setAllowsMemory();
7773       return true;
7774     case 'Z':
7775       if (Name[1] == 'C') { // An address usable by ll, and sc.
7776         Info.setAllowsMemory();
7777         Name++; // Skip over 'Z'.
7778         return true;
7779       }
7780       return false;
7781     }
7782   }
7783
7784   std::string convertConstraint(const char *&Constraint) const override {
7785     std::string R;
7786     switch (*Constraint) {
7787     case 'Z': // Two-character constraint; add "^" hint for later parsing.
7788       if (Constraint[1] == 'C') {
7789         R = std::string("^") + std::string(Constraint, 2);
7790         Constraint++;
7791         return R;
7792       }
7793       break;
7794     }
7795     return TargetInfo::convertConstraint(Constraint);
7796   }
7797
7798   const char *getClobbers() const override {
7799     // In GCC, $1 is not widely used in generated code (it's used only in a few
7800     // specific situations), so there is no real need for users to add it to
7801     // the clobbers list if they want to use it in their inline assembly code.
7802     //
7803     // In LLVM, $1 is treated as a normal GPR and is always allocatable during
7804     // code generation, so using it in inline assembly without adding it to the
7805     // clobbers list can cause conflicts between the inline assembly code and
7806     // the surrounding generated code.
7807     //
7808     // Another problem is that LLVM is allowed to choose $1 for inline assembly
7809     // operands, which will conflict with the ".set at" assembler option (which
7810     // we use only for inline assembly, in order to maintain compatibility with
7811     // GCC) and will also conflict with the user's usage of $1.
7812     //
7813     // The easiest way to avoid these conflicts and keep $1 as an allocatable
7814     // register for generated code is to automatically clobber $1 for all inline
7815     // assembly code.
7816     //
7817     // FIXME: We should automatically clobber $1 only for inline assembly code
7818     // which actually uses it. This would allow LLVM to use $1 for inline
7819     // assembly operands if the user's assembly code doesn't use it.
7820     return "~{$1}";
7821   }
7822
7823   bool handleTargetFeatures(std::vector<std::string> &Features,
7824                             DiagnosticsEngine &Diags) override {
7825     IsMips16 = false;
7826     IsMicromips = false;
7827     IsNan2008 = isNaN2008Default();
7828     IsSingleFloat = false;
7829     FloatABI = HardFloat;
7830     DspRev = NoDSP;
7831     HasFP64 = isFP64Default();
7832
7833     for (const auto &Feature : Features) {
7834       if (Feature == "+single-float")
7835         IsSingleFloat = true;
7836       else if (Feature == "+soft-float")
7837         FloatABI = SoftFloat;
7838       else if (Feature == "+mips16")
7839         IsMips16 = true;
7840       else if (Feature == "+micromips")
7841         IsMicromips = true;
7842       else if (Feature == "+dsp")
7843         DspRev = std::max(DspRev, DSP1);
7844       else if (Feature == "+dspr2")
7845         DspRev = std::max(DspRev, DSP2);
7846       else if (Feature == "+msa")
7847         HasMSA = true;
7848       else if (Feature == "+fp64")
7849         HasFP64 = true;
7850       else if (Feature == "-fp64")
7851         HasFP64 = false;
7852       else if (Feature == "+nan2008")
7853         IsNan2008 = true;
7854       else if (Feature == "-nan2008")
7855         IsNan2008 = false;
7856     }
7857
7858     setDataLayout();
7859
7860     return true;
7861   }
7862
7863   int getEHDataRegisterNumber(unsigned RegNo) const override {
7864     if (RegNo == 0) return 4;
7865     if (RegNo == 1) return 5;
7866     return -1;
7867   }
7868
7869   bool isCLZForZeroUndef() const override { return false; }
7870
7871   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7872     static const TargetInfo::GCCRegAlias O32RegAliases[] = {
7873         {{"at"}, "$1"},  {{"v0"}, "$2"},         {{"v1"}, "$3"},
7874         {{"a0"}, "$4"},  {{"a1"}, "$5"},         {{"a2"}, "$6"},
7875         {{"a3"}, "$7"},  {{"t0"}, "$8"},         {{"t1"}, "$9"},
7876         {{"t2"}, "$10"}, {{"t3"}, "$11"},        {{"t4"}, "$12"},
7877         {{"t5"}, "$13"}, {{"t6"}, "$14"},        {{"t7"}, "$15"},
7878         {{"s0"}, "$16"}, {{"s1"}, "$17"},        {{"s2"}, "$18"},
7879         {{"s3"}, "$19"}, {{"s4"}, "$20"},        {{"s5"}, "$21"},
7880         {{"s6"}, "$22"}, {{"s7"}, "$23"},        {{"t8"}, "$24"},
7881         {{"t9"}, "$25"}, {{"k0"}, "$26"},        {{"k1"}, "$27"},
7882         {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
7883         {{"ra"}, "$31"}};
7884     static const TargetInfo::GCCRegAlias NewABIRegAliases[] = {
7885         {{"at"}, "$1"},  {{"v0"}, "$2"},         {{"v1"}, "$3"},
7886         {{"a0"}, "$4"},  {{"a1"}, "$5"},         {{"a2"}, "$6"},
7887         {{"a3"}, "$7"},  {{"a4"}, "$8"},         {{"a5"}, "$9"},
7888         {{"a6"}, "$10"}, {{"a7"}, "$11"},        {{"t0"}, "$12"},
7889         {{"t1"}, "$13"}, {{"t2"}, "$14"},        {{"t3"}, "$15"},
7890         {{"s0"}, "$16"}, {{"s1"}, "$17"},        {{"s2"}, "$18"},
7891         {{"s3"}, "$19"}, {{"s4"}, "$20"},        {{"s5"}, "$21"},
7892         {{"s6"}, "$22"}, {{"s7"}, "$23"},        {{"t8"}, "$24"},
7893         {{"t9"}, "$25"}, {{"k0"}, "$26"},        {{"k1"}, "$27"},
7894         {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
7895         {{"ra"}, "$31"}};
7896     if (ABI == "o32")
7897       return llvm::makeArrayRef(O32RegAliases);
7898     return llvm::makeArrayRef(NewABIRegAliases);
7899   }
7900
7901   bool hasInt128Type() const override {
7902     return ABI == "n32" || ABI == "n64";
7903   }
7904
7905   bool validateTarget(DiagnosticsEngine &Diags) const override {
7906     // FIXME: It's valid to use O32 on a 64-bit CPU but the backend can't handle
7907     //        this yet. It's better to fail here than on the backend assertion.
7908     if (processorSupportsGPR64() && ABI == "o32") {
7909       Diags.Report(diag::err_target_unsupported_abi) << ABI << CPU;
7910       return false;
7911     }
7912
7913     // 64-bit ABI's require 64-bit CPU's.
7914     if (!processorSupportsGPR64() && (ABI == "n32" || ABI == "n64")) {
7915       Diags.Report(diag::err_target_unsupported_abi) << ABI << CPU;
7916       return false;
7917     }
7918
7919     // FIXME: It's valid to use O32 on a mips64/mips64el triple but the backend
7920     //        can't handle this yet. It's better to fail here than on the
7921     //        backend assertion.
7922     if ((getTriple().getArch() == llvm::Triple::mips64 ||
7923          getTriple().getArch() == llvm::Triple::mips64el) &&
7924         ABI == "o32") {
7925       Diags.Report(diag::err_target_unsupported_abi_for_triple)
7926           << ABI << getTriple().str();
7927       return false;
7928     }
7929
7930     // FIXME: It's valid to use N32/N64 on a mips/mipsel triple but the backend
7931     //        can't handle this yet. It's better to fail here than on the
7932     //        backend assertion.
7933     if ((getTriple().getArch() == llvm::Triple::mips ||
7934          getTriple().getArch() == llvm::Triple::mipsel) &&
7935         (ABI == "n32" || ABI == "n64")) {
7936       Diags.Report(diag::err_target_unsupported_abi_for_triple)
7937           << ABI << getTriple().str();
7938       return false;
7939     }
7940
7941     return true;
7942   }
7943 };
7944
7945 const Builtin::Info MipsTargetInfo::BuiltinInfo[] = {
7946 #define BUILTIN(ID, TYPE, ATTRS) \
7947   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7948 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
7949   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
7950 #include "clang/Basic/BuiltinsMips.def"
7951 };
7952
7953 class PNaClTargetInfo : public TargetInfo {
7954 public:
7955   PNaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7956       : TargetInfo(Triple) {
7957     this->LongAlign = 32;
7958     this->LongWidth = 32;
7959     this->PointerAlign = 32;
7960     this->PointerWidth = 32;
7961     this->IntMaxType = TargetInfo::SignedLongLong;
7962     this->Int64Type = TargetInfo::SignedLongLong;
7963     this->DoubleAlign = 64;
7964     this->LongDoubleWidth = 64;
7965     this->LongDoubleAlign = 64;
7966     this->SizeType = TargetInfo::UnsignedInt;
7967     this->PtrDiffType = TargetInfo::SignedInt;
7968     this->IntPtrType = TargetInfo::SignedInt;
7969     this->RegParmMax = 0; // Disallow regparm
7970   }
7971
7972   void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
7973     Builder.defineMacro("__le32__");
7974     Builder.defineMacro("__pnacl__");
7975   }
7976   void getTargetDefines(const LangOptions &Opts,
7977                         MacroBuilder &Builder) const override {
7978     getArchDefines(Opts, Builder);
7979   }
7980   bool hasFeature(StringRef Feature) const override {
7981     return Feature == "pnacl";
7982   }
7983   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
7984   BuiltinVaListKind getBuiltinVaListKind() const override {
7985     return TargetInfo::PNaClABIBuiltinVaList;
7986   }
7987   ArrayRef<const char *> getGCCRegNames() const override;
7988   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
7989   bool validateAsmConstraint(const char *&Name,
7990                              TargetInfo::ConstraintInfo &Info) const override {
7991     return false;
7992   }
7993
7994   const char *getClobbers() const override {
7995     return "";
7996   }
7997 };
7998
7999 ArrayRef<const char *> PNaClTargetInfo::getGCCRegNames() const {
8000   return None;
8001 }
8002
8003 ArrayRef<TargetInfo::GCCRegAlias> PNaClTargetInfo::getGCCRegAliases() const {
8004   return None;
8005 }
8006
8007 // We attempt to use PNaCl (le32) frontend and Mips32EL backend.
8008 class NaClMips32TargetInfo : public MipsTargetInfo {
8009 public:
8010   NaClMips32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8011       : MipsTargetInfo(Triple, Opts) {}
8012
8013   BuiltinVaListKind getBuiltinVaListKind() const override {
8014     return TargetInfo::PNaClABIBuiltinVaList;
8015   }
8016 };
8017
8018 class Le64TargetInfo : public TargetInfo {
8019   static const Builtin::Info BuiltinInfo[];
8020
8021 public:
8022   Le64TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8023       : TargetInfo(Triple) {
8024     NoAsmVariants = true;
8025     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
8026     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
8027     resetDataLayout("e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128");
8028   }
8029
8030   void getTargetDefines(const LangOptions &Opts,
8031                         MacroBuilder &Builder) const override {
8032     DefineStd(Builder, "unix", Opts);
8033     defineCPUMacros(Builder, "le64", /*Tuning=*/false);
8034     Builder.defineMacro("__ELF__");
8035   }
8036   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
8037     return llvm::makeArrayRef(BuiltinInfo,
8038                           clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin);
8039   }
8040   BuiltinVaListKind getBuiltinVaListKind() const override {
8041     return TargetInfo::PNaClABIBuiltinVaList;
8042   }
8043   const char *getClobbers() const override { return ""; }
8044   ArrayRef<const char *> getGCCRegNames() const override {
8045     return None;
8046   }
8047   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8048     return None;
8049   }
8050   bool validateAsmConstraint(const char *&Name,
8051                              TargetInfo::ConstraintInfo &Info) const override {
8052     return false;
8053   }
8054
8055   bool hasProtectedVisibility() const override { return false; }
8056 };
8057
8058 class WebAssemblyTargetInfo : public TargetInfo {
8059   static const Builtin::Info BuiltinInfo[];
8060
8061   enum SIMDEnum {
8062     NoSIMD,
8063     SIMD128,
8064   } SIMDLevel;
8065
8066 public:
8067   explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &)
8068       : TargetInfo(T), SIMDLevel(NoSIMD) {
8069     NoAsmVariants = true;
8070     SuitableAlign = 128;
8071     LargeArrayMinWidth = 128;
8072     LargeArrayAlign = 128;
8073     SimdDefaultAlign = 128;
8074     SigAtomicType = SignedLong;
8075     LongDoubleWidth = LongDoubleAlign = 128;
8076     LongDoubleFormat = &llvm::APFloat::IEEEquad();
8077     SizeType = UnsignedInt;
8078     PtrDiffType = SignedInt;
8079     IntPtrType = SignedInt;
8080   }
8081
8082 protected:
8083   void getTargetDefines(const LangOptions &Opts,
8084                         MacroBuilder &Builder) const override {
8085     defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
8086     if (SIMDLevel >= SIMD128)
8087       Builder.defineMacro("__wasm_simd128__");
8088   }
8089
8090 private:
8091   bool
8092   initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
8093                  StringRef CPU,
8094                  const std::vector<std::string> &FeaturesVec) const override {
8095     if (CPU == "bleeding-edge")
8096       Features["simd128"] = true;
8097     return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
8098   }
8099   bool hasFeature(StringRef Feature) const final {
8100     return llvm::StringSwitch<bool>(Feature)
8101         .Case("simd128", SIMDLevel >= SIMD128)
8102         .Default(false);
8103   }
8104   bool handleTargetFeatures(std::vector<std::string> &Features,
8105                             DiagnosticsEngine &Diags) final {
8106     for (const auto &Feature : Features) {
8107       if (Feature == "+simd128") {
8108         SIMDLevel = std::max(SIMDLevel, SIMD128);
8109         continue;
8110       }
8111       if (Feature == "-simd128") {
8112         SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
8113         continue;
8114       }
8115
8116       Diags.Report(diag::err_opt_not_valid_with_opt) << Feature
8117                                                      << "-target-feature";
8118       return false;
8119     }
8120     return true;
8121   }
8122   bool setCPU(const std::string &Name) final {
8123     return llvm::StringSwitch<bool>(Name)
8124               .Case("mvp",           true)
8125               .Case("bleeding-edge", true)
8126               .Case("generic",       true)
8127               .Default(false);
8128   }
8129   ArrayRef<Builtin::Info> getTargetBuiltins() const final {
8130     return llvm::makeArrayRef(BuiltinInfo,
8131                    clang::WebAssembly::LastTSBuiltin - Builtin::FirstTSBuiltin);
8132   }
8133   BuiltinVaListKind getBuiltinVaListKind() const final {
8134     return VoidPtrBuiltinVaList;
8135   }
8136   ArrayRef<const char *> getGCCRegNames() const final {
8137     return None;
8138   }
8139   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
8140     return None;
8141   }
8142   bool
8143   validateAsmConstraint(const char *&Name,
8144                         TargetInfo::ConstraintInfo &Info) const final {
8145     return false;
8146   }
8147   const char *getClobbers() const final { return ""; }
8148   bool isCLZForZeroUndef() const final { return false; }
8149   bool hasInt128Type() const final { return true; }
8150   IntType getIntTypeByWidth(unsigned BitWidth,
8151                             bool IsSigned) const final {
8152     // WebAssembly prefers long long for explicitly 64-bit integers.
8153     return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
8154                           : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
8155   }
8156   IntType getLeastIntTypeByWidth(unsigned BitWidth,
8157                                  bool IsSigned) const final {
8158     // WebAssembly uses long long for int_least64_t and int_fast64_t.
8159     return BitWidth == 64
8160                ? (IsSigned ? SignedLongLong : UnsignedLongLong)
8161                : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
8162   }
8163 };
8164
8165 const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
8166 #define BUILTIN(ID, TYPE, ATTRS) \
8167   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8168 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
8169   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
8170 #include "clang/Basic/BuiltinsWebAssembly.def"
8171 };
8172
8173 class WebAssembly32TargetInfo : public WebAssemblyTargetInfo {
8174 public:
8175   explicit WebAssembly32TargetInfo(const llvm::Triple &T,
8176                                    const TargetOptions &Opts)
8177       : WebAssemblyTargetInfo(T, Opts) {
8178     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
8179     resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128");
8180   }
8181
8182 protected:
8183   void getTargetDefines(const LangOptions &Opts,
8184                         MacroBuilder &Builder) const override {
8185     WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
8186     defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
8187   }
8188 };
8189
8190 class WebAssembly64TargetInfo : public WebAssemblyTargetInfo {
8191 public:
8192   explicit WebAssembly64TargetInfo(const llvm::Triple &T,
8193                                    const TargetOptions &Opts)
8194       : WebAssemblyTargetInfo(T, Opts) {
8195     LongAlign = LongWidth = 64;
8196     PointerAlign = PointerWidth = 64;
8197     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
8198     SizeType = UnsignedLong;
8199     PtrDiffType = SignedLong;
8200     IntPtrType = SignedLong;
8201     resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
8202   }
8203
8204 protected:
8205   void getTargetDefines(const LangOptions &Opts,
8206                         MacroBuilder &Builder) const override {
8207     WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
8208     defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
8209   }
8210 };
8211
8212 const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
8213 #define BUILTIN(ID, TYPE, ATTRS)                                               \
8214   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8215 #include "clang/Basic/BuiltinsLe64.def"
8216 };
8217
8218 static const unsigned SPIRAddrSpaceMap[] = {
8219     1, // opencl_global
8220     3, // opencl_local
8221     2, // opencl_constant
8222     4, // opencl_generic
8223     0, // cuda_device
8224     0, // cuda_constant
8225     0  // cuda_shared
8226 };
8227 class SPIRTargetInfo : public TargetInfo {
8228 public:
8229   SPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8230       : TargetInfo(Triple) {
8231     assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
8232            "SPIR target must use unknown OS");
8233     assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
8234            "SPIR target must use unknown environment type");
8235     TLSSupported = false;
8236     LongWidth = LongAlign = 64;
8237     AddrSpaceMap = &SPIRAddrSpaceMap;
8238     UseAddrSpaceMapMangling = true;
8239     // Define available target features
8240     // These must be defined in sorted order!
8241     NoAsmVariants = true;
8242   }
8243   void getTargetDefines(const LangOptions &Opts,
8244                         MacroBuilder &Builder) const override {
8245     DefineStd(Builder, "SPIR", Opts);
8246   }
8247   bool hasFeature(StringRef Feature) const override {
8248     return Feature == "spir";
8249   }
8250
8251   ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
8252   const char *getClobbers() const override { return ""; }
8253   ArrayRef<const char *> getGCCRegNames() const override { return None; }
8254   bool validateAsmConstraint(const char *&Name,
8255                              TargetInfo::ConstraintInfo &info) const override {
8256     return true;
8257   }
8258   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8259     return None;
8260   }
8261   BuiltinVaListKind getBuiltinVaListKind() const override {
8262     return TargetInfo::VoidPtrBuiltinVaList;
8263   }
8264
8265   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
8266     return (CC == CC_SpirFunction || CC == CC_OpenCLKernel) ? CCCR_OK
8267                                                             : CCCR_Warning;
8268   }
8269
8270   CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
8271     return CC_SpirFunction;
8272   }
8273
8274   void setSupportedOpenCLOpts() override {
8275     // Assume all OpenCL extensions and optional core features are supported
8276     // for SPIR since it is a generic target.
8277     getSupportedOpenCLOpts().supportAll();
8278   }
8279 };
8280
8281 class SPIR32TargetInfo : public SPIRTargetInfo {
8282 public:
8283   SPIR32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8284       : SPIRTargetInfo(Triple, Opts) {
8285     PointerWidth = PointerAlign = 32;
8286     SizeType = TargetInfo::UnsignedInt;
8287     PtrDiffType = IntPtrType = TargetInfo::SignedInt;
8288     resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
8289                     "v96:128-v192:256-v256:256-v512:512-v1024:1024");
8290   }
8291   void getTargetDefines(const LangOptions &Opts,
8292                         MacroBuilder &Builder) const override {
8293     DefineStd(Builder, "SPIR32", Opts);
8294   }
8295 };
8296
8297 class SPIR64TargetInfo : public SPIRTargetInfo {
8298 public:
8299   SPIR64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8300       : SPIRTargetInfo(Triple, Opts) {
8301     PointerWidth = PointerAlign = 64;
8302     SizeType = TargetInfo::UnsignedLong;
8303     PtrDiffType = IntPtrType = TargetInfo::SignedLong;
8304     resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
8305                     "v96:128-v192:256-v256:256-v512:512-v1024:1024");
8306   }
8307   void getTargetDefines(const LangOptions &Opts,
8308                         MacroBuilder &Builder) const override {
8309     DefineStd(Builder, "SPIR64", Opts);
8310   }
8311 };
8312
8313 class XCoreTargetInfo : public TargetInfo {
8314   static const Builtin::Info BuiltinInfo[];
8315 public:
8316   XCoreTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8317       : TargetInfo(Triple) {
8318     NoAsmVariants = true;
8319     LongLongAlign = 32;
8320     SuitableAlign = 32;
8321     DoubleAlign = LongDoubleAlign = 32;
8322     SizeType = UnsignedInt;
8323     PtrDiffType = SignedInt;
8324     IntPtrType = SignedInt;
8325     WCharType = UnsignedChar;
8326     WIntType = UnsignedInt;
8327     UseZeroLengthBitfieldAlignment = true;
8328     resetDataLayout("e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
8329                     "-f64:32-a:0:32-n32");
8330   }
8331   void getTargetDefines(const LangOptions &Opts,
8332                         MacroBuilder &Builder) const override {
8333     Builder.defineMacro("__XS1B__");
8334   }
8335   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
8336     return llvm::makeArrayRef(BuiltinInfo,
8337                            clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin);
8338   }
8339   BuiltinVaListKind getBuiltinVaListKind() const override {
8340     return TargetInfo::VoidPtrBuiltinVaList;
8341   }
8342   const char *getClobbers() const override {
8343     return "";
8344   }
8345   ArrayRef<const char *> getGCCRegNames() const override {
8346     static const char * const GCCRegNames[] = {
8347       "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
8348       "r8",   "r9",   "r10",  "r11",  "cp",   "dp",   "sp",   "lr"
8349     };
8350     return llvm::makeArrayRef(GCCRegNames);
8351   }
8352   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8353     return None;
8354   }
8355   bool validateAsmConstraint(const char *&Name,
8356                              TargetInfo::ConstraintInfo &Info) const override {
8357     return false;
8358   }
8359   int getEHDataRegisterNumber(unsigned RegNo) const override {
8360     // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
8361     return (RegNo < 2)? RegNo : -1;
8362   }
8363   bool allowsLargerPreferedTypeAlignment() const override {
8364     return false;
8365   }
8366 };
8367
8368 const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
8369 #define BUILTIN(ID, TYPE, ATTRS) \
8370   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8371 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
8372   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
8373 #include "clang/Basic/BuiltinsXCore.def"
8374 };
8375
8376 // x86_32 Android target
8377 class AndroidX86_32TargetInfo : public LinuxTargetInfo<X86_32TargetInfo> {
8378 public:
8379   AndroidX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8380       : LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts) {
8381     SuitableAlign = 32;
8382     LongDoubleWidth = 64;
8383     LongDoubleFormat = &llvm::APFloat::IEEEdouble();
8384   }
8385 };
8386
8387 // x86_64 Android target
8388 class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> {
8389 public:
8390   AndroidX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8391       : LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts) {
8392     LongDoubleFormat = &llvm::APFloat::IEEEquad();
8393   }
8394
8395   bool useFloat128ManglingForLongDouble() const override {
8396     return true;
8397   }
8398 };
8399
8400 // 32-bit RenderScript is armv7 with width and align of 'long' set to 8-bytes
8401 class RenderScript32TargetInfo : public ARMleTargetInfo {
8402 public:
8403   RenderScript32TargetInfo(const llvm::Triple &Triple,
8404                            const TargetOptions &Opts)
8405       : ARMleTargetInfo(llvm::Triple("armv7", Triple.getVendorName(),
8406                                      Triple.getOSName(),
8407                                      Triple.getEnvironmentName()),
8408                         Opts) {
8409     IsRenderScriptTarget = true;
8410     LongWidth = LongAlign = 64;
8411   }
8412   void getTargetDefines(const LangOptions &Opts,
8413                         MacroBuilder &Builder) const override {
8414     Builder.defineMacro("__RENDERSCRIPT__");
8415     ARMleTargetInfo::getTargetDefines(Opts, Builder);
8416   }
8417 };
8418
8419 // 64-bit RenderScript is aarch64
8420 class RenderScript64TargetInfo : public AArch64leTargetInfo {
8421 public:
8422   RenderScript64TargetInfo(const llvm::Triple &Triple,
8423                            const TargetOptions &Opts)
8424       : AArch64leTargetInfo(llvm::Triple("aarch64", Triple.getVendorName(),
8425                                          Triple.getOSName(),
8426                                          Triple.getEnvironmentName()),
8427                             Opts) {
8428     IsRenderScriptTarget = true;
8429   }
8430
8431   void getTargetDefines(const LangOptions &Opts,
8432                         MacroBuilder &Builder) const override {
8433     Builder.defineMacro("__RENDERSCRIPT__");
8434     AArch64leTargetInfo::getTargetDefines(Opts, Builder);
8435   }
8436 };
8437
8438
8439 // AVR Target
8440 class AVRTargetInfo : public TargetInfo {
8441 public:
8442   AVRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8443       : TargetInfo(Triple) {
8444     TLSSupported = false;
8445     PointerWidth = 16;
8446     PointerAlign = 8;
8447     IntWidth = 16;
8448     IntAlign = 8;
8449     LongWidth = 32;
8450     LongAlign = 8;
8451     LongLongWidth = 64;
8452     LongLongAlign = 8;
8453     SuitableAlign = 8;
8454     DefaultAlignForAttributeAligned = 8;
8455     HalfWidth = 16;
8456     HalfAlign = 8;
8457     FloatWidth = 32;
8458     FloatAlign = 8;
8459     DoubleWidth = 32;
8460     DoubleAlign = 8;
8461     DoubleFormat = &llvm::APFloat::IEEEsingle();
8462     LongDoubleWidth = 32;
8463     LongDoubleAlign = 8;
8464     LongDoubleFormat = &llvm::APFloat::IEEEsingle();
8465     SizeType = UnsignedInt;
8466     PtrDiffType = SignedInt;
8467     IntPtrType = SignedInt;
8468     Char16Type = UnsignedInt;
8469     WCharType = SignedInt;
8470     WIntType = SignedInt;
8471     Char32Type = UnsignedLong;
8472     SigAtomicType = SignedChar;
8473     resetDataLayout("e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
8474                     "-f32:32:32-f64:64:64-n8");
8475   }
8476
8477   void getTargetDefines(const LangOptions &Opts,
8478                         MacroBuilder &Builder) const override {
8479     Builder.defineMacro("__AVR__");
8480   }
8481
8482   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
8483     return None;
8484   }
8485
8486   BuiltinVaListKind getBuiltinVaListKind() const override {
8487     return TargetInfo::VoidPtrBuiltinVaList;
8488   }
8489
8490   const char *getClobbers() const override {
8491     return "";
8492   }
8493
8494   ArrayRef<const char *> getGCCRegNames() const override {
8495     static const char * const GCCRegNames[] = {
8496       "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
8497       "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
8498       "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
8499       "r24",  "r25",  "X",    "Y",    "Z",    "SP"
8500     };
8501     return llvm::makeArrayRef(GCCRegNames);
8502   }
8503
8504   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8505     return None;
8506   }
8507
8508   ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override {
8509     static const TargetInfo::AddlRegName AddlRegNames[] = {
8510       { { "r26", "r27"}, 26 },
8511       { { "r28", "r29"}, 27 },
8512       { { "r30", "r31"}, 28 },
8513       { { "SPL", "SPH"}, 29 },
8514     };
8515     return llvm::makeArrayRef(AddlRegNames);
8516   }
8517
8518   bool validateAsmConstraint(const char *&Name,
8519                              TargetInfo::ConstraintInfo &Info) const override {
8520     return false;
8521   }
8522
8523   IntType getIntTypeByWidth(unsigned BitWidth,
8524                             bool IsSigned) const final {
8525     // AVR prefers int for 16-bit integers.
8526     return BitWidth == 16 ? (IsSigned ? SignedInt : UnsignedInt)
8527                           : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
8528   }
8529
8530   IntType getLeastIntTypeByWidth(unsigned BitWidth,
8531                                  bool IsSigned) const final {
8532     // AVR uses int for int_least16_t and int_fast16_t.
8533     return BitWidth == 16
8534                ? (IsSigned ? SignedInt : UnsignedInt)
8535                : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
8536   }
8537 };
8538
8539 } // end anonymous namespace
8540
8541 //===----------------------------------------------------------------------===//
8542 // Driver code
8543 //===----------------------------------------------------------------------===//
8544
8545 static TargetInfo *AllocateTarget(const llvm::Triple &Triple,
8546                                   const TargetOptions &Opts) {
8547   llvm::Triple::OSType os = Triple.getOS();
8548
8549   switch (Triple.getArch()) {
8550   default:
8551     return nullptr;
8552
8553   case llvm::Triple::xcore:
8554     return new XCoreTargetInfo(Triple, Opts);
8555
8556   case llvm::Triple::hexagon:
8557     return new HexagonTargetInfo(Triple, Opts);
8558
8559   case llvm::Triple::lanai:
8560     return new LanaiTargetInfo(Triple, Opts);
8561
8562   case llvm::Triple::aarch64:
8563     if (Triple.isOSDarwin())
8564       return new DarwinAArch64TargetInfo(Triple, Opts);
8565
8566     switch (os) {
8567     case llvm::Triple::CloudABI:
8568       return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
8569     case llvm::Triple::FreeBSD:
8570       return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
8571     case llvm::Triple::Fuchsia:
8572       return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
8573     case llvm::Triple::Linux:
8574       return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
8575     case llvm::Triple::NetBSD:
8576       return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
8577     default:
8578       return new AArch64leTargetInfo(Triple, Opts);
8579     }
8580
8581   case llvm::Triple::aarch64_be:
8582     switch (os) {
8583     case llvm::Triple::FreeBSD:
8584       return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
8585     case llvm::Triple::Fuchsia:
8586       return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
8587     case llvm::Triple::Linux:
8588       return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
8589     case llvm::Triple::NetBSD:
8590       return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
8591     default:
8592       return new AArch64beTargetInfo(Triple, Opts);
8593     }
8594
8595   case llvm::Triple::arm:
8596   case llvm::Triple::thumb:
8597     if (Triple.isOSBinFormatMachO())
8598       return new DarwinARMTargetInfo(Triple, Opts);
8599
8600     switch (os) {
8601     case llvm::Triple::CloudABI:
8602       return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
8603     case llvm::Triple::Linux:
8604       return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
8605     case llvm::Triple::FreeBSD:
8606       return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
8607     case llvm::Triple::Fuchsia:
8608       return new FuchsiaTargetInfo<ARMleTargetInfo>(Triple, Opts);
8609     case llvm::Triple::NetBSD:
8610       return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
8611     case llvm::Triple::OpenBSD:
8612       return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
8613     case llvm::Triple::Bitrig:
8614       return new BitrigTargetInfo<ARMleTargetInfo>(Triple, Opts);
8615     case llvm::Triple::RTEMS:
8616       return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
8617     case llvm::Triple::NaCl:
8618       return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
8619     case llvm::Triple::Win32:
8620       switch (Triple.getEnvironment()) {
8621       case llvm::Triple::Cygnus:
8622         return new CygwinARMTargetInfo(Triple, Opts);
8623       case llvm::Triple::GNU:
8624         return new MinGWARMTargetInfo(Triple, Opts);
8625       case llvm::Triple::Itanium:
8626         return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
8627       case llvm::Triple::MSVC:
8628       default: // Assume MSVC for unknown environments
8629         return new MicrosoftARMleTargetInfo(Triple, Opts);
8630       }
8631     default:
8632       return new ARMleTargetInfo(Triple, Opts);
8633     }
8634
8635   case llvm::Triple::armeb:
8636   case llvm::Triple::thumbeb:
8637     if (Triple.isOSDarwin())
8638       return new DarwinARMTargetInfo(Triple, Opts);
8639
8640     switch (os) {
8641     case llvm::Triple::Linux:
8642       return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8643     case llvm::Triple::FreeBSD:
8644       return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8645     case llvm::Triple::Fuchsia:
8646       return new FuchsiaTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8647     case llvm::Triple::NetBSD:
8648       return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8649     case llvm::Triple::OpenBSD:
8650       return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8651     case llvm::Triple::Bitrig:
8652       return new BitrigTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8653     case llvm::Triple::RTEMS:
8654       return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8655     case llvm::Triple::NaCl:
8656       return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
8657     default:
8658       return new ARMbeTargetInfo(Triple, Opts);
8659     }
8660
8661   case llvm::Triple::avr:
8662     return new AVRTargetInfo(Triple, Opts);
8663   case llvm::Triple::bpfeb:
8664   case llvm::Triple::bpfel:
8665     return new BPFTargetInfo(Triple, Opts);
8666
8667   case llvm::Triple::msp430:
8668     return new MSP430TargetInfo(Triple, Opts);
8669
8670   case llvm::Triple::mips:
8671     switch (os) {
8672     case llvm::Triple::Linux:
8673       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
8674     case llvm::Triple::RTEMS:
8675       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
8676     case llvm::Triple::FreeBSD:
8677       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8678     case llvm::Triple::NetBSD:
8679       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8680     default:
8681       return new MipsTargetInfo(Triple, Opts);
8682     }
8683
8684   case llvm::Triple::mipsel:
8685     switch (os) {
8686     case llvm::Triple::Linux:
8687       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
8688     case llvm::Triple::RTEMS:
8689       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
8690     case llvm::Triple::FreeBSD:
8691       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8692     case llvm::Triple::NetBSD:
8693       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8694     case llvm::Triple::NaCl:
8695       return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
8696     default:
8697       return new MipsTargetInfo(Triple, Opts);
8698     }
8699
8700   case llvm::Triple::mips64:
8701     switch (os) {
8702     case llvm::Triple::Linux:
8703       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
8704     case llvm::Triple::RTEMS:
8705       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
8706     case llvm::Triple::FreeBSD:
8707       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8708     case llvm::Triple::NetBSD:
8709       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8710     case llvm::Triple::OpenBSD:
8711       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8712     default:
8713       return new MipsTargetInfo(Triple, Opts);
8714     }
8715
8716   case llvm::Triple::mips64el:
8717     switch (os) {
8718     case llvm::Triple::Linux:
8719       return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
8720     case llvm::Triple::RTEMS:
8721       return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
8722     case llvm::Triple::FreeBSD:
8723       return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8724     case llvm::Triple::NetBSD:
8725       return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8726     case llvm::Triple::OpenBSD:
8727       return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
8728     default:
8729       return new MipsTargetInfo(Triple, Opts);
8730     }
8731
8732   case llvm::Triple::le32:
8733     switch (os) {
8734     case llvm::Triple::NaCl:
8735       return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
8736     default:
8737       return nullptr;
8738     }
8739
8740   case llvm::Triple::le64:
8741     return new Le64TargetInfo(Triple, Opts);
8742
8743   case llvm::Triple::ppc:
8744     if (Triple.isOSDarwin())
8745       return new DarwinPPC32TargetInfo(Triple, Opts);
8746     switch (os) {
8747     case llvm::Triple::Linux:
8748       return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
8749     case llvm::Triple::FreeBSD:
8750       return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
8751     case llvm::Triple::NetBSD:
8752       return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
8753     case llvm::Triple::OpenBSD:
8754       return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
8755     case llvm::Triple::RTEMS:
8756       return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
8757     default:
8758       return new PPC32TargetInfo(Triple, Opts);
8759     }
8760
8761   case llvm::Triple::ppc64:
8762     if (Triple.isOSDarwin())
8763       return new DarwinPPC64TargetInfo(Triple, Opts);
8764     switch (os) {
8765     case llvm::Triple::Linux:
8766       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
8767     case llvm::Triple::Lv2:
8768       return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
8769     case llvm::Triple::FreeBSD:
8770       return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
8771     case llvm::Triple::NetBSD:
8772       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
8773     default:
8774       return new PPC64TargetInfo(Triple, Opts);
8775     }
8776
8777   case llvm::Triple::ppc64le:
8778     switch (os) {
8779     case llvm::Triple::Linux:
8780       return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
8781     case llvm::Triple::NetBSD:
8782       return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
8783     default:
8784       return new PPC64TargetInfo(Triple, Opts);
8785     }
8786
8787   case llvm::Triple::nvptx:
8788     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
8789   case llvm::Triple::nvptx64:
8790     return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
8791
8792   case llvm::Triple::amdgcn:
8793   case llvm::Triple::r600:
8794     return new AMDGPUTargetInfo(Triple, Opts);
8795
8796   case llvm::Triple::sparc:
8797     switch (os) {
8798     case llvm::Triple::Linux:
8799       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
8800     case llvm::Triple::Solaris:
8801       return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
8802     case llvm::Triple::NetBSD:
8803       return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
8804     case llvm::Triple::OpenBSD:
8805       return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
8806     case llvm::Triple::RTEMS:
8807       return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
8808     default:
8809       return new SparcV8TargetInfo(Triple, Opts);
8810     }
8811
8812   // The 'sparcel' architecture copies all the above cases except for Solaris.
8813   case llvm::Triple::sparcel:
8814     switch (os) {
8815     case llvm::Triple::Linux:
8816       return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
8817     case llvm::Triple::NetBSD:
8818       return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
8819     case llvm::Triple::OpenBSD:
8820       return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
8821     case llvm::Triple::RTEMS:
8822       return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
8823     default:
8824       return new SparcV8elTargetInfo(Triple, Opts);
8825     }
8826
8827   case llvm::Triple::sparcv9:
8828     switch (os) {
8829     case llvm::Triple::Linux:
8830       return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
8831     case llvm::Triple::Solaris:
8832       return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
8833     case llvm::Triple::NetBSD:
8834       return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
8835     case llvm::Triple::OpenBSD:
8836       return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
8837     case llvm::Triple::FreeBSD:
8838       return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
8839     default:
8840       return new SparcV9TargetInfo(Triple, Opts);
8841     }
8842
8843   case llvm::Triple::systemz:
8844     switch (os) {
8845     case llvm::Triple::Linux:
8846       return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
8847     default:
8848       return new SystemZTargetInfo(Triple, Opts);
8849     }
8850
8851   case llvm::Triple::tce:
8852     return new TCETargetInfo(Triple, Opts);
8853
8854   case llvm::Triple::tcele:
8855     return new TCELETargetInfo(Triple, Opts);
8856
8857   case llvm::Triple::x86:
8858     if (Triple.isOSDarwin())
8859       return new DarwinI386TargetInfo(Triple, Opts);
8860
8861     switch (os) {
8862     case llvm::Triple::CloudABI:
8863       return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
8864     case llvm::Triple::Linux: {
8865       switch (Triple.getEnvironment()) {
8866       default:
8867         return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
8868       case llvm::Triple::Android:
8869         return new AndroidX86_32TargetInfo(Triple, Opts);
8870       }
8871     }
8872     case llvm::Triple::DragonFly:
8873       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
8874     case llvm::Triple::NetBSD:
8875       return new NetBSDI386TargetInfo(Triple, Opts);
8876     case llvm::Triple::OpenBSD:
8877       return new OpenBSDI386TargetInfo(Triple, Opts);
8878     case llvm::Triple::Bitrig:
8879       return new BitrigI386TargetInfo(Triple, Opts);
8880     case llvm::Triple::FreeBSD:
8881       return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
8882     case llvm::Triple::Fuchsia:
8883       return new FuchsiaTargetInfo<X86_32TargetInfo>(Triple, Opts);
8884     case llvm::Triple::KFreeBSD:
8885       return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
8886     case llvm::Triple::Minix:
8887       return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
8888     case llvm::Triple::Solaris:
8889       return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
8890     case llvm::Triple::Win32: {
8891       switch (Triple.getEnvironment()) {
8892       case llvm::Triple::Cygnus:
8893         return new CygwinX86_32TargetInfo(Triple, Opts);
8894       case llvm::Triple::GNU:
8895         return new MinGWX86_32TargetInfo(Triple, Opts);
8896       case llvm::Triple::Itanium:
8897       case llvm::Triple::MSVC:
8898       default: // Assume MSVC for unknown environments
8899         return new MicrosoftX86_32TargetInfo(Triple, Opts);
8900       }
8901     }
8902     case llvm::Triple::Haiku:
8903       return new HaikuX86_32TargetInfo(Triple, Opts);
8904     case llvm::Triple::RTEMS:
8905       return new RTEMSX86_32TargetInfo(Triple, Opts);
8906     case llvm::Triple::NaCl:
8907       return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
8908     case llvm::Triple::ELFIAMCU:
8909       return new MCUX86_32TargetInfo(Triple, Opts);
8910     default:
8911       return new X86_32TargetInfo(Triple, Opts);
8912     }
8913
8914   case llvm::Triple::x86_64:
8915     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
8916       return new DarwinX86_64TargetInfo(Triple, Opts);
8917
8918     switch (os) {
8919     case llvm::Triple::CloudABI:
8920       return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
8921     case llvm::Triple::Linux: {
8922       switch (Triple.getEnvironment()) {
8923       default:
8924         return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
8925       case llvm::Triple::Android:
8926         return new AndroidX86_64TargetInfo(Triple, Opts);
8927       }
8928     }
8929     case llvm::Triple::DragonFly:
8930       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
8931     case llvm::Triple::NetBSD:
8932       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
8933     case llvm::Triple::OpenBSD:
8934       return new OpenBSDX86_64TargetInfo(Triple, Opts);
8935     case llvm::Triple::Bitrig:
8936       return new BitrigX86_64TargetInfo(Triple, Opts);
8937     case llvm::Triple::FreeBSD:
8938       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
8939     case llvm::Triple::Fuchsia:
8940       return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
8941     case llvm::Triple::KFreeBSD:
8942       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
8943     case llvm::Triple::Solaris:
8944       return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
8945     case llvm::Triple::Win32: {
8946       switch (Triple.getEnvironment()) {
8947       case llvm::Triple::Cygnus:
8948         return new CygwinX86_64TargetInfo(Triple, Opts);
8949       case llvm::Triple::GNU:
8950         return new MinGWX86_64TargetInfo(Triple, Opts);
8951       case llvm::Triple::MSVC:
8952       default: // Assume MSVC for unknown environments
8953         return new MicrosoftX86_64TargetInfo(Triple, Opts);
8954       }
8955     }
8956     case llvm::Triple::Haiku:
8957       return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
8958     case llvm::Triple::NaCl:
8959       return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
8960     case llvm::Triple::PS4:
8961       return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
8962     default:
8963       return new X86_64TargetInfo(Triple, Opts);
8964     }
8965
8966   case llvm::Triple::spir: {
8967     if (Triple.getOS() != llvm::Triple::UnknownOS ||
8968         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
8969       return nullptr;
8970     return new SPIR32TargetInfo(Triple, Opts);
8971   }
8972   case llvm::Triple::spir64: {
8973     if (Triple.getOS() != llvm::Triple::UnknownOS ||
8974         Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
8975       return nullptr;
8976     return new SPIR64TargetInfo(Triple, Opts);
8977   }
8978   case llvm::Triple::wasm32:
8979     if (!(Triple == llvm::Triple("wasm32-unknown-unknown")))
8980       return nullptr;
8981     return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
8982   case llvm::Triple::wasm64:
8983     if (!(Triple == llvm::Triple("wasm64-unknown-unknown")))
8984       return nullptr;
8985     return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
8986
8987   case llvm::Triple::renderscript32:
8988     return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
8989   case llvm::Triple::renderscript64:
8990     return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
8991   }
8992 }
8993
8994 /// CreateTargetInfo - Return the target info object for the specified target
8995 /// options.
8996 TargetInfo *
8997 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
8998                              const std::shared_ptr<TargetOptions> &Opts) {
8999   llvm::Triple Triple(Opts->Triple);
9000
9001   // Construct the target
9002   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
9003   if (!Target) {
9004     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
9005     return nullptr;
9006   }
9007   Target->TargetOpts = Opts;
9008
9009   // Set the target CPU if specified.
9010   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
9011     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
9012     return nullptr;
9013   }
9014
9015   // Set the target ABI if specified.
9016   if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
9017     Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
9018     return nullptr;
9019   }
9020
9021   // Set the fp math unit.
9022   if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
9023     Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
9024     return nullptr;
9025   }
9026
9027   // Compute the default target features, we need the target to handle this
9028   // because features may have dependencies on one another.
9029   llvm::StringMap<bool> Features;
9030   if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
9031                               Opts->FeaturesAsWritten))
9032       return nullptr;
9033
9034   // Add the features to the compile options.
9035   Opts->Features.clear();
9036   for (const auto &F : Features)
9037     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
9038
9039   if (!Target->handleTargetFeatures(Opts->Features, Diags))
9040     return nullptr;
9041
9042   Target->setSupportedOpenCLOpts();
9043   Target->setOpenCLExtensionOpts();
9044
9045   if (!Target->validateTarget(Diags))
9046     return nullptr;
9047
9048   return Target.release();
9049 }