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

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