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/MC/MCSectionMachO.h"
  29 #include "llvm/Support/ErrorHandling.h"
  30 #include "llvm/Type.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 //===----------------------------------------------------------------------===//
  58 // Defines specific to certain operating systems.
  59 //===----------------------------------------------------------------------===//
  60
  61 namespace {
  62 template<typename TgtInfo>
  63 class OSTargetInfo : public TgtInfo {
  64 protected:
  65   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
  66                             MacroBuilder &Builder) const=0;
  67 public:
  68   OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
  69   virtual void getTargetDefines(const LangOptions &Opts,
  70                                 MacroBuilder &Builder) const {
  71     TgtInfo::getTargetDefines(Opts, Builder);
  72     getOSDefines(Opts, TgtInfo::getTriple(), Builder);
  73   }
  74
  75 };
  76 } // end anonymous namespace
  77
  78
  79 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
  80                              const llvm::Triple &Triple,
  81                              StringRef &PlatformName,
  82                              VersionTuple &PlatformMinVersion) {
  83   Builder.defineMacro("__APPLE_CC__", "5621");
  84   Builder.defineMacro("__APPLE__");
  85   Builder.defineMacro("__MACH__");
  86   Builder.defineMacro("OBJC_NEW_PROPERTIES");
  87
  88   if (!Opts.ObjCAutoRefCount) {
  89     // __weak is always defined, for use in blocks and with objc pointers.
  90     Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
  91
  92     // Darwin defines __strong even in C mode (just to nothing).
  93     if (Opts.getGC() != LangOptions::NonGC)
  94       Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
  95     else
  96       Builder.defineMacro("__strong", "");
  97
  98     // __unsafe_unretained is defined to nothing in non-ARC mode. We even
  99     // allow this in C, since one might have block pointers in structs that
 100     // are used in pure C code and in Objective-C ARC.
 101     Builder.defineMacro("__unsafe_unretained", "");
 102
 103     // The Objective-C bridged cast keywords are defined to nothing in non-ARC
 104     // mode; then they become normal, C-style casts.
 105     Builder.defineMacro("__bridge", "");
 106     Builder.defineMacro("__bridge_transfer", "");
 107     Builder.defineMacro("__bridge_retained", "");
 108     Builder.defineMacro("__bridge_retain", "");
 109   }
 110
 111   if (Opts.Static)
 112     Builder.defineMacro("__STATIC__");
 113   else
 114     Builder.defineMacro("__DYNAMIC__");
 115
 116   if (Opts.POSIXThreads)
 117     Builder.defineMacro("_REENTRANT");
 118
 119   // Get the platform type and version number from the triple.
 120   unsigned Maj, Min, Rev;
 121
 122   // If no version was given, default to to 10.4.0, for simplifying tests.
 123   if (Triple.getOSName() == "darwin" || Triple.getOSName() == "osx") {
 124     PlatformName = "macosx";
 125     Min = Rev = 0;
 126     Maj = 8;
 127   } else {
 128     // Otherwise, honor all three triple forms ("-darwinNNN[-iphoneos]",
 129     // "-osxNNN", and "-iosNNN").
 130
 131     if (Triple.getOS() == llvm::Triple::Darwin) {
 132       // For historical reasons that make little sense, the version passed here
 133       // is the "darwin" version, which drops the 10 and offsets by 4.
 134       Triple.getOSVersion(Maj, Min, Rev);
 135
 136       if (Triple.getEnvironmentName() == "iphoneos") {
 137         PlatformName = "ios";
 138       } else {
 139         PlatformName = "macosx";
 140         Rev = Min;
 141         Min = Maj - 4;
 142         Maj = 10;
 143       }
 144     } else {
 145       Triple.getOSVersion(Maj, Min, Rev);
 146       PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
 147     }
 148   }
 149
 150   // If -ccc-host-triple arch-pc-win32-macho option specified, we're
 151   // generating code for Win32 ABI. No need to emit
 152   // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
 153   if (PlatformName == "win32") {
 154     PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 155     return;
 156   }
 157
 158   // Set the appropriate OS version define.
 159   if (PlatformName == "ios") {
 160     assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
 161     char Str[6];
 162     Str[0] = '0' + Maj;
 163     Str[1] = '0' + (Min / 10);
 164     Str[2] = '0' + (Min % 10);
 165     Str[3] = '0' + (Rev / 10);
 166     Str[4] = '0' + (Rev % 10);
 167     Str[5] = '\0';
 168     Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
 169   } else {
 170     // Note that the Driver allows versions which aren't representable in the
 171     // define (because we only get a single digit for the minor and micro
 172     // revision numbers). So, we limit them to the maximum representable
 173     // version.
 174     assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
 175     assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
 176     char Str[5];
 177     Str[0] = '0' + (Maj / 10);
 178     Str[1] = '0' + (Maj % 10);
 179     Str[2] = '0' + std::min(Min, 9U);
 180     Str[3] = '0' + std::min(Rev, 9U);
 181     Str[4] = '\0';
 182     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
 183   }
 184
 185   PlatformMinVersion = VersionTuple(Maj, Min, Rev);
 186 }
 187
 188 namespace {
 189 template<typename Target>
 190 class DarwinTargetInfo : public OSTargetInfo<Target> {
 191 protected:
 192   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 193                             MacroBuilder &Builder) const {
 194     getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
 195                      this->PlatformMinVersion);
 196   }
 197
 198 public:
 199   DarwinTargetInfo(const std::string& triple) :
 200     OSTargetInfo<Target>(triple) {
 201       llvm::Triple T = llvm::Triple(triple);
 202       this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
 203       this->MCountName = "\01mcount";
 204     }
 205
 206   virtual std::string isValidSectionSpecifier(StringRef SR) const {
 207     // Let MCSectionMachO validate this.
 208     StringRef Segment, Section;
 209     unsigned TAA, StubSize;
 210     bool HasTAA;
 211     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
 212                                                        TAA, HasTAA, StubSize);
 213   }
 214
 215   virtual const char *getStaticInitSectionSpecifier() const {
 216     // FIXME: We should return 0 when building kexts.
 217     return "__TEXT,__StaticInit,regular,pure_instructions";
 218   }
 219
 220 };
 221
 222
 223 // DragonFlyBSD Target
 224 template<typename Target>
 225 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
 226 protected:
 227   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 228                             MacroBuilder &Builder) const {
 229     // DragonFly defines; list based off of gcc output
 230     Builder.defineMacro("__DragonFly__");
 231     Builder.defineMacro("__DragonFly_cc_version", "100001");
 232     Builder.defineMacro("__ELF__");
 233     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 234     Builder.defineMacro("__tune_i386__");
 235     DefineStd(Builder, "unix", Opts);
 236   }
 237 public:
 238   DragonFlyBSDTargetInfo(const std::string &triple)
 239     : OSTargetInfo<Target>(triple) {}
 240 };
 241
 242 // FreeBSD Target
 243 template<typename Target>
 244 class FreeBSDTargetInfo : public OSTargetInfo<Target> {
 245 protected:
 246   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 247                             MacroBuilder &Builder) const {
 248     // FreeBSD defines; list based off of gcc output
 249
 250     unsigned Release = Triple.getOSMajorVersion();
 251     if (Release == 0U)
 252       Release = 8U;
 253
 254     Builder.defineMacro("__FreeBSD__", Twine(Release));
 255     Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
 256     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 257     DefineStd(Builder, "unix", Opts);
 258     Builder.defineMacro("__ELF__");
 259   }
 260 public:
 261   FreeBSDTargetInfo(const std::string &triple)
 262     : OSTargetInfo<Target>(triple) {
 263       this->UserLabelPrefix = "";
 264
 265       llvm::Triple Triple(triple);
 266       switch (Triple.getArch()) {
 267         default:
 268         case llvm::Triple::x86:
 269         case llvm::Triple::x86_64:
 270           this->MCountName = ".mcount";
 271           break;
 272         case llvm::Triple::mips:
 273         case llvm::Triple::mipsel:
 274         case llvm::Triple::ppc:
 275         case llvm::Triple::ppc64:
 276           this->MCountName = "_mcount";
 277           break;
 278         case llvm::Triple::arm:
 279           this->MCountName = "__mcount";
 280           break;
 281       }
 282
 283     }
 284 };
 285
 286 // Minix Target
 287 template<typename Target>
 288 class MinixTargetInfo : public OSTargetInfo<Target> {
 289 protected:
 290   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 291                             MacroBuilder &Builder) const {
 292     // Minix defines
 293
 294     Builder.defineMacro("__minix", "3");
 295     Builder.defineMacro("_EM_WSIZE", "4");
 296     Builder.defineMacro("_EM_PSIZE", "4");
 297     Builder.defineMacro("_EM_SSIZE", "2");
 298     Builder.defineMacro("_EM_LSIZE", "4");
 299     Builder.defineMacro("_EM_FSIZE", "4");
 300     Builder.defineMacro("_EM_DSIZE", "8");
 301     DefineStd(Builder, "unix", Opts);
 302   }
 303 public:
 304   MinixTargetInfo(const std::string &triple)
 305     : OSTargetInfo<Target>(triple) {
 306       this->UserLabelPrefix = "";
 307     }
 308 };
 309
 310 // Linux target
 311 template<typename Target>
 312 class LinuxTargetInfo : public OSTargetInfo<Target> {
 313 protected:
 314   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 315                             MacroBuilder &Builder) const {
 316     // Linux defines; list based off of gcc output
 317     DefineStd(Builder, "unix", Opts);
 318     DefineStd(Builder, "linux", Opts);
 319     Builder.defineMacro("__gnu_linux__");
 320     Builder.defineMacro("__ELF__");
 321     if (Opts.POSIXThreads)
 322       Builder.defineMacro("_REENTRANT");
 323     if (Opts.CPlusPlus)
 324       Builder.defineMacro("_GNU_SOURCE");
 325   }
 326 public:
 327   LinuxTargetInfo(const std::string& triple)
 328     : OSTargetInfo<Target>(triple) {
 329     this->UserLabelPrefix = "";
 330     this->WIntType = TargetInfo::UnsignedInt;
 331   }
 332 };
 333
 334 // NetBSD Target
 335 template<typename Target>
 336 class NetBSDTargetInfo : public OSTargetInfo<Target> {
 337 protected:
 338   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 339                             MacroBuilder &Builder) const {
 340     // NetBSD defines; list based off of gcc output
 341     Builder.defineMacro("__NetBSD__");
 342     Builder.defineMacro("__unix__");
 343     Builder.defineMacro("__ELF__");
 344     if (Opts.POSIXThreads)
 345       Builder.defineMacro("_POSIX_THREADS");
 346   }
 347 public:
 348   NetBSDTargetInfo(const std::string &triple)
 349     : OSTargetInfo<Target>(triple) {
 350       this->UserLabelPrefix = "";
 351     }
 352 };
 353
 354 // OpenBSD Target
 355 template<typename Target>
 356 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 357 protected:
 358   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 359                             MacroBuilder &Builder) const {
 360     // OpenBSD defines; list based off of gcc output
 361
 362     Builder.defineMacro("__OpenBSD__");
 363     DefineStd(Builder, "unix", Opts);
 364     Builder.defineMacro("__ELF__");
 365     if (Opts.POSIXThreads)
 366       Builder.defineMacro("_POSIX_THREADS");
 367   }
 368 public:
 369   OpenBSDTargetInfo(const std::string &triple)
 370     : OSTargetInfo<Target>(triple) {}
 371 };
 372
 373 // PSP Target
 374 template<typename Target>
 375 class PSPTargetInfo : public OSTargetInfo<Target> {
 376 protected:
 377   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 378                             MacroBuilder &Builder) const {
 379     // PSP defines; list based on the output of the pspdev gcc toolchain.
 380     Builder.defineMacro("PSP");
 381     Builder.defineMacro("_PSP");
 382     Builder.defineMacro("__psp__");
 383     Builder.defineMacro("__ELF__");
 384   }
 385 public:
 386   PSPTargetInfo(const std::string& triple)
 387     : OSTargetInfo<Target>(triple) {
 388     this->UserLabelPrefix = "";
 389   }
 390 };
 391
 392 // PS3 PPU Target
 393 template<typename Target>
 394 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
 395 protected:
 396   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 397                             MacroBuilder &Builder) const {
 398     // PS3 PPU defines.
 399     Builder.defineMacro("__PPC__");
 400     Builder.defineMacro("__PPU__");
 401     Builder.defineMacro("__CELLOS_LV2__");
 402     Builder.defineMacro("__ELF__");
 403     Builder.defineMacro("__LP32__");
 404     Builder.defineMacro("_ARCH_PPC64");
 405     Builder.defineMacro("__powerpc64__");
 406   }
 407 public:
 408   PS3PPUTargetInfo(const std::string& triple)
 409     : OSTargetInfo<Target>(triple) {
 410     this->UserLabelPrefix = "";
 411     this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
 412     this->IntMaxType = TargetInfo::SignedLongLong;
 413     this->UIntMaxType = TargetInfo::UnsignedLongLong;
 414     this->Int64Type = TargetInfo::SignedLongLong;
 415     this->SizeType = TargetInfo::UnsignedInt;
 416     this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
 417                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
 418   }
 419 };
 420
 421 // FIXME: Need a real SPU target.
 422 // PS3 SPU Target
 423 template<typename Target>
 424 class PS3SPUTargetInfo : public OSTargetInfo<Target> {
 425 protected:
 426   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 427                             MacroBuilder &Builder) const {
 428     // PS3 PPU defines.
 429     Builder.defineMacro("__SPU__");
 430     Builder.defineMacro("__ELF__");
 431   }
 432 public:
 433   PS3SPUTargetInfo(const std::string& triple)
 434     : OSTargetInfo<Target>(triple) {
 435     this->UserLabelPrefix = "";
 436   }
 437 };
 438
 439 // AuroraUX target
 440 template<typename Target>
 441 class AuroraUXTargetInfo : public OSTargetInfo<Target> {
 442 protected:
 443   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 444                             MacroBuilder &Builder) const {
 445     DefineStd(Builder, "sun", Opts);
 446     DefineStd(Builder, "unix", Opts);
 447     Builder.defineMacro("__ELF__");
 448     Builder.defineMacro("__svr4__");
 449     Builder.defineMacro("__SVR4");
 450   }
 451 public:
 452   AuroraUXTargetInfo(const std::string& triple)
 453     : OSTargetInfo<Target>(triple) {
 454     this->UserLabelPrefix = "";
 455     this->WCharType = this->SignedLong;
 456     // FIXME: WIntType should be SignedLong
 457   }
 458 };
 459
 460 // Solaris target
 461 template<typename Target>
 462 class SolarisTargetInfo : public OSTargetInfo<Target> {
 463 protected:
 464   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 465                             MacroBuilder &Builder) const {
 466     DefineStd(Builder, "sun", Opts);
 467     DefineStd(Builder, "unix", Opts);
 468     Builder.defineMacro("__ELF__");
 469     Builder.defineMacro("__svr4__");
 470     Builder.defineMacro("__SVR4");
 471   }
 472 public:
 473   SolarisTargetInfo(const std::string& triple)
 474     : OSTargetInfo<Target>(triple) {
 475     this->UserLabelPrefix = "";
 476     this->WCharType = this->SignedLong;
 477     // FIXME: WIntType should be SignedLong
 478   }
 479 };
 480
 481 // Windows target
 482 template<typename Target>
 483 class WindowsTargetInfo : public OSTargetInfo<Target> {
 484 protected:
 485   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 486                             MacroBuilder &Builder) const {
 487     Builder.defineMacro("_WIN32");
 488   }
 489   void getVisualStudioDefines(const LangOptions &Opts,
 490                               MacroBuilder &Builder) const {
 491     if (Opts.CPlusPlus) {
 492       if (Opts.RTTI)
 493         Builder.defineMacro("_CPPRTTI");
 494
 495       if (Opts.Exceptions)
 496         Builder.defineMacro("_CPPUNWIND");
 497     }
 498
 499     if (!Opts.CharIsSigned)
 500       Builder.defineMacro("_CHAR_UNSIGNED");
 501
 502     // FIXME: POSIXThreads isn't exactly the option this should be defined for,
 503     //        but it works for now.
 504     if (Opts.POSIXThreads)
 505       Builder.defineMacro("_MT");
 506
 507     if (Opts.MSCVersion != 0)
 508       Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
 509
 510     if (Opts.MicrosoftExt) {
 511       Builder.defineMacro("_MSC_EXTENSIONS");
 512
 513       if (Opts.CPlusPlus0x) {
 514         Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
 515         Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
 516         Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
 517       }
 518     }
 519
 520     Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
 521   }
 522
 523 public:
 524   WindowsTargetInfo(const std::string &triple)
 525     : OSTargetInfo<Target>(triple) {}
 526 };
 527
 528 } // end anonymous namespace.
 529
 530 //===----------------------------------------------------------------------===//
 531 // Specific target implementations.
 532 //===----------------------------------------------------------------------===//
 533
 534 namespace {
 535 // PPC abstract base class
 536 class PPCTargetInfo : public TargetInfo {
 537   static const Builtin::Info BuiltinInfo[];
 538   static const char * const GCCRegNames[];
 539   static const TargetInfo::GCCRegAlias GCCRegAliases[];
 540 public:
 541   PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
 542
 543   virtual void getTargetBuiltins(const Builtin::Info *&Records,
 544                                  unsigned &NumRecords) const {
 545     Records = BuiltinInfo;
 546     NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
 547   }
 548
 549   virtual void getTargetDefines(const LangOptions &Opts,
 550                                 MacroBuilder &Builder) const;
 551
 552   virtual void getGCCRegNames(const char * const *&Names,
 553                               unsigned &NumNames) const;
 554   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
 555                                 unsigned &NumAliases) const;
 556   virtual bool validateAsmConstraint(const char *&Name,
 557                                      TargetInfo::ConstraintInfo &Info) const {
 558     switch (*Name) {
 559     default: return false;
 560     case 'O': // Zero
 561       break;
 562     case 'b': // Base register
 563     case 'f': // Floating point register
 564       Info.setAllowsRegister();
 565       break;
 566     // FIXME: The following are added to allow parsing.
 567     // I just took a guess at what the actions should be.
 568     // Also, is more specific checking needed?  I.e. specific registers?
 569     case 'd': // Floating point register (containing 64-bit value)
 570     case 'v': // Altivec vector register
 571       Info.setAllowsRegister();
 572       break;
 573     case 'w':
 574       switch (Name[1]) {
 575         case 'd':// VSX vector register to hold vector double data
 576         case 'f':// VSX vector register to hold vector float data
 577         case 's':// VSX vector register to hold scalar float data
 578         case 'a':// Any VSX register
 579           break;
 580         default:
 581           return false;
 582       }
 583       Info.setAllowsRegister();
 584       Name++; // Skip over 'w'.
 585       break;
 586     case 'h': // `MQ', `CTR', or `LINK' register
 587     case 'q': // `MQ' register
 588     case 'c': // `CTR' register
 589     case 'l': // `LINK' register
 590     case 'x': // `CR' register (condition register) number 0
 591     case 'y': // `CR' register (condition register)
 592     case 'z': // `XER[CA]' carry bit (part of the XER register)
 593       Info.setAllowsRegister();
 594       break;
 595     case 'I': // Signed 16-bit constant
 596     case 'J': // Unsigned 16-bit constant shifted left 16 bits
 597               //  (use `L' instead for SImode constants)
 598     case 'K': // Unsigned 16-bit constant
 599     case 'L': // Signed 16-bit constant shifted left 16 bits
 600     case 'M': // Constant larger than 31
 601     case 'N': // Exact power of 2
 602     case 'P': // Constant whose negation is a signed 16-bit constant
 603     case 'G': // Floating point constant that can be loaded into a
 604               // register with one instruction per word
 605     case 'H': // Integer/Floating point constant that can be loaded
 606               // into a register using three instructions
 607       break;
 608     case 'm': // Memory operand. Note that on PowerPC targets, m can
 609               // include addresses that update the base register. It
 610               // is therefore only safe to use `m' in an asm statement
 611               // if that asm statement accesses the operand exactly once.
 612               // The asm statement must also use `%U<opno>' as a
 613               // placeholder for the "update" flag in the corresponding
 614               // load or store instruction. For example:
 615               // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
 616               // is correct but:
 617               // asm ("st %1,%0" : "=m" (mem) : "r" (val));
 618               // is not. Use es rather than m if you don't want the base
 619               // register to be updated.
 620     case 'e':
 621       if (Name[1] != 's')
 622           return false;
 623               // es: A "stable" memory operand; that is, one which does not
 624               // include any automodification of the base register. Unlike
 625               // `m', this constraint can be used in asm statements that
 626               // might access the operand several times, or that might not
 627               // access it at all.
 628       Info.setAllowsMemory();
 629       Name++; // Skip over 'e'.
 630       break;
 631     case 'Q': // Memory operand that is an offset from a register (it is
 632               // usually better to use `m' or `es' in asm statements)
 633     case 'Z': // Memory operand that is an indexed or indirect from a
 634               // register (it is usually better to use `m' or `es' in
 635               // asm statements)
 636       Info.setAllowsMemory();
 637       Info.setAllowsRegister();
 638       break;
 639     case 'R': // AIX TOC entry
 640     case 'a': // Address operand that is an indexed or indirect from a
 641               // register (`p' is preferable for asm statements)
 642     case 'S': // Constant suitable as a 64-bit mask operand
 643     case 'T': // Constant suitable as a 32-bit mask operand
 644     case 'U': // System V Release 4 small data area reference
 645     case 't': // AND masks that can be performed by two rldic{l, r}
 646               // instructions
 647     case 'W': // Vector constant that does not require memory
 648     case 'j': // Vector constant that is all zeros.
 649       break;
 650     // End FIXME.
 651     }
 652     return true;
 653   }
 654   virtual const char *getClobbers() const {
 655     return "";
 656   }
 657 };
 658
 659 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
 660 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
 661 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
 662                                               ALL_LANGUAGES },
 663 #include "clang/Basic/BuiltinsPPC.def"
 664 };
 665
 666
 667 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 668 /// #defines that are not tied to a specific subtarget.
 669 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
 670                                      MacroBuilder &Builder) const {
 671   // Target identification.
 672   Builder.defineMacro("__ppc__");
 673   Builder.defineMacro("_ARCH_PPC");
 674   Builder.defineMacro("__powerpc__");
 675   Builder.defineMacro("__POWERPC__");
 676   if (PointerWidth == 64) {
 677     Builder.defineMacro("_ARCH_PPC64");
 678     Builder.defineMacro("_LP64");
 679     Builder.defineMacro("__LP64__");
 680     Builder.defineMacro("__powerpc64__");
 681     Builder.defineMacro("__ppc64__");
 682   } else {
 683     Builder.defineMacro("__ppc__");
 684   }
 685
 686   // Target properties.
 687   if (getTriple().getOS() != llvm::Triple::NetBSD)
 688     Builder.defineMacro("_BIG_ENDIAN");
 689   Builder.defineMacro("__BIG_ENDIAN__");
 690
 691   // Subtarget options.
 692   Builder.defineMacro("__NATURAL_ALIGNMENT__");
 693   Builder.defineMacro("__REGISTER_PREFIX__", "");
 694
 695   // FIXME: Should be controlled by command line option.
 696   Builder.defineMacro("__LONG_DOUBLE_128__");
 697
 698   if (Opts.AltiVec) {
 699     Builder.defineMacro("__VEC__", "10206");
 700     Builder.defineMacro("__ALTIVEC__");
 701   }
 702 }
 703
 704
 705 const char * const PPCTargetInfo::GCCRegNames[] = {
 706   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 707   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 708   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 709   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 710   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 711   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 712   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 713   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 714   "mq", "lr", "ctr", "ap",
 715   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
 716   "xer",
 717   "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
 718   "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
 719   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
 720   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
 721   "vrsave", "vscr",
 722   "spe_acc", "spefscr",
 723   "sfp"
 724 };
 725
 726 void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
 727                                    unsigned &NumNames) const {
 728   Names = GCCRegNames;
 729   NumNames = llvm::array_lengthof(GCCRegNames);
 730 }
 731
 732 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
 733   // While some of these aliases do map to different registers
 734   // they still share the same register name.
 735   { { "0" }, "r0" },
 736   { { "1"}, "r1" },
 737   { { "2" }, "r2" },
 738   { { "3" }, "r3" },
 739   { { "4" }, "r4" },
 740   { { "5" }, "r5" },
 741   { { "6" }, "r6" },
 742   { { "7" }, "r7" },
 743   { { "8" }, "r8" },
 744   { { "9" }, "r9" },
 745   { { "10" }, "r10" },
 746   { { "11" }, "r11" },
 747   { { "12" }, "r12" },
 748   { { "13" }, "r13" },
 749   { { "14" }, "r14" },
 750   { { "15" }, "r15" },
 751   { { "16" }, "r16" },
 752   { { "17" }, "r17" },
 753   { { "18" }, "r18" },
 754   { { "19" }, "r19" },
 755   { { "20" }, "r20" },
 756   { { "21" }, "r21" },
 757   { { "22" }, "r22" },
 758   { { "23" }, "r23" },
 759   { { "24" }, "r24" },
 760   { { "25" }, "r25" },
 761   { { "26" }, "r26" },
 762   { { "27" }, "r27" },
 763   { { "28" }, "r28" },
 764   { { "29" }, "r29" },
 765   { { "30" }, "r30" },
 766   { { "31" }, "r31" },
 767   { { "fr0" }, "f0" },
 768   { { "fr1" }, "f1" },
 769   { { "fr2" }, "f2" },
 770   { { "fr3" }, "f3" },
 771   { { "fr4" }, "f4" },
 772   { { "fr5" }, "f5" },
 773   { { "fr6" }, "f6" },
 774   { { "fr7" }, "f7" },
 775   { { "fr8" }, "f8" },
 776   { { "fr9" }, "f9" },
 777   { { "fr10" }, "f10" },
 778   { { "fr11" }, "f11" },
 779   { { "fr12" }, "f12" },
 780   { { "fr13" }, "f13" },
 781   { { "fr14" }, "f14" },
 782   { { "fr15" }, "f15" },
 783   { { "fr16" }, "f16" },
 784   { { "fr17" }, "f17" },
 785   { { "fr18" }, "f18" },
 786   { { "fr19" }, "f19" },
 787   { { "fr20" }, "f20" },
 788   { { "fr21" }, "f21" },
 789   { { "fr22" }, "f22" },
 790   { { "fr23" }, "f23" },
 791   { { "fr24" }, "f24" },
 792   { { "fr25" }, "f25" },
 793   { { "fr26" }, "f26" },
 794   { { "fr27" }, "f27" },
 795   { { "fr28" }, "f28" },
 796   { { "fr29" }, "f29" },
 797   { { "fr30" }, "f30" },
 798   { { "fr31" }, "f31" },
 799   { { "cc" }, "cr0" },
 800 };
 801
 802 void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
 803                                      unsigned &NumAliases) const {
 804   Aliases = GCCRegAliases;
 805   NumAliases = llvm::array_lengthof(GCCRegAliases);
 806 }
 807 } // end anonymous namespace.
 808
 809 namespace {
 810 class PPC32TargetInfo : public PPCTargetInfo {
 811 public:
 812   PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
 813     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
 814                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
 815
 816     switch (getTriple().getOS()) {
 817     case llvm::Triple::FreeBSD:
 818     case llvm::Triple::NetBSD:
 819       SizeType = UnsignedInt;
 820       break;
 821     default:
 822       break;
 823     }
 824   }
 825
 826   virtual const char *getVAListDeclaration() const {
 827     // This is the ELF definition, and is overridden by the Darwin sub-target
 828     return "typedef struct __va_list_tag {"
 829            "  unsigned char gpr;"
 830            "  unsigned char fpr;"
 831            "  unsigned short reserved;"
 832            "  void* overflow_arg_area;"
 833            "  void* reg_save_area;"
 834            "} __builtin_va_list[1];";
 835   }
 836 };
 837 } // end anonymous namespace.
 838
 839 namespace {
 840 class PPC64TargetInfo : public PPCTargetInfo {
 841 public:
 842   PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
 843     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
 844     IntMaxType = SignedLong;
 845     UIntMaxType = UnsignedLong;
 846     Int64Type = SignedLong;
 847     DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
 848                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
 849   }
 850   virtual const char *getVAListDeclaration() const {
 851     return "typedef char* __builtin_va_list;";
 852   }
 853 };
 854 } // end anonymous namespace.
 855
 856
 857 namespace {
 858 class DarwinPPC32TargetInfo :
 859   public DarwinTargetInfo<PPC32TargetInfo> {
 860 public:
 861   DarwinPPC32TargetInfo(const std::string& triple)
 862     : DarwinTargetInfo<PPC32TargetInfo>(triple) {
 863     HasAlignMac68kSupport = true;
 864     BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
 865   }
 866   virtual const char *getVAListDeclaration() const {
 867     return "typedef char* __builtin_va_list;";
 868   }
 869 };
 870
 871 class DarwinPPC64TargetInfo :
 872   public DarwinTargetInfo<PPC64TargetInfo> {
 873 public:
 874   DarwinPPC64TargetInfo(const std::string& triple)
 875     : DarwinTargetInfo<PPC64TargetInfo>(triple) {
 876     HasAlignMac68kSupport = true;
 877   }
 878 };
 879 } // end anonymous namespace.
 880
 881 namespace {
 882   static const unsigned PTXAddrSpaceMap[] = {
 883     0,    // opencl_global
 884     4,    // opencl_local
 885     1     // opencl_constant
 886   };
 887   class PTXTargetInfo : public TargetInfo {
 888     static const char * const GCCRegNames[];
 889     static const Builtin::Info BuiltinInfo[];
 890     std::vector<llvm::StringRef> AvailableFeatures;
 891   public:
 892     PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
 893       TLSSupported = false;
 894       LongWidth = LongAlign = 64;
 895       AddrSpaceMap = &PTXAddrSpaceMap;
 896       // Define available target features
 897       // These must be defined in sorted order!
 898       AvailableFeatures.push_back("compute10");
 899       AvailableFeatures.push_back("compute11");
 900       AvailableFeatures.push_back("compute12");
 901       AvailableFeatures.push_back("compute13");
 902       AvailableFeatures.push_back("compute20");
 903       AvailableFeatures.push_back("double");
 904       AvailableFeatures.push_back("no-fma");
 905       AvailableFeatures.push_back("ptx20");
 906       AvailableFeatures.push_back("ptx21");
 907       AvailableFeatures.push_back("ptx22");
 908       AvailableFeatures.push_back("ptx23");
 909       AvailableFeatures.push_back("sm10");
 910       AvailableFeatures.push_back("sm11");
 911       AvailableFeatures.push_back("sm12");
 912       AvailableFeatures.push_back("sm13");
 913       AvailableFeatures.push_back("sm20");
 914       AvailableFeatures.push_back("sm21");
 915       AvailableFeatures.push_back("sm22");
 916       AvailableFeatures.push_back("sm23");
 917     }
 918     virtual void getTargetDefines(const LangOptions &Opts,
 919                                   MacroBuilder &Builder) const {
 920       Builder.defineMacro("__PTX__");
 921     }
 922     virtual void getTargetBuiltins(const Builtin::Info *&Records,
 923                                    unsigned &NumRecords) const {
 924       Records = BuiltinInfo;
 925       NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
 926     }
 927
 928     virtual void getGCCRegNames(const char * const *&Names,
 929                                 unsigned &NumNames) const;
 930     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
 931                                   unsigned &NumAliases) const {
 932       // No aliases.
 933       Aliases = 0;
 934       NumAliases = 0;
 935     }
 936     virtual bool validateAsmConstraint(const char *&Name,
 937                                        TargetInfo::ConstraintInfo &info) const {
 938       // FIXME: implement
 939       return true;
 940     }
 941     virtual const char *getClobbers() const {
 942       // FIXME: Is this really right?
 943       return "";
 944     }
 945     virtual const char *getVAListDeclaration() const {
 946       // FIXME: implement
 947       return "typedef char* __builtin_va_list;";
 948     }
 949
 950     virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
 951                                    const std::string &Name,
 952                                    bool Enabled) const;
 953   };
 954
 955   const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
 956 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
 957 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
 958                                               ALL_LANGUAGES },
 959 #include "clang/Basic/BuiltinsPTX.def"
 960   };
 961
 962   const char * const PTXTargetInfo::GCCRegNames[] = {
 963     "r0"
 964   };
 965
 966   void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
 967                                      unsigned &NumNames) const {
 968     Names = GCCRegNames;
 969     NumNames = llvm::array_lengthof(GCCRegNames);
 970   }
 971
 972   bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
 973                                         const std::string &Name,
 974                                         bool Enabled) const {
 975     if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
 976                           Name)) {
 977       Features[Name] = Enabled;
 978       return true;
 979     } else {
 980       return false;
 981     }
 982   }
 983
 984   class PTX32TargetInfo : public PTXTargetInfo {
 985   public:
 986   PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
 987       PointerWidth = PointerAlign = 32;
 988       SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
 989       DescriptionString
 990         = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
 991     }
 992   };
 993
 994   class PTX64TargetInfo : public PTXTargetInfo {
 995   public:
 996   PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
 997       PointerWidth = PointerAlign = 64;
 998       SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
 999       DescriptionString
1000         = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1001     }
1002   };
1003 }
1004
1005 namespace {
1006 // MBlaze abstract base class
1007 class MBlazeTargetInfo : public TargetInfo {
1008   static const char * const GCCRegNames[];
1009   static const TargetInfo::GCCRegAlias GCCRegAliases[];
1010
1011 public:
1012   MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
1013     DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
1014   }
1015
1016   virtual void getTargetBuiltins(const Builtin::Info *&Records,
1017                                  unsigned &NumRecords) const {
1018     // FIXME: Implement.
1019     Records = 0;
1020     NumRecords = 0;
1021   }
1022
1023   virtual void getTargetDefines(const LangOptions &Opts,
1024                                 MacroBuilder &Builder) const;
1025
1026   virtual const char *getVAListDeclaration() const {
1027     return "typedef char* __builtin_va_list;";
1028   }
1029   virtual const char *getTargetPrefix() const {
1030     return "mblaze";
1031   }
1032   virtual void getGCCRegNames(const char * const *&Names,
1033                               unsigned &NumNames) const;
1034   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1035                                 unsigned &NumAliases) const;
1036   virtual bool validateAsmConstraint(const char *&Name,
1037                                      TargetInfo::ConstraintInfo &Info) const {
1038     switch (*Name) {
1039     default: return false;
1040     case 'O': // Zero
1041       return true;
1042     case 'b': // Base register
1043     case 'f': // Floating point register
1044       Info.setAllowsRegister();
1045       return true;
1046     }
1047   }
1048   virtual const char *getClobbers() const {
1049     return "";
1050   }
1051 };
1052
1053 /// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1054 /// #defines that are not tied to a specific subtarget.
1055 void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1056                                      MacroBuilder &Builder) const {
1057   // Target identification.
1058   Builder.defineMacro("__microblaze__");
1059   Builder.defineMacro("_ARCH_MICROBLAZE");
1060   Builder.defineMacro("__MICROBLAZE__");
1061
1062   // Target properties.
1063   Builder.defineMacro("_BIG_ENDIAN");
1064   Builder.defineMacro("__BIG_ENDIAN__");
1065
1066   // Subtarget options.
1067   Builder.defineMacro("__REGISTER_PREFIX__", "");
1068 }
1069
1070
1071 const char * const MBlazeTargetInfo::GCCRegNames[] = {
1072   "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
1073   "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
1074   "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
1075   "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
1076   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
1077   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1078   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1079   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1080   "hi",   "lo",   "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1081   "$fcc5","$fcc6","$fcc7","$ap",  "$rap", "$frp"
1082 };
1083
1084 void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1085                                    unsigned &NumNames) const {
1086   Names = GCCRegNames;
1087   NumNames = llvm::array_lengthof(GCCRegNames);
1088 }
1089
1090 const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1091   { {"f0"},  "r0" },
1092   { {"f1"},  "r1" },
1093   { {"f2"},  "r2" },
1094   { {"f3"},  "r3" },
1095   { {"f4"},  "r4" },
1096   { {"f5"},  "r5" },
1097   { {"f6"},  "r6" },
1098   { {"f7"},  "r7" },
1099   { {"f8"},  "r8" },
1100   { {"f9"},  "r9" },
1101   { {"f10"}, "r10" },
1102   { {"f11"}, "r11" },
1103   { {"f12"}, "r12" },
1104   { {"f13"}, "r13" },
1105   { {"f14"}, "r14" },
1106   { {"f15"}, "r15" },
1107   { {"f16"}, "r16" },
1108   { {"f17"}, "r17" },
1109   { {"f18"}, "r18" },
1110   { {"f19"}, "r19" },
1111   { {"f20"}, "r20" },
1112   { {"f21"}, "r21" },
1113   { {"f22"}, "r22" },
1114   { {"f23"}, "r23" },
1115   { {"f24"}, "r24" },
1116   { {"f25"}, "r25" },
1117   { {"f26"}, "r26" },
1118   { {"f27"}, "r27" },
1119   { {"f28"}, "r28" },
1120   { {"f29"}, "r29" },
1121   { {"f30"}, "r30" },
1122   { {"f31"}, "r31" },
1123 };
1124
1125 void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1126                                      unsigned &NumAliases) const {
1127   Aliases = GCCRegAliases;
1128   NumAliases = llvm::array_lengthof(GCCRegAliases);
1129 }
1130 } // end anonymous namespace.
1131
1132 namespace {
1133 // Namespace for x86 abstract base class
1134 const Builtin::Info BuiltinInfo[] = {
1135 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1136 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1137                                               ALL_LANGUAGES },
1138 #include "clang/Basic/BuiltinsX86.def"
1139 };
1140
1141 static const char* const GCCRegNames[] = {
1142   "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1143   "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
1144   "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
1145   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1146   "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1147   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1148   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
1149 };
1150
1151 const TargetInfo::AddlRegName AddlRegNames[] = {
1152   { { "al", "ah", "eax", "rax" }, 0 },
1153   { { "bl", "bh", "ebx", "rbx" }, 3 },
1154   { { "cl", "ch", "ecx", "rcx" }, 2 },
1155   { { "dl", "dh", "edx", "rdx" }, 1 },
1156   { { "esi", "rsi" }, 4 },
1157   { { "edi", "rdi" }, 5 },
1158   { { "esp", "rsp" }, 7 },
1159   { { "ebp", "rbp" }, 6 },
1160 };
1161
1162 // X86 target abstract base class; x86-32 and x86-64 are very close, so
1163 // most of the implementation can be shared.
1164 class X86TargetInfo : public TargetInfo {
1165   enum X86SSEEnum {
1166     NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
1167   } SSELevel;
1168   enum MMX3DNowEnum {
1169     NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1170   } MMX3DNowLevel;
1171
1172   bool HasAES;
1173   bool HasAVX;
1174
1175   /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1176   ///
1177   /// Each enumeration represents a particular CPU supported by Clang. These
1178   /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1179   enum CPUKind {
1180     CK_Generic,
1181
1182     /// \name i386
1183     /// i386-generation processors.
1184     //@{
1185     CK_i386,
1186     //@}
1187
1188     /// \name i486
1189     /// i486-generation processors.
1190     //@{
1191     CK_i486,
1192     CK_WinChipC6,
1193     CK_WinChip2,
1194     CK_C3,
1195     //@}
1196
1197     /// \name i586
1198     /// i586-generation processors, P5 microarchitecture based.
1199     //@{
1200     CK_i586,
1201     CK_Pentium,
1202     CK_PentiumMMX,
1203     //@}
1204
1205     /// \name i686
1206     /// i686-generation processors, P6 / Pentium M microarchitecture based.
1207     //@{
1208     CK_i686,
1209     CK_PentiumPro,
1210     CK_Pentium2,
1211     CK_Pentium3,
1212     CK_Pentium3M,
1213     CK_PentiumM,
1214     CK_C3_2,
1215
1216     /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1217     /// Clang however has some logic to suport this.
1218     // FIXME: Warn, deprecate, and potentially remove this.
1219     CK_Yonah,
1220     //@}
1221
1222     /// \name Netburst
1223     /// Netburst microarchitecture based processors.
1224     //@{
1225     CK_Pentium4,
1226     CK_Pentium4M,
1227     CK_Prescott,
1228     CK_Nocona,
1229     //@}
1230
1231     /// \name Core
1232     /// Core microarchitecture based processors.
1233     //@{
1234     CK_Core2,
1235
1236     /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1237     /// codename which GCC no longer accepts as an option to -march, but Clang
1238     /// has some logic for recognizing it.
1239     // FIXME: Warn, deprecate, and potentially remove this.
1240     CK_Penryn,
1241     //@}
1242
1243     /// \name Atom
1244     /// Atom processors
1245     //@{
1246     CK_Atom,
1247     //@}
1248
1249     /// \name Nehalem
1250     /// Nehalem microarchitecture based processors.
1251     //@{
1252     CK_Corei7,
1253     CK_Corei7AVX,
1254     CK_CoreAVXi,
1255     //@}
1256
1257     /// \name K6
1258     /// K6 architecture processors.
1259     //@{
1260     CK_K6,
1261     CK_K6_2,
1262     CK_K6_3,
1263     //@}
1264
1265     /// \name K7
1266     /// K7 architecture processors.
1267     //@{
1268     CK_Athlon,
1269     CK_AthlonThunderbird,
1270     CK_Athlon4,
1271     CK_AthlonXP,
1272     CK_AthlonMP,
1273     //@}
1274
1275     /// \name K8
1276     /// K8 architecture processors.
1277     //@{
1278     CK_Athlon64,
1279     CK_Athlon64SSE3,
1280     CK_AthlonFX,
1281     CK_K8,
1282     CK_K8SSE3,
1283     CK_Opteron,
1284     CK_OpteronSSE3,
1285
1286     /// This specification is deprecated and will be removed in the future.
1287     /// Users should prefer \see CK_K8.
1288     // FIXME: Warn on this when the CPU is set to it.
1289     CK_x86_64,
1290     //@}
1291
1292     /// \name Geode
1293     /// Geode processors.
1294     //@{
1295     CK_Geode
1296     //@}
1297   } CPU;
1298
1299 public:
1300   X86TargetInfo(const std::string& triple)
1301     : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
1302       HasAES(false), HasAVX(false), CPU(CK_Generic) {
1303     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
1304   }
1305   virtual void getTargetBuiltins(const Builtin::Info *&Records,
1306                                  unsigned &NumRecords) const {
1307     Records = BuiltinInfo;
1308     NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
1309   }
1310   virtual void getGCCRegNames(const char * const *&Names,
1311                               unsigned &NumNames) const {
1312     Names = GCCRegNames;
1313     NumNames = llvm::array_lengthof(GCCRegNames);
1314   }
1315   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1316                                 unsigned &NumAliases) const {
1317     Aliases = 0;
1318     NumAliases = 0;
1319   }
1320   virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1321                                   unsigned &NumNames) const {
1322     Names = AddlRegNames;
1323     NumNames = llvm::array_lengthof(AddlRegNames);
1324   }
1325   virtual bool validateAsmConstraint(const char *&Name,
1326                                      TargetInfo::ConstraintInfo &info) const;
1327   virtual std::string convertConstraint(const char *&Constraint) const;
1328   virtual const char *getClobbers() const {
1329     return "~{dirflag},~{fpsr},~{flags}";
1330   }
1331   virtual void getTargetDefines(const LangOptions &Opts,
1332                                 MacroBuilder &Builder) const;
1333   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1334                                  const std::string &Name,
1335                                  bool Enabled) const;
1336   virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
1337   virtual void HandleTargetFeatures(std::vector<std::string> &Features);
1338   virtual const char* getABI() const {
1339     return MMX3DNowLevel == NoMMX3DNow ? "no-mmx" : "";
1340   }
1341   virtual bool setCPU(const std::string &Name) {
1342     CPU = llvm::StringSwitch<CPUKind>(Name)
1343       .Case("i386", CK_i386)
1344       .Case("i486", CK_i486)
1345       .Case("winchip-c6", CK_WinChipC6)
1346       .Case("winchip2", CK_WinChip2)
1347       .Case("c3", CK_C3)
1348       .Case("i586", CK_i586)
1349       .Case("pentium", CK_Pentium)
1350       .Case("pentium-mmx", CK_PentiumMMX)
1351       .Case("i686", CK_i686)
1352       .Case("pentiumpro", CK_PentiumPro)
1353       .Case("pentium2", CK_Pentium2)
1354       .Case("pentium3", CK_Pentium3)
1355       .Case("pentium3m", CK_Pentium3M)
1356       .Case("pentium-m", CK_PentiumM)
1357       .Case("c3-2", CK_C3_2)
1358       .Case("yonah", CK_Yonah)
1359       .Case("pentium4", CK_Pentium4)
1360       .Case("pentium4m", CK_Pentium4M)
1361       .Case("prescott", CK_Prescott)
1362       .Case("nocona", CK_Nocona)
1363       .Case("core2", CK_Core2)
1364       .Case("penryn", CK_Penryn)
1365       .Case("atom", CK_Atom)
1366       .Case("corei7", CK_Corei7)
1367       .Case("corei7-avx", CK_Corei7AVX)
1368       .Case("core-avx-i", CK_CoreAVXi)
1369       .Case("k6", CK_K6)
1370       .Case("k6-2", CK_K6_2)
1371       .Case("k6-3", CK_K6_3)
1372       .Case("athlon", CK_Athlon)
1373       .Case("athlon-tbird", CK_AthlonThunderbird)
1374       .Case("athlon-4", CK_Athlon4)
1375       .Case("athlon-xp", CK_AthlonXP)
1376       .Case("athlon-mp", CK_AthlonMP)
1377       .Case("athlon64", CK_Athlon64)
1378       .Case("athlon64-sse3", CK_Athlon64SSE3)
1379       .Case("athlon-fx", CK_AthlonFX)
1380       .Case("k8", CK_K8)
1381       .Case("k8-sse3", CK_K8SSE3)
1382       .Case("opteron", CK_Opteron)
1383       .Case("opteron-sse3", CK_OpteronSSE3)
1384       .Case("x86-64", CK_x86_64)
1385       .Case("geode", CK_Geode)
1386       .Default(CK_Generic);
1387
1388     // Perform any per-CPU checks necessary to determine if this CPU is
1389     // acceptable.
1390     // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1391     // invalid without explaining *why*.
1392     switch (CPU) {
1393     case CK_Generic:
1394       // No processor selected!
1395       return false;
1396
1397     case CK_i386:
1398     case CK_i486:
1399     case CK_WinChipC6:
1400     case CK_WinChip2:
1401     case CK_C3:
1402     case CK_i586:
1403     case CK_Pentium:
1404     case CK_PentiumMMX:
1405     case CK_i686:
1406     case CK_PentiumPro:
1407     case CK_Pentium2:
1408     case CK_Pentium3:
1409     case CK_Pentium3M:
1410     case CK_PentiumM:
1411     case CK_Yonah:
1412     case CK_C3_2:
1413     case CK_Pentium4:
1414     case CK_Pentium4M:
1415     case CK_Prescott:
1416     case CK_K6:
1417     case CK_K6_2:
1418     case CK_K6_3:
1419     case CK_Athlon:
1420     case CK_AthlonThunderbird:
1421     case CK_Athlon4:
1422     case CK_AthlonXP:
1423     case CK_AthlonMP:
1424     case CK_Geode:
1425       // Only accept certain architectures when compiling in 32-bit mode.
1426       if (PointerWidth != 32)
1427         return false;
1428
1429       // Fallthrough
1430     case CK_Nocona:
1431     case CK_Core2:
1432     case CK_Penryn:
1433     case CK_Atom:
1434     case CK_Corei7:
1435     case CK_Corei7AVX:
1436     case CK_CoreAVXi:
1437     case CK_Athlon64:
1438     case CK_Athlon64SSE3:
1439     case CK_AthlonFX:
1440     case CK_K8:
1441     case CK_K8SSE3:
1442     case CK_Opteron:
1443     case CK_OpteronSSE3:
1444     case CK_x86_64:
1445       return true;
1446     }
1447     llvm_unreachable("Unhandled CPU kind");
1448   }
1449 };
1450
1451 void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1452   // FIXME: This should not be here.
1453   Features["3dnow"] = false;
1454   Features["3dnowa"] = false;
1455   Features["mmx"] = false;
1456   Features["sse"] = false;
1457   Features["sse2"] = false;
1458   Features["sse3"] = false;
1459   Features["ssse3"] = false;
1460   Features["sse41"] = false;
1461   Features["sse42"] = false;
1462   Features["aes"] = false;
1463   Features["avx"] = false;
1464
1465   // LLVM does not currently recognize this.
1466   // Features["sse4a"] = false;
1467
1468   // FIXME: This *really* should not be here.
1469
1470   // X86_64 always has SSE2.
1471   if (PointerWidth == 64)
1472     Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1473
1474   switch (CPU) {
1475   case CK_Generic:
1476   case CK_i386:
1477   case CK_i486:
1478   case CK_i586:
1479   case CK_Pentium:
1480   case CK_i686:
1481   case CK_PentiumPro:
1482     break;
1483   case CK_PentiumMMX:
1484   case CK_Pentium2:
1485     setFeatureEnabled(Features, "mmx", true);
1486     break;
1487   case CK_Pentium3:
1488   case CK_Pentium3M:
1489     setFeatureEnabled(Features, "mmx", true);
1490     setFeatureEnabled(Features, "sse", true);
1491     break;
1492   case CK_PentiumM:
1493   case CK_Pentium4:
1494   case CK_Pentium4M:
1495   case CK_x86_64:
1496     setFeatureEnabled(Features, "mmx", true);
1497     setFeatureEnabled(Features, "sse2", true);
1498     break;
1499   case CK_Yonah:
1500   case CK_Prescott:
1501   case CK_Nocona:
1502     setFeatureEnabled(Features, "mmx", true);
1503     setFeatureEnabled(Features, "sse3", true);
1504     break;
1505   case CK_Core2:
1506     setFeatureEnabled(Features, "mmx", true);
1507     setFeatureEnabled(Features, "ssse3", true);
1508     break;
1509   case CK_Penryn:
1510     setFeatureEnabled(Features, "mmx", true);
1511     setFeatureEnabled(Features, "sse4", true);
1512     Features["sse42"] = false;
1513     break;
1514   case CK_Atom:
1515     setFeatureEnabled(Features, "mmx", true);
1516     setFeatureEnabled(Features, "ssse3", true);
1517     break;
1518   case CK_Corei7:
1519     setFeatureEnabled(Features, "mmx", true);
1520     setFeatureEnabled(Features, "sse4", true);
1521     setFeatureEnabled(Features, "aes", true);
1522     break;
1523   case CK_Corei7AVX:
1524   case CK_CoreAVXi:
1525     setFeatureEnabled(Features, "mmx", true);
1526     setFeatureEnabled(Features, "sse4", true);
1527     setFeatureEnabled(Features, "aes", true);
1528     //setFeatureEnabled(Features, "avx", true);
1529     break;
1530   case CK_K6:
1531   case CK_WinChipC6:
1532     setFeatureEnabled(Features, "mmx", true);
1533     break;
1534   case CK_K6_2:
1535   case CK_K6_3:
1536   case CK_WinChip2:
1537   case CK_C3:
1538     setFeatureEnabled(Features, "3dnow", true);
1539     break;
1540   case CK_Athlon:
1541   case CK_AthlonThunderbird:
1542   case CK_Geode:
1543     setFeatureEnabled(Features, "3dnowa", true);
1544     break;
1545   case CK_Athlon4:
1546   case CK_AthlonXP:
1547   case CK_AthlonMP:
1548     setFeatureEnabled(Features, "sse", true);
1549     setFeatureEnabled(Features, "3dnowa", true);
1550     break;
1551   case CK_K8:
1552   case CK_Opteron:
1553   case CK_Athlon64:
1554   case CK_AthlonFX:
1555     setFeatureEnabled(Features, "sse2", true);
1556     setFeatureEnabled(Features, "3dnowa", true);
1557     break;
1558   case CK_K8SSE3:
1559   case CK_OpteronSSE3:
1560   case CK_Athlon64SSE3:
1561     setFeatureEnabled(Features, "sse3", true);
1562     setFeatureEnabled(Features, "3dnowa", true);
1563     break;
1564   case CK_C3_2:
1565     setFeatureEnabled(Features, "mmx", true);
1566     setFeatureEnabled(Features, "sse", true);
1567     break;
1568   }
1569 }
1570
1571 bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1572                                       const std::string &Name,
1573                                       bool Enabled) const {
1574   // FIXME: This *really* should not be here.  We need some way of translating
1575   // options into llvm subtarget features.
1576   if (!Features.count(Name) &&
1577       (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
1578     return false;
1579
1580   if (Enabled) {
1581     if (Name == "mmx")
1582       Features["mmx"] = true;
1583     else if (Name == "sse")
1584       Features["sse"] = true;
1585     else if (Name == "sse2")
1586       Features["sse"] = Features["sse2"] = true;
1587     else if (Name == "sse3")
1588       Features["sse"] = Features["sse2"] = Features["sse3"] = true;
1589     else if (Name == "ssse3")
1590       Features["sse"] = Features["sse2"] = Features["sse3"] =
1591         Features["ssse3"] = true;
1592     else if (Name == "sse4" || Name == "sse4.2")
1593       Features["sse"] = Features["sse2"] = Features["sse3"] =
1594         Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
1595     else if (Name == "sse4.1")
1596       Features["sse"] = Features["sse2"] = Features["sse3"] =
1597         Features["ssse3"] = Features["sse41"] = true;
1598     else if (Name == "3dnow")
1599       Features["mmx"] = Features["3dnow"] = true;
1600     else if (Name == "3dnowa")
1601       Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
1602     else if (Name == "aes")
1603       Features["aes"] = true;
1604     else if (Name == "avx")
1605       Features["avx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1606         Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
1607   } else {
1608     if (Name == "mmx")
1609       Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
1610     else if (Name == "sse")
1611       Features["sse"] = Features["sse2"] = Features["sse3"] =
1612         Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1613     else if (Name == "sse2")
1614       Features["sse2"] = Features["sse3"] = Features["ssse3"] =
1615         Features["sse41"] = Features["sse42"] = false;
1616     else if (Name == "sse3")
1617       Features["sse3"] = Features["ssse3"] = Features["sse41"] =
1618         Features["sse42"] = false;
1619     else if (Name == "ssse3")
1620       Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1621     else if (Name == "sse4" || Name == "sse4.1")
1622       Features["sse41"] = Features["sse42"] = false;
1623     else if (Name == "sse4.2")
1624       Features["sse42"] = false;
1625     else if (Name == "3dnow")
1626       Features["3dnow"] = Features["3dnowa"] = false;
1627     else if (Name == "3dnowa")
1628       Features["3dnowa"] = false;
1629     else if (Name == "aes")
1630       Features["aes"] = false;
1631     else if (Name == "avx")
1632       Features["avx"] = false;
1633   }
1634
1635   return true;
1636 }
1637
1638 /// HandleTargetOptions - Perform initialization based on the user
1639 /// configured set of features.
1640 void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
1641   // Remember the maximum enabled sselevel.
1642   for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1643     // Ignore disabled features.
1644     if (Features[i][0] == '-')
1645       continue;
1646
1647     if (Features[i].substr(1) == "aes") {
1648       HasAES = true;
1649       continue;
1650     }
1651
1652     // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1653     // For now let it be enabled together with other SSE levels.
1654     if (Features[i].substr(1) == "avx") {
1655       HasAVX = true;
1656       continue;
1657     }
1658
1659     assert(Features[i][0] == '+' && "Invalid target feature!");
1660     X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1661       .Case("sse42", SSE42)
1662       .Case("sse41", SSE41)
1663       .Case("ssse3", SSSE3)
1664       .Case("sse3", SSE3)
1665       .Case("sse2", SSE2)
1666       .Case("sse", SSE1)
1667       .Default(NoSSE);
1668     SSELevel = std::max(SSELevel, Level);
1669
1670     MMX3DNowEnum ThreeDNowLevel =
1671       llvm::StringSwitch<MMX3DNowEnum>(Features[i].substr(1))
1672         .Case("3dnowa", AMD3DNowAthlon)
1673         .Case("3dnow", AMD3DNow)
1674         .Case("mmx", MMX)
1675         .Default(NoMMX3DNow);
1676
1677     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
1678   }
1679
1680   // Don't tell the backend if we're turning off mmx; it will end up disabling
1681   // SSE, which we don't want.
1682   std::vector<std::string>::iterator it;
1683   it = std::find(Features.begin(), Features.end(), "-mmx");
1684   if (it != Features.end())
1685     Features.erase(it);
1686 }
1687
1688 /// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1689 /// definitions for this particular subtarget.
1690 void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
1691                                      MacroBuilder &Builder) const {
1692   // Target identification.
1693   if (PointerWidth == 64) {
1694     Builder.defineMacro("_LP64");
1695     Builder.defineMacro("__LP64__");
1696     Builder.defineMacro("__amd64__");
1697     Builder.defineMacro("__amd64");
1698     Builder.defineMacro("__x86_64");
1699     Builder.defineMacro("__x86_64__");
1700   } else {
1701     DefineStd(Builder, "i386", Opts);
1702   }
1703
1704   // Subtarget options.
1705   // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1706   // truly should be based on -mtune options.
1707   switch (CPU) {
1708   case CK_Generic:
1709     break;
1710   case CK_i386:
1711     // The rest are coming from the i386 define above.
1712     Builder.defineMacro("__tune_i386__");
1713     break;
1714   case CK_i486:
1715   case CK_WinChipC6:
1716   case CK_WinChip2:
1717   case CK_C3:
1718     Builder.defineMacro("__i486");
1719     Builder.defineMacro("__i486__");
1720     Builder.defineMacro("__tune_i486__");
1721     break;
1722   case CK_PentiumMMX:
1723     Builder.defineMacro("__pentium_mmx__");
1724     Builder.defineMacro("__tune_pentium_mmx__");
1725     // Fallthrough
1726   case CK_i586:
1727   case CK_Pentium:
1728     Builder.defineMacro("__i586");
1729     Builder.defineMacro("__i586__");
1730     Builder.defineMacro("__tune_i586__");
1731     Builder.defineMacro("__pentium");
1732     Builder.defineMacro("__pentium__");
1733     Builder.defineMacro("__tune_pentium__");
1734     break;
1735   case CK_Pentium3:
1736   case CK_Pentium3M:
1737   case CK_PentiumM:
1738     Builder.defineMacro("__tune_pentium3__");
1739     // Fallthrough
1740   case CK_Pentium2:
1741   case CK_C3_2:
1742     Builder.defineMacro("__tune_pentium2__");
1743     // Fallthrough
1744   case CK_PentiumPro:
1745     Builder.defineMacro("__tune_i686__");
1746     Builder.defineMacro("__tune_pentiumpro__");
1747     // Fallthrough
1748   case CK_i686:
1749     Builder.defineMacro("__i686");
1750     Builder.defineMacro("__i686__");
1751     // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1752     Builder.defineMacro("__pentiumpro");
1753     Builder.defineMacro("__pentiumpro__");
1754     break;
1755   case CK_Pentium4:
1756   case CK_Pentium4M:
1757     Builder.defineMacro("__pentium4");
1758     Builder.defineMacro("__pentium4__");
1759     Builder.defineMacro("__tune_pentium4__");
1760     break;
1761   case CK_Yonah:
1762   case CK_Prescott:
1763   case CK_Nocona:
1764     Builder.defineMacro("__nocona");
1765     Builder.defineMacro("__nocona__");
1766     Builder.defineMacro("__tune_nocona__");
1767     break;
1768   case CK_Core2:
1769   case CK_Penryn:
1770     Builder.defineMacro("__core2");
1771     Builder.defineMacro("__core2__");
1772     Builder.defineMacro("__tune_core2__");
1773     break;
1774   case CK_Atom:
1775     Builder.defineMacro("__atom");
1776     Builder.defineMacro("__atom__");
1777     Builder.defineMacro("__tune_atom__");
1778     break;
1779   case CK_Corei7:
1780   case CK_Corei7AVX:
1781   case CK_CoreAVXi:
1782     Builder.defineMacro("__corei7");
1783     Builder.defineMacro("__corei7__");
1784     Builder.defineMacro("__tune_corei7__");
1785     break;
1786   case CK_K6_2:
1787     Builder.defineMacro("__k6_2__");
1788     Builder.defineMacro("__tune_k6_2__");
1789     // Fallthrough
1790   case CK_K6_3:
1791     if (CPU != CK_K6_2) {  // In case of fallthrough
1792       // FIXME: GCC may be enabling these in cases where some other k6
1793       // architecture is specified but -m3dnow is explicitly provided. The
1794       // exact semantics need to be determined and emulated here.
1795       Builder.defineMacro("__k6_3__");
1796       Builder.defineMacro("__tune_k6_3__");
1797     }
1798     // Fallthrough
1799   case CK_K6:
1800     Builder.defineMacro("__k6");
1801     Builder.defineMacro("__k6__");
1802     Builder.defineMacro("__tune_k6__");
1803     break;
1804   case CK_Athlon:
1805   case CK_AthlonThunderbird:
1806   case CK_Athlon4:
1807   case CK_AthlonXP:
1808   case CK_AthlonMP:
1809     Builder.defineMacro("__athlon");
1810     Builder.defineMacro("__athlon__");
1811     Builder.defineMacro("__tune_athlon__");
1812     if (SSELevel != NoSSE) {
1813       Builder.defineMacro("__athlon_sse__");
1814       Builder.defineMacro("__tune_athlon_sse__");
1815     }
1816     break;
1817   case CK_K8:
1818   case CK_K8SSE3:
1819   case CK_x86_64:
1820   case CK_Opteron:
1821   case CK_OpteronSSE3:
1822   case CK_Athlon64:
1823   case CK_Athlon64SSE3:
1824   case CK_AthlonFX:
1825     Builder.defineMacro("__k8");
1826     Builder.defineMacro("__k8__");
1827     Builder.defineMacro("__tune_k8__");
1828     break;
1829   case CK_Geode:
1830     Builder.defineMacro("__geode");
1831     Builder.defineMacro("__geode__");
1832     Builder.defineMacro("__tune_geode__");
1833     break;
1834   }
1835
1836   // Target properties.
1837   Builder.defineMacro("__LITTLE_ENDIAN__");
1838   Builder.defineMacro("__REGISTER_PREFIX__", "");
1839
1840   // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1841   // functions in glibc header files that use FP Stack inline asm which the
1842   // backend can't deal with (PR879).
1843   Builder.defineMacro("__NO_MATH_INLINES");
1844
1845   if (HasAES)
1846     Builder.defineMacro("__AES__");
1847
1848   if (HasAVX)
1849     Builder.defineMacro("__AVX__");
1850
1851   // Each case falls through to the previous one here.
1852   switch (SSELevel) {
1853   case SSE42:
1854     Builder.defineMacro("__SSE4_2__");
1855   case SSE41:
1856     Builder.defineMacro("__SSE4_1__");
1857   case SSSE3:
1858     Builder.defineMacro("__SSSE3__");
1859   case SSE3:
1860     Builder.defineMacro("__SSE3__");
1861   case SSE2:
1862     Builder.defineMacro("__SSE2__");
1863     Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
1864   case SSE1:
1865     Builder.defineMacro("__SSE__");
1866     Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
1867   case NoSSE:
1868     break;
1869   }
1870
1871   if (Opts.MicrosoftExt && PointerWidth == 32) {
1872     switch (SSELevel) {
1873     case SSE42:
1874     case SSE41:
1875     case SSSE3:
1876     case SSE3:
1877     case SSE2:
1878       Builder.defineMacro("_M_IX86_FP", Twine(2));
1879       break;
1880     case SSE1:
1881       Builder.defineMacro("_M_IX86_FP", Twine(1));
1882       break;
1883     default:
1884       Builder.defineMacro("_M_IX86_FP", Twine(0));
1885     }
1886   }
1887
1888   // Each case falls through to the previous one here.
1889   switch (MMX3DNowLevel) {
1890   case AMD3DNowAthlon:
1891     Builder.defineMacro("__3dNOW_A__");
1892   case AMD3DNow:
1893     Builder.defineMacro("__3dNOW__");
1894   case MMX:
1895     Builder.defineMacro("__MMX__");
1896   case NoMMX3DNow:
1897     break;
1898   }
1899 }
1900
1901
1902 bool
1903 X86TargetInfo::validateAsmConstraint(const char *&Name,
1904                                      TargetInfo::ConstraintInfo &Info) const {
1905   switch (*Name) {
1906   default: return false;
1907   case 'Y': // first letter of a pair:
1908     switch (*(Name+1)) {
1909     default: return false;
1910     case '0':  // First SSE register.
1911     case 't':  // Any SSE register, when SSE2 is enabled.
1912     case 'i':  // Any SSE register, when SSE2 and inter-unit moves enabled.
1913     case 'm':  // any MMX register, when inter-unit moves enabled.
1914       break;   // falls through to setAllowsRegister.
1915   }
1916   case 'a': // eax.
1917   case 'b': // ebx.
1918   case 'c': // ecx.
1919   case 'd': // edx.
1920   case 'S': // esi.
1921   case 'D': // edi.
1922   case 'A': // edx:eax.
1923   case 'f': // any x87 floating point stack register.
1924   case 't': // top of floating point stack.
1925   case 'u': // second from top of floating point stack.
1926   case 'q': // Any register accessible as [r]l: a, b, c, and d.
1927   case 'y': // Any MMX register.
1928   case 'x': // Any SSE register.
1929   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
1930   case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1931   case 'l': // "Index" registers: any general register that can be used as an
1932             // index in a base+index memory access.
1933     Info.setAllowsRegister();
1934     return true;
1935   case 'C': // SSE floating point constant.
1936   case 'G': // x87 floating point constant.
1937   case 'e': // 32-bit signed integer constant for use with zero-extending
1938             // x86_64 instructions.
1939   case 'Z': // 32-bit unsigned integer constant for use with zero-extending
1940             // x86_64 instructions.
1941     return true;
1942   }
1943   return false;
1944 }
1945
1946
1947 std::string
1948 X86TargetInfo::convertConstraint(const char *&Constraint) const {
1949   switch (*Constraint) {
1950   case 'a': return std::string("{ax}");
1951   case 'b': return std::string("{bx}");
1952   case 'c': return std::string("{cx}");
1953   case 'd': return std::string("{dx}");
1954   case 'S': return std::string("{si}");
1955   case 'D': return std::string("{di}");
1956   case 'p': // address
1957     return std::string("im");
1958   case 't': // top of floating point stack.
1959     return std::string("{st}");
1960   case 'u': // second from top of floating point stack.
1961     return std::string("{st(1)}"); // second from top of floating point stack.
1962   default:
1963     return std::string(1, *Constraint);
1964   }
1965 }
1966 } // end anonymous namespace
1967
1968 namespace {
1969 // X86-32 generic target
1970 class X86_32TargetInfo : public X86TargetInfo {
1971 public:
1972   X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1973     DoubleAlign = LongLongAlign = 32;
1974     LongDoubleWidth = 96;
1975     LongDoubleAlign = 32;
1976     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1977                         "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
1978                         "a0:0:64-f80:32:32-n8:16:32-S128";
1979     SizeType = UnsignedInt;
1980     PtrDiffType = SignedInt;
1981     IntPtrType = SignedInt;
1982     RegParmMax = 3;
1983
1984     // Use fpret for all types.
1985     RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1986                              (1 << TargetInfo::Double) |
1987                              (1 << TargetInfo::LongDouble));
1988
1989     // x86-32 has atomics up to 8 bytes
1990     // FIXME: Check that we actually have cmpxchg8b before setting
1991     // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
1992     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
1993   }
1994   virtual const char *getVAListDeclaration() const {
1995     return "typedef char* __builtin_va_list;";
1996   }
1997
1998   int getEHDataRegisterNumber(unsigned RegNo) const {
1999     if (RegNo == 0) return 0;
2000     if (RegNo == 1) return 2;
2001     return -1;
2002   }
2003 };
2004 } // end anonymous namespace
2005
2006 namespace {
2007 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2008 public:
2009   OpenBSDI386TargetInfo(const std::string& triple) :
2010     OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2011     SizeType = UnsignedLong;
2012     IntPtrType = SignedLong;
2013     PtrDiffType = SignedLong;
2014   }
2015 };
2016 } // end anonymous namespace
2017
2018 namespace {
2019 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
2020 public:
2021   DarwinI386TargetInfo(const std::string& triple) :
2022     DarwinTargetInfo<X86_32TargetInfo>(triple) {
2023     LongDoubleWidth = 128;
2024     LongDoubleAlign = 128;
2025     SizeType = UnsignedLong;
2026     IntPtrType = SignedLong;
2027     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2028                         "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
2029                         "a0:0:64-f80:128:128-n8:16:32-S128";
2030     HasAlignMac68kSupport = true;
2031   }
2032
2033 };
2034 } // end anonymous namespace
2035
2036 namespace {
2037 // x86-32 Windows target
2038 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
2039 public:
2040   WindowsX86_32TargetInfo(const std::string& triple)
2041     : WindowsTargetInfo<X86_32TargetInfo>(triple) {
2042     TLSSupported = false;
2043     WCharType = UnsignedShort;
2044     DoubleAlign = LongLongAlign = 64;
2045     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2046                         "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
2047                         "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
2048   }
2049   virtual void getTargetDefines(const LangOptions &Opts,
2050                                 MacroBuilder &Builder) const {
2051     WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2052   }
2053 };
2054 } // end anonymous namespace
2055
2056 namespace {
2057
2058 // x86-32 Windows Visual Studio target
2059 class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2060 public:
2061   VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2062     : WindowsX86_32TargetInfo(triple) {
2063     LongDoubleWidth = LongDoubleAlign = 64;
2064     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2065   }
2066   virtual void getTargetDefines(const LangOptions &Opts,
2067                                 MacroBuilder &Builder) const {
2068     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2069     WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2070     // The value of the following reflects processor type.
2071     // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2072     // We lost the original triple, so we use the default.
2073     Builder.defineMacro("_M_IX86", "600");
2074   }
2075 };
2076 } // end anonymous namespace
2077
2078 namespace {
2079 // x86-32 MinGW target
2080 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2081 public:
2082   MinGWX86_32TargetInfo(const std::string& triple)
2083     : WindowsX86_32TargetInfo(triple) {
2084   }
2085   virtual void getTargetDefines(const LangOptions &Opts,
2086                                 MacroBuilder &Builder) const {
2087     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2088     DefineStd(Builder, "WIN32", Opts);
2089     DefineStd(Builder, "WINNT", Opts);
2090     Builder.defineMacro("_X86_");
2091     Builder.defineMacro("__MSVCRT__");
2092     Builder.defineMacro("__MINGW32__");
2093
2094     // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2095     // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
2096     if (Opts.MicrosoftExt)
2097       // Provide "as-is" __declspec.
2098       Builder.defineMacro("__declspec", "__declspec");
2099     else
2100       // Provide alias of __attribute__ like mingw32-gcc.
2101       Builder.defineMacro("__declspec(a)", "__attribute__((a))");
2102   }
2103 };
2104 } // end anonymous namespace
2105
2106 namespace {
2107 // x86-32 Cygwin target
2108 class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2109 public:
2110   CygwinX86_32TargetInfo(const std::string& triple)
2111     : X86_32TargetInfo(triple) {
2112     TLSSupported = false;
2113     WCharType = UnsignedShort;
2114     DoubleAlign = LongLongAlign = 64;
2115     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2116                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
2117                         "a0:0:64-f80:32:32-n8:16:32-S32";
2118   }
2119   virtual void getTargetDefines(const LangOptions &Opts,
2120                                 MacroBuilder &Builder) const {
2121     X86_32TargetInfo::getTargetDefines(Opts, Builder);
2122     Builder.defineMacro("__CYGWIN__");
2123     Builder.defineMacro("__CYGWIN32__");
2124     DefineStd(Builder, "unix", Opts);
2125     if (Opts.CPlusPlus)
2126       Builder.defineMacro("_GNU_SOURCE");
2127   }
2128 };
2129 } // end anonymous namespace
2130
2131 namespace {
2132 // x86-32 Haiku target
2133 class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2134 public:
2135   HaikuX86_32TargetInfo(const std::string& triple)
2136     : X86_32TargetInfo(triple) {
2137     SizeType = UnsignedLong;
2138     IntPtrType = SignedLong;
2139     PtrDiffType = SignedLong;
2140     this->UserLabelPrefix = "";
2141   }
2142   virtual void getTargetDefines(const LangOptions &Opts,
2143                                 MacroBuilder &Builder) const {
2144     X86_32TargetInfo::getTargetDefines(Opts, Builder);
2145     Builder.defineMacro("__INTEL__");
2146     Builder.defineMacro("__HAIKU__");
2147   }
2148 };
2149 } // end anonymous namespace
2150
2151 // RTEMS Target
2152 template<typename Target>
2153 class RTEMSTargetInfo : public OSTargetInfo<Target> {
2154 protected:
2155   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2156                             MacroBuilder &Builder) const {
2157     // RTEMS defines; list based off of gcc output
2158
2159     Builder.defineMacro("__rtems__");
2160     Builder.defineMacro("__ELF__");
2161   }
2162 public:
2163   RTEMSTargetInfo(const std::string &triple)
2164     : OSTargetInfo<Target>(triple) {
2165       this->UserLabelPrefix = "";
2166
2167       llvm::Triple Triple(triple);
2168       switch (Triple.getArch()) {
2169         default:
2170         case llvm::Triple::x86:
2171           // this->MCountName = ".mcount";
2172           break;
2173         case llvm::Triple::mips:
2174         case llvm::Triple::mipsel:
2175         case llvm::Triple::ppc:
2176         case llvm::Triple::ppc64:
2177           // this->MCountName = "_mcount";
2178           break;
2179         case llvm::Triple::arm:
2180           // this->MCountName = "__mcount";
2181           break;
2182       }
2183
2184     }
2185 };
2186
2187 namespace {
2188 // x86-32 RTEMS target
2189 class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2190 public:
2191   RTEMSX86_32TargetInfo(const std::string& triple)
2192     : X86_32TargetInfo(triple) {
2193     SizeType = UnsignedLong;
2194     IntPtrType = SignedLong;
2195     PtrDiffType = SignedLong;
2196     this->UserLabelPrefix = "";
2197   }
2198   virtual void getTargetDefines(const LangOptions &Opts,
2199                                 MacroBuilder &Builder) const {
2200     X86_32TargetInfo::getTargetDefines(Opts, Builder);
2201     Builder.defineMacro("__INTEL__");
2202     Builder.defineMacro("__rtems__");
2203   }
2204 };
2205 } // end anonymous namespace
2206
2207 namespace {
2208 // x86-64 generic target
2209 class X86_64TargetInfo : public X86TargetInfo {
2210 public:
2211   X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
2212     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
2213     LongDoubleWidth = 128;
2214     LongDoubleAlign = 128;
2215     LargeArrayMinWidth = 128;
2216     LargeArrayAlign = 128;
2217     IntMaxType = SignedLong;
2218     UIntMaxType = UnsignedLong;
2219     Int64Type = SignedLong;
2220     RegParmMax = 6;
2221
2222     DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2223                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
2224                         "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
2225
2226     // Use fpret only for long double.
2227     RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
2228
2229     // x86-64 has atomics up to 16 bytes.
2230     // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2231     // on CPUs with cmpxchg16b
2232     MaxAtomicPromoteWidth = 128;
2233     MaxAtomicInlineWidth = 64;
2234   }
2235   virtual const char *getVAListDeclaration() const {
2236     return "typedef struct __va_list_tag {"
2237            "  unsigned gp_offset;"
2238            "  unsigned fp_offset;"
2239            "  void* overflow_arg_area;"
2240            "  void* reg_save_area;"
2241            "} __va_list_tag;"
2242            "typedef __va_list_tag __builtin_va_list[1];";
2243   }
2244
2245   int getEHDataRegisterNumber(unsigned RegNo) const {
2246     if (RegNo == 0) return 0;
2247     if (RegNo == 1) return 1;
2248     return -1;
2249   }
2250 };
2251 } // end anonymous namespace
2252
2253 namespace {
2254 // x86-64 Windows target
2255 class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
2256 public:
2257   WindowsX86_64TargetInfo(const std::string& triple)
2258     : WindowsTargetInfo<X86_64TargetInfo>(triple) {
2259     TLSSupported = false;
2260     WCharType = UnsignedShort;
2261     LongWidth = LongAlign = 32;
2262     DoubleAlign = LongLongAlign = 64;
2263     IntMaxType = SignedLongLong;
2264     UIntMaxType = UnsignedLongLong;
2265     Int64Type = SignedLongLong;
2266     SizeType = UnsignedLongLong;
2267     PtrDiffType = SignedLongLong;
2268     IntPtrType = SignedLongLong;
2269     this->UserLabelPrefix = "";
2270   }
2271   virtual void getTargetDefines(const LangOptions &Opts,
2272                                 MacroBuilder &Builder) const {
2273     WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
2274     Builder.defineMacro("_WIN64");
2275   }
2276   virtual const char *getVAListDeclaration() const {
2277     return "typedef char* __builtin_va_list;";
2278   }
2279 };
2280 } // end anonymous namespace
2281
2282 namespace {
2283 // x86-64 Windows Visual Studio target
2284 class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2285 public:
2286   VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2287     : WindowsX86_64TargetInfo(triple) {
2288     LongDoubleWidth = LongDoubleAlign = 64;
2289     LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2290   }
2291   virtual void getTargetDefines(const LangOptions &Opts,
2292                                 MacroBuilder &Builder) const {
2293     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2294     WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
2295     Builder.defineMacro("_M_X64");
2296     Builder.defineMacro("_M_AMD64");
2297   }
2298 };
2299 } // end anonymous namespace
2300
2301 namespace {
2302 // x86-64 MinGW target
2303 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2304 public:
2305   MinGWX86_64TargetInfo(const std::string& triple)
2306     : WindowsX86_64TargetInfo(triple) {
2307   }
2308   virtual void getTargetDefines(const LangOptions &Opts,
2309                                 MacroBuilder &Builder) const {
2310     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2311     DefineStd(Builder, "WIN64", Opts);
2312     Builder.defineMacro("__MSVCRT__");
2313     Builder.defineMacro("__MINGW32__");
2314     Builder.defineMacro("__MINGW64__");
2315
2316     // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2317     // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
2318     if (Opts.MicrosoftExt)
2319       // Provide "as-is" __declspec.
2320       Builder.defineMacro("__declspec", "__declspec");
2321     else
2322       // Provide alias of __attribute__ like mingw32-gcc.
2323       Builder.defineMacro("__declspec(a)", "__attribute__((a))");
2324   }
2325 };
2326 } // end anonymous namespace
2327
2328 namespace {
2329 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2330 public:
2331   DarwinX86_64TargetInfo(const std::string& triple)
2332       : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2333     Int64Type = SignedLongLong;
2334   }
2335 };
2336 } // end anonymous namespace
2337
2338 namespace {
2339 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2340 public:
2341   OpenBSDX86_64TargetInfo(const std::string& triple)
2342       : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2343     IntMaxType = SignedLongLong;
2344     UIntMaxType = UnsignedLongLong;
2345     Int64Type = SignedLongLong;
2346   }
2347 };
2348 } // end anonymous namespace
2349
2350 namespace {
2351 class ARMTargetInfo : public TargetInfo {
2352   // Possible FPU choices.
2353   enum FPUMode {
2354     NoFPU,
2355     VFP2FPU,
2356     VFP3FPU,
2357     NeonFPU
2358   };
2359
2360   static bool FPUModeIsVFP(FPUMode Mode) {
2361     return Mode >= VFP2FPU && Mode <= NeonFPU;
2362   }
2363
2364   static const TargetInfo::GCCRegAlias GCCRegAliases[];
2365   static const char * const GCCRegNames[];
2366
2367   std::string ABI, CPU;
2368
2369   unsigned FPU : 3;
2370
2371   unsigned IsThumb : 1;
2372
2373   // Initialized via features.
2374   unsigned SoftFloat : 1;
2375   unsigned SoftFloatABI : 1;
2376
2377   static const Builtin::Info BuiltinInfo[];
2378
2379 public:
2380   ARMTargetInfo(const std::string &TripleStr)
2381     : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
2382   {
2383     SizeType = UnsignedInt;
2384     PtrDiffType = SignedInt;
2385
2386     // {} in inline assembly are neon specifiers, not assembly variant
2387     // specifiers.
2388     NoAsmVariants = true;
2389
2390     // FIXME: Should we just treat this as a feature?
2391     IsThumb = getTriple().getArchName().startswith("thumb");
2392     if (IsThumb) {
2393       // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2394       // so set preferred for small types to 32.
2395       DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2396                            "i64:64:64-f32:32:32-f64:64:64-"
2397                            "v64:64:64-v128:64:128-a0:0:32-n32-S64");
2398     } else {
2399       DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2400                            "i64:64:64-f32:32:32-f64:64:64-"
2401                            "v64:64:64-v128:64:128-a0:0:64-n32-S64");
2402     }
2403
2404     // ARM targets default to using the ARM C++ ABI.
2405     CXXABI = CXXABI_ARM;
2406
2407     // ARM has atomics up to 8 bytes
2408     // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2409     MaxAtomicPromoteWidth = 64;
2410   }
2411   virtual const char *getABI() const { return ABI.c_str(); }
2412   virtual bool setABI(const std::string &Name) {
2413     ABI = Name;
2414
2415     // The defaults (above) are for AAPCS, check if we need to change them.
2416     //
2417     // FIXME: We need support for -meabi... we could just mangle it into the
2418     // name.
2419     if (Name == "apcs-gnu") {
2420       DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
2421       SizeType = UnsignedLong;
2422
2423       // Do not respect the alignment of bit-field types when laying out
2424       // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2425       UseBitFieldTypeAlignment = false;
2426
2427       /// Do force alignment of members that follow zero length bitfields.  If
2428       /// the alignment of the zero-length bitfield is greater than the member
2429       /// that follows it, `bar', `bar' will be aligned as the  type of the
2430       /// zero length bitfield.
2431       UseZeroLengthBitfieldAlignment = true;
2432
2433       /// gcc forces the alignment to 4 bytes, regardless of the type of the
2434       /// zero length bitfield.  This corresponds to EMPTY_FIELD_BOUNDARY in
2435       /// gcc.
2436       ZeroLengthBitfieldBoundary = 32;
2437
2438       if (IsThumb) {
2439         // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2440         // so set preferred for small types to 32.
2441         DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2442                              "i64:32:64-f32:32:32-f64:32:64-"
2443                              "v64:32:64-v128:32:128-a0:0:32-n32-S32");
2444       } else {
2445         DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2446                              "i64:32:64-f32:32:32-f64:32:64-"
2447                              "v64:32:64-v128:32:128-a0:0:32-n32-S32");
2448       }
2449
2450       // FIXME: Override "preferred align" for double and long long.
2451     } else if (Name == "aapcs") {
2452       // FIXME: Enumerated types are variable width in straight AAPCS.
2453     } else if (Name == "aapcs-linux") {
2454       ;
2455     } else
2456       return false;
2457
2458     return true;
2459   }
2460
2461   void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
2462     if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2463       Features["vfp2"] = true;
2464     else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2465       Features["neon"] = true;
2466   }
2467
2468   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2469                                  const std::string &Name,
2470                                  bool Enabled) const {
2471     if (Name == "soft-float" || Name == "soft-float-abi" ||
2472         Name == "vfp2" || Name == "vfp3" || Name == "neon") {
2473       Features[Name] = Enabled;
2474     } else
2475       return false;
2476
2477     return true;
2478   }
2479
2480   virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2481     FPU = NoFPU;
2482     SoftFloat = SoftFloatABI = false;
2483     for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2484       if (Features[i] == "+soft-float")
2485         SoftFloat = true;
2486       else if (Features[i] == "+soft-float-abi")
2487         SoftFloatABI = true;
2488       else if (Features[i] == "+vfp2")
2489         FPU = VFP2FPU;
2490       else if (Features[i] == "+vfp3")
2491         FPU = VFP3FPU;
2492       else if (Features[i] == "+neon")
2493         FPU = NeonFPU;
2494     }
2495
2496     // Remove front-end specific options which the backend handles differently.
2497     std::vector<std::string>::iterator it;
2498     it = std::find(Features.begin(), Features.end(), "+soft-float");
2499     if (it != Features.end())
2500       Features.erase(it);
2501     it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2502     if (it != Features.end())
2503       Features.erase(it);
2504   }
2505
2506   static const char *getCPUDefineSuffix(StringRef Name) {
2507     return llvm::StringSwitch<const char*>(Name)
2508       .Cases("arm8", "arm810", "4")
2509       .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2510       .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2511       .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2512       .Case("ep9312", "4T")
2513       .Cases("arm10tdmi", "arm1020t", "5T")
2514       .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2515       .Case("arm926ej-s", "5TEJ")
2516       .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2517       .Cases("xscale", "iwmmxt", "5TE")
2518       .Case("arm1136j-s", "6J")
2519       .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
2520       .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
2521       .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2522       .Cases("cortex-a8", "cortex-a9", "7A")
2523       .Case("cortex-m3", "7M")
2524       .Case("cortex-m0", "6M")
2525       .Default(0);
2526   }
2527   virtual bool setCPU(const std::string &Name) {
2528     if (!getCPUDefineSuffix(Name))
2529       return false;
2530
2531     CPU = Name;
2532     return true;
2533   }
2534   virtual void getTargetDefines(const LangOptions &Opts,
2535                                 MacroBuilder &Builder) const {
2536     // Target identification.
2537     Builder.defineMacro("__arm");
2538     Builder.defineMacro("__arm__");
2539
2540     // Target properties.
2541     Builder.defineMacro("__ARMEL__");
2542     Builder.defineMacro("__LITTLE_ENDIAN__");
2543     Builder.defineMacro("__REGISTER_PREFIX__", "");
2544
2545     StringRef CPUArch = getCPUDefineSuffix(CPU);
2546     Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
2547
2548     // Subtarget options.
2549
2550     // FIXME: It's more complicated than this and we don't really support
2551     // interworking.
2552     if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
2553       Builder.defineMacro("__THUMB_INTERWORK__");
2554
2555     if (ABI == "aapcs" || ABI == "aapcs-linux")
2556       Builder.defineMacro("__ARM_EABI__");
2557
2558     if (SoftFloat)
2559       Builder.defineMacro("__SOFTFP__");
2560
2561     if (CPU == "xscale")
2562       Builder.defineMacro("__XSCALE__");
2563
2564     bool IsARMv7 = CPUArch.startswith("7");
2565     if (IsThumb) {
2566       Builder.defineMacro("__THUMBEL__");
2567       Builder.defineMacro("__thumb__");
2568       if (CPUArch == "6T2" || IsARMv7)
2569         Builder.defineMacro("__thumb2__");
2570     }
2571
2572     // Note, this is always on in gcc, even though it doesn't make sense.
2573     Builder.defineMacro("__APCS_32__");
2574
2575     if (FPUModeIsVFP((FPUMode) FPU))
2576       Builder.defineMacro("__VFP_FP__");
2577
2578     // This only gets set when Neon instructions are actually available, unlike
2579     // the VFP define, hence the soft float and arch check. This is subtly
2580     // different from gcc, we follow the intent which was that it should be set
2581     // when Neon instructions are actually available.
2582     if (FPU == NeonFPU && !SoftFloat && IsARMv7)
2583       Builder.defineMacro("__ARM_NEON__");
2584   }
2585   virtual void getTargetBuiltins(const Builtin::Info *&Records,
2586                                  unsigned &NumRecords) const {
2587     Records = BuiltinInfo;
2588     NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
2589   }
2590   virtual const char *getVAListDeclaration() const {
2591     return "typedef void* __builtin_va_list;";
2592   }
2593   virtual void getGCCRegNames(const char * const *&Names,
2594                               unsigned &NumNames) const;
2595   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2596                                 unsigned &NumAliases) const;
2597   virtual bool validateAsmConstraint(const char *&Name,
2598                                      TargetInfo::ConstraintInfo &Info) const {
2599     // FIXME: Check if this is complete
2600     switch (*Name) {
2601     default:
2602     case 'l': // r0-r7
2603     case 'h': // r8-r15
2604     case 'w': // VFP Floating point register single precision
2605     case 'P': // VFP Floating point register double precision
2606       Info.setAllowsRegister();
2607       return true;
2608     case 'Q': // A memory address that is a single base register.
2609       Info.setAllowsMemory();
2610       return true;
2611     case 'U': // a memory reference...
2612       switch (Name[1]) {
2613       case 'q': // ...ARMV4 ldrsb
2614       case 'v': // ...VFP load/store (reg+constant offset)
2615       case 'y': // ...iWMMXt load/store
2616       case 't': // address valid for load/store opaque types wider
2617                 // than 128-bits
2618       case 'n': // valid address for Neon doubleword vector load/store
2619       case 'm': // valid address for Neon element and structure load/store
2620       case 's': // valid address for non-offset loads/stores of quad-word
2621                 // values in four ARM registers
2622         Info.setAllowsMemory();
2623         Name++;
2624         return true;
2625       }
2626     }
2627     return false;
2628   }
2629   virtual std::string convertConstraint(const char *&Constraint) const {
2630     std::string R;
2631     switch (*Constraint) {
2632     case 'U':   // Two-character constraint; add "^" hint for later parsing.
2633       R = std::string("^") + std::string(Constraint, 2);
2634       Constraint++;
2635       break;
2636     case 'p': // 'p' should be translated to 'r' by default.
2637       R = std::string("r");
2638       break;
2639     default:
2640       return std::string(1, *Constraint);
2641     }
2642     return R;
2643   }
2644   virtual const char *getClobbers() const {
2645     // FIXME: Is this really right?
2646     return "";
2647   }
2648 };
2649
2650 const char * const ARMTargetInfo::GCCRegNames[] = {
2651   // Integer registers
2652   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2653   "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2654
2655   // Float registers
2656   "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2657   "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2658   "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
2659   "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
2660
2661   // Double registers
2662   "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2663   "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
2664   "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2665   "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
2666
2667   // Quad registers
2668   "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2669   "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
2670 };
2671
2672 void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
2673                                    unsigned &NumNames) const {
2674   Names = GCCRegNames;
2675   NumNames = llvm::array_lengthof(GCCRegNames);
2676 }
2677
2678 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
2679   { { "a1" }, "r0" },
2680   { { "a2" }, "r1" },
2681   { { "a3" }, "r2" },
2682   { { "a4" }, "r3" },
2683   { { "v1" }, "r4" },
2684   { { "v2" }, "r5" },
2685   { { "v3" }, "r6" },
2686   { { "v4" }, "r7" },
2687   { { "v5" }, "r8" },
2688   { { "v6", "rfp" }, "r9" },
2689   { { "sl" }, "r10" },
2690   { { "fp" }, "r11" },
2691   { { "ip" }, "r12" },
2692   { { "r13" }, "sp" },
2693   { { "r14" }, "lr" },
2694   { { "r15" }, "pc" },
2695   // The S, D and Q registers overlap, but aren't really aliases; we
2696   // don't want to substitute one of these for a different-sized one.
2697 };
2698
2699 void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2700                                        unsigned &NumAliases) const {
2701   Aliases = GCCRegAliases;
2702   NumAliases = llvm::array_lengthof(GCCRegAliases);
2703 }
2704
2705 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
2706 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
2707 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
2708                                               ALL_LANGUAGES },
2709 #include "clang/Basic/BuiltinsARM.def"
2710 };
2711 } // end anonymous namespace.
2712
2713
2714 namespace {
2715 class DarwinARMTargetInfo :
2716   public DarwinTargetInfo<ARMTargetInfo> {
2717 protected:
2718   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2719                             MacroBuilder &Builder) const {
2720     getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
2721   }
2722
2723 public:
2724   DarwinARMTargetInfo(const std::string& triple)
2725     : DarwinTargetInfo<ARMTargetInfo>(triple) {
2726     HasAlignMac68kSupport = true;
2727     // iOS always has 64-bit atomic instructions.
2728     // FIXME: This should be based off of the target features in ARMTargetInfo.
2729     MaxAtomicInlineWidth = 64;
2730   }
2731 };
2732 } // end anonymous namespace.
2733
2734 namespace {
2735 class SparcV8TargetInfo : public TargetInfo {
2736   static const TargetInfo::GCCRegAlias GCCRegAliases[];
2737   static const char * const GCCRegNames[];
2738   bool SoftFloat;
2739 public:
2740   SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
2741     // FIXME: Support Sparc quad-precision long double?
2742     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2743                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
2744   }
2745   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
2746                                  const std::string &Name,
2747                                  bool Enabled) const {
2748     if (Name == "soft-float")
2749       Features[Name] = Enabled;
2750     else
2751       return false;
2752
2753     return true;
2754   }
2755   virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
2756     SoftFloat = false;
2757     for (unsigned i = 0, e = Features.size(); i != e; ++i)
2758       if (Features[i] == "+soft-float")
2759         SoftFloat = true;
2760   }
2761   virtual void getTargetDefines(const LangOptions &Opts,
2762                                 MacroBuilder &Builder) const {
2763     DefineStd(Builder, "sparc", Opts);
2764     Builder.defineMacro("__sparcv8");
2765     Builder.defineMacro("__REGISTER_PREFIX__", "");
2766
2767     if (SoftFloat)
2768       Builder.defineMacro("SOFT_FLOAT", "1");
2769   }
2770   virtual void getTargetBuiltins(const Builtin::Info *&Records,
2771                                  unsigned &NumRecords) const {
2772     // FIXME: Implement!
2773   }
2774   virtual const char *getVAListDeclaration() const {
2775     return "typedef void* __builtin_va_list;";
2776   }
2777   virtual void getGCCRegNames(const char * const *&Names,
2778                               unsigned &NumNames) const;
2779   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2780                                 unsigned &NumAliases) const;
2781   virtual bool validateAsmConstraint(const char *&Name,
2782                                      TargetInfo::ConstraintInfo &info) const {
2783     // FIXME: Implement!
2784     return false;
2785   }
2786   virtual const char *getClobbers() const {
2787     // FIXME: Implement!
2788     return "";
2789   }
2790 };
2791
2792 const char * const SparcV8TargetInfo::GCCRegNames[] = {
2793   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2794   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2795   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2796   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2797 };
2798
2799 void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
2800                                        unsigned &NumNames) const {
2801   Names = GCCRegNames;
2802   NumNames = llvm::array_lengthof(GCCRegNames);
2803 }
2804
2805 const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
2806   { { "g0" }, "r0" },
2807   { { "g1" }, "r1" },
2808   { { "g2" }, "r2" },
2809   { { "g3" }, "r3" },
2810   { { "g4" }, "r4" },
2811   { { "g5" }, "r5" },
2812   { { "g6" }, "r6" },
2813   { { "g7" }, "r7" },
2814   { { "o0" }, "r8" },
2815   { { "o1" }, "r9" },
2816   { { "o2" }, "r10" },
2817   { { "o3" }, "r11" },
2818   { { "o4" }, "r12" },
2819   { { "o5" }, "r13" },
2820   { { "o6", "sp" }, "r14" },
2821   { { "o7" }, "r15" },
2822   { { "l0" }, "r16" },
2823   { { "l1" }, "r17" },
2824   { { "l2" }, "r18" },
2825   { { "l3" }, "r19" },
2826   { { "l4" }, "r20" },
2827   { { "l5" }, "r21" },
2828   { { "l6" }, "r22" },
2829   { { "l7" }, "r23" },
2830   { { "i0" }, "r24" },
2831   { { "i1" }, "r25" },
2832   { { "i2" }, "r26" },
2833   { { "i3" }, "r27" },
2834   { { "i4" }, "r28" },
2835   { { "i5" }, "r29" },
2836   { { "i6", "fp" }, "r30" },
2837   { { "i7" }, "r31" },
2838 };
2839
2840 void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2841                                          unsigned &NumAliases) const {
2842   Aliases = GCCRegAliases;
2843   NumAliases = llvm::array_lengthof(GCCRegAliases);
2844 }
2845 } // end anonymous namespace.
2846
2847 namespace {
2848 class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2849 public:
2850   AuroraUXSparcV8TargetInfo(const std::string& triple) :
2851       AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2852     SizeType = UnsignedInt;
2853     PtrDiffType = SignedInt;
2854   }
2855 };
2856 class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
2857 public:
2858   SolarisSparcV8TargetInfo(const std::string& triple) :
2859       SolarisTargetInfo<SparcV8TargetInfo>(triple) {
2860     SizeType = UnsignedInt;
2861     PtrDiffType = SignedInt;
2862   }
2863 };
2864 } // end anonymous namespace.
2865
2866 namespace {
2867   class MSP430TargetInfo : public TargetInfo {
2868     static const char * const GCCRegNames[];
2869   public:
2870     MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2871       TLSSupported = false;
2872       IntWidth = 16; IntAlign = 16;
2873       LongWidth = 32; LongLongWidth = 64;
2874       LongAlign = LongLongAlign = 16;
2875       PointerWidth = 16; PointerAlign = 16;
2876       SizeType = UnsignedInt;
2877       IntMaxType = SignedLong;
2878       UIntMaxType = UnsignedLong;
2879       IntPtrType = SignedShort;
2880       PtrDiffType = SignedInt;
2881       SigAtomicType = SignedLong;
2882       DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
2883    }
2884     virtual void getTargetDefines(const LangOptions &Opts,
2885                                   MacroBuilder &Builder) const {
2886       Builder.defineMacro("MSP430");
2887       Builder.defineMacro("__MSP430__");
2888       // FIXME: defines for different 'flavours' of MCU
2889     }
2890     virtual void getTargetBuiltins(const Builtin::Info *&Records,
2891                                    unsigned &NumRecords) const {
2892      // FIXME: Implement.
2893       Records = 0;
2894       NumRecords = 0;
2895     }
2896     virtual void getGCCRegNames(const char * const *&Names,
2897                                 unsigned &NumNames) const;
2898     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2899                                   unsigned &NumAliases) const {
2900       // No aliases.
2901       Aliases = 0;
2902       NumAliases = 0;
2903     }
2904     virtual bool validateAsmConstraint(const char *&Name,
2905                                        TargetInfo::ConstraintInfo &info) const {
2906       // No target constraints for now.
2907       return false;
2908     }
2909     virtual const char *getClobbers() const {
2910       // FIXME: Is this really right?
2911       return "";
2912     }
2913     virtual const char *getVAListDeclaration() const {
2914       // FIXME: implement
2915       return "typedef char* __builtin_va_list;";
2916    }
2917   };
2918
2919   const char * const MSP430TargetInfo::GCCRegNames[] = {
2920     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2921     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2922   };
2923
2924   void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2925                                         unsigned &NumNames) const {
2926     Names = GCCRegNames;
2927     NumNames = llvm::array_lengthof(GCCRegNames);
2928   }
2929 }
2930
2931
2932 namespace {
2933   class SystemZTargetInfo : public TargetInfo {
2934     static const char * const GCCRegNames[];
2935   public:
2936     SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2937       TLSSupported = false;
2938       IntWidth = IntAlign = 32;
2939       LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2940       PointerWidth = PointerAlign = 64;
2941       DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2942       "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
2943    }
2944     virtual void getTargetDefines(const LangOptions &Opts,
2945                                   MacroBuilder &Builder) const {
2946       Builder.defineMacro("__s390__");
2947       Builder.defineMacro("__s390x__");
2948     }
2949     virtual void getTargetBuiltins(const Builtin::Info *&Records,
2950                                    unsigned &NumRecords) const {
2951       // FIXME: Implement.
2952       Records = 0;
2953       NumRecords = 0;
2954     }
2955
2956     virtual void getGCCRegNames(const char * const *&Names,
2957                                 unsigned &NumNames) const;
2958     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2959                                   unsigned &NumAliases) const {
2960       // No aliases.
2961       Aliases = 0;
2962       NumAliases = 0;
2963     }
2964     virtual bool validateAsmConstraint(const char *&Name,
2965                                        TargetInfo::ConstraintInfo &info) const {
2966       // FIXME: implement
2967       return true;
2968     }
2969     virtual const char *getClobbers() const {
2970       // FIXME: Is this really right?
2971       return "";
2972     }
2973     virtual const char *getVAListDeclaration() const {
2974       // FIXME: implement
2975       return "typedef char* __builtin_va_list;";
2976    }
2977   };
2978
2979   const char * const SystemZTargetInfo::GCCRegNames[] = {
2980     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2981     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2982   };
2983
2984   void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2985                                          unsigned &NumNames) const {
2986     Names = GCCRegNames;
2987     NumNames = llvm::array_lengthof(GCCRegNames);
2988   }
2989 }
2990
2991 namespace {
2992   class BlackfinTargetInfo : public TargetInfo {
2993     static const char * const GCCRegNames[];
2994   public:
2995     BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2996       TLSSupported = false;
2997       DoubleAlign = 32;
2998       LongLongAlign = 32;
2999       LongDoubleAlign = 32;
3000       DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
3001     }
3002
3003     virtual void getTargetDefines(const LangOptions &Opts,
3004                                   MacroBuilder &Builder) const {
3005       DefineStd(Builder, "bfin", Opts);
3006       DefineStd(Builder, "BFIN", Opts);
3007       Builder.defineMacro("__ADSPBLACKFIN__");
3008       // FIXME: This one is really dependent on -mcpu
3009       Builder.defineMacro("__ADSPLPBLACKFIN__");
3010       // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
3011     }
3012
3013     virtual void getTargetBuiltins(const Builtin::Info *&Records,
3014                                    unsigned &NumRecords) const {
3015       // FIXME: Implement.
3016       Records = 0;
3017       NumRecords = 0;
3018     }
3019
3020     virtual void getGCCRegNames(const char * const *&Names,
3021                                 unsigned &NumNames) const;
3022
3023     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3024                                   unsigned &NumAliases) const {
3025       // No aliases.
3026       Aliases = 0;
3027       NumAliases = 0;
3028     }
3029
3030     virtual bool validateAsmConstraint(const char *&Name,
3031                                        TargetInfo::ConstraintInfo &Info) const {
3032       if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
3033         Info.setAllowsRegister();
3034         return true;
3035       }
3036       return false;
3037     }
3038
3039     virtual const char *getClobbers() const {
3040       return "";
3041     }
3042
3043     virtual const char *getVAListDeclaration() const {
3044       return "typedef char* __builtin_va_list;";
3045     }
3046   };
3047
3048   const char * const BlackfinTargetInfo::GCCRegNames[] = {
3049     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3050     "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
3051     "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
3052     "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
3053     "a0", "a1", "cc",
3054     "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
3055     "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
3056   };
3057
3058   void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
3059                                           unsigned &NumNames) const {
3060     Names = GCCRegNames;
3061     NumNames = llvm::array_lengthof(GCCRegNames);
3062   }
3063 }
3064
3065 namespace {
3066
3067   // LLVM and Clang cannot be used directly to output native binaries for
3068   // target, but is used to compile C code to llvm bitcode with correct
3069   // type and alignment information.
3070   //
3071   // TCE uses the llvm bitcode as input and uses it for generating customized
3072   // target processor and program binary. TCE co-design environment is
3073   // publicly available in http://tce.cs.tut.fi
3074
3075   static const unsigned TCEOpenCLAddrSpaceMap[] = {
3076       3, // opencl_global
3077       4, // opencl_local
3078       5  // opencl_constant
3079   };
3080
3081   class TCETargetInfo : public TargetInfo{
3082   public:
3083     TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3084       TLSSupported = false;
3085       IntWidth = 32;
3086       LongWidth = LongLongWidth = 32;
3087       PointerWidth = 32;
3088       IntAlign = 32;
3089       LongAlign = LongLongAlign = 32;
3090       PointerAlign = 32;
3091       SizeType = UnsignedInt;
3092       IntMaxType = SignedLong;
3093       UIntMaxType = UnsignedLong;
3094       IntPtrType = SignedInt;
3095       PtrDiffType = SignedInt;
3096       FloatWidth = 32;
3097       FloatAlign = 32;
3098       DoubleWidth = 32;
3099       DoubleAlign = 32;
3100       LongDoubleWidth = 32;
3101       LongDoubleAlign = 32;
3102       FloatFormat = &llvm::APFloat::IEEEsingle;
3103       DoubleFormat = &llvm::APFloat::IEEEsingle;
3104       LongDoubleFormat = &llvm::APFloat::IEEEsingle;
3105       DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3106                           "i16:16:32-i32:32:32-i64:32:32-"
3107                           "f32:32:32-f64:32:32-v64:32:32-"
3108                           "v128:32:32-a0:0:32-n32";
3109       AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
3110     }
3111
3112     virtual void getTargetDefines(const LangOptions &Opts,
3113                                   MacroBuilder &Builder) const {
3114       DefineStd(Builder, "tce", Opts);
3115       Builder.defineMacro("__TCE__");
3116       Builder.defineMacro("__TCE_V1__");
3117     }
3118     virtual void getTargetBuiltins(const Builtin::Info *&Records,
3119                                    unsigned &NumRecords) const {}
3120     virtual const char *getClobbers() const {
3121       return "";
3122     }
3123     virtual const char *getVAListDeclaration() const {
3124       return "typedef void* __builtin_va_list;";
3125     }
3126     virtual void getGCCRegNames(const char * const *&Names,
3127                                 unsigned &NumNames) const {}
3128     virtual bool validateAsmConstraint(const char *&Name,
3129                                        TargetInfo::ConstraintInfo &info) const {
3130       return true;
3131     }
3132     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3133                                   unsigned &NumAliases) const {}
3134   };
3135 }
3136
3137 namespace {
3138 class MipsTargetInfoBase : public TargetInfo {
3139   std::string CPU;
3140 protected:
3141   std::string ABI;
3142 public:
3143   MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
3144     : TargetInfo(triple), ABI(ABIStr) {
3145     SizeType = UnsignedInt;
3146     PtrDiffType = SignedInt;
3147   }
3148   virtual const char *getABI() const { return ABI.c_str(); }
3149   virtual bool setABI(const std::string &Name) = 0;
3150   virtual bool setCPU(const std::string &Name) {
3151     CPU = Name;
3152     return true;
3153   }
3154   void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
3155     Features[ABI] = true;
3156     Features[CPU] = true;
3157   }
3158   virtual void getArchDefines(const LangOptions &Opts,
3159                               MacroBuilder &Builder) const = 0;
3160   virtual void getTargetDefines(const LangOptions &Opts,
3161                                 MacroBuilder &Builder) const = 0;
3162   virtual void getTargetBuiltins(const Builtin::Info *&Records,
3163                                  unsigned &NumRecords) const {
3164     // FIXME: Implement!
3165   }
3166   virtual const char *getVAListDeclaration() const {
3167     return "typedef void* __builtin_va_list;";
3168   }
3169   virtual void getGCCRegNames(const char * const *&Names,
3170                               unsigned &NumNames) const {
3171     static const char * const GCCRegNames[] = {
3172       "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
3173       "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
3174       "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
3175       "$24",  "$25",  "$26",  "$27",  "$28",  "$sp",  "$fp",  "$31",
3176       "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
3177       "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3178       "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3179       "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3180       "hi",   "lo",   "",     "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3181       "$fcc5","$fcc6","$fcc7"
3182     };
3183     Names = GCCRegNames;
3184     NumNames = llvm::array_lengthof(GCCRegNames);
3185   }
3186   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3187                                 unsigned &NumAliases) const = 0;
3188   virtual bool validateAsmConstraint(const char *&Name,
3189                                      TargetInfo::ConstraintInfo &Info) const {
3190     switch (*Name) {
3191     default:
3192     case 'r': // CPU registers.
3193     case 'd': // Equivalent to "r" unless generating MIPS16 code.
3194     case 'y': // Equivalent to "r", backwards compatibility only.
3195     case 'f': // floating-point registers.
3196       Info.setAllowsRegister();
3197       return true;
3198     }
3199     return false;
3200   }
3201
3202   virtual const char *getClobbers() const {
3203     // FIXME: Implement!
3204     return "";
3205   }
3206 };
3207
3208 class Mips32TargetInfoBase : public MipsTargetInfoBase {
3209 public:
3210   Mips32TargetInfoBase(const std::string& triple) :
3211     MipsTargetInfoBase(triple, "o32") {}
3212   virtual bool setABI(const std::string &Name) {
3213     if ((Name == "o32") || (Name == "eabi")) {
3214       ABI = Name;
3215       return true;
3216     } else
3217       return false;
3218   }
3219   virtual void getArchDefines(const LangOptions &Opts,
3220                               MacroBuilder &Builder) const {
3221     if (ABI == "o32") {
3222       Builder.defineMacro("__mips_o32");
3223       Builder.defineMacro("_ABIO32", "1");
3224       Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3225     }
3226     else if (ABI == "eabi")
3227       Builder.defineMacro("__mips_eabi");
3228     else
3229       llvm_unreachable("Invalid ABI for Mips32.");
3230   }
3231   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3232                                 unsigned &NumAliases) const {
3233     static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3234       { { "at" },  "$1" },
3235       { { "v0" },  "$2" },
3236       { { "v1" },  "$3" },
3237       { { "a0" },  "$4" },
3238       { { "a1" },  "$5" },
3239       { { "a2" },  "$6" },
3240       { { "a3" },  "$7" },
3241       { { "t0" },  "$8" },
3242       { { "t1" },  "$9" },
3243       { { "t2" }, "$10" },
3244       { { "t3" }, "$11" },
3245       { { "t4" }, "$12" },
3246       { { "t5" }, "$13" },
3247       { { "t6" }, "$14" },
3248       { { "t7" }, "$15" },
3249       { { "s0" }, "$16" },
3250       { { "s1" }, "$17" },
3251       { { "s2" }, "$18" },
3252       { { "s3" }, "$19" },
3253       { { "s4" }, "$20" },
3254       { { "s5" }, "$21" },
3255       { { "s6" }, "$22" },
3256       { { "s7" }, "$23" },
3257       { { "t8" }, "$24" },
3258       { { "t9" }, "$25" },
3259       { { "k0" }, "$26" },
3260       { { "k1" }, "$27" },
3261       { { "gp" }, "$28" },
3262       { { "sp" }, "$29" },
3263       { { "fp" }, "$30" },
3264       { { "ra" }, "$31" }
3265     };
3266     Aliases = GCCRegAliases;
3267     NumAliases = llvm::array_lengthof(GCCRegAliases);
3268   }
3269 };
3270
3271 class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3272 public:
3273   Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3274     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3275                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3276   }
3277   virtual void getTargetDefines(const LangOptions &Opts,
3278                                 MacroBuilder &Builder) const {
3279     DefineStd(Builder, "mips", Opts);
3280     Builder.defineMacro("_mips");
3281     DefineStd(Builder, "MIPSEB", Opts);
3282     Builder.defineMacro("_MIPSEB");
3283     Builder.defineMacro("__REGISTER_PREFIX__", "");
3284     getArchDefines(Opts, Builder);
3285   }
3286 };
3287
3288 class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3289 public:
3290   Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3291     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3292                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3293   }
3294   virtual void getTargetDefines(const LangOptions &Opts,
3295                                 MacroBuilder &Builder) const {
3296     DefineStd(Builder, "mips", Opts);
3297     Builder.defineMacro("_mips");
3298     DefineStd(Builder, "MIPSEL", Opts);
3299     Builder.defineMacro("_MIPSEL");
3300     Builder.defineMacro("__REGISTER_PREFIX__", "");
3301     getArchDefines(Opts, Builder);
3302   }
3303 };
3304
3305 class Mips64TargetInfoBase : public MipsTargetInfoBase {
3306   virtual void SetDescriptionString(const std::string &Name) = 0;
3307 public:
3308   Mips64TargetInfoBase(const std::string& triple) :
3309     MipsTargetInfoBase(triple, "n64") {}
3310   virtual bool setABI(const std::string &Name) {
3311     SetDescriptionString(Name);
3312     if ((Name == "n32") || (Name == "n64")) {
3313       ABI = Name;
3314       return true;
3315     } else
3316       return false;
3317   }
3318   virtual void getArchDefines(const LangOptions &Opts,
3319                               MacroBuilder &Builder) const {
3320     if (ABI == "n32") {
3321       Builder.defineMacro("__mips_n32");
3322       Builder.defineMacro("_ABIN32", "2");
3323       Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3324     }
3325     else if (ABI == "n64") {
3326       Builder.defineMacro("__mips_n64");
3327       Builder.defineMacro("_ABI64", "3");
3328       Builder.defineMacro("_MIPS_SIM", "_ABI64");
3329     }
3330     else
3331       llvm_unreachable("Invalid ABI for Mips64.");
3332   }
3333   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3334                                 unsigned &NumAliases) const {
3335     static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3336       { { "at" },  "$1" },
3337       { { "v0" },  "$2" },
3338       { { "v1" },  "$3" },
3339       { { "a0" },  "$4" },
3340       { { "a1" },  "$5" },
3341       { { "a2" },  "$6" },
3342       { { "a3" },  "$7" },
3343       { { "a4" },  "$8" },
3344       { { "a5" },  "$9" },
3345       { { "a6" }, "$10" },
3346       { { "a7" }, "$11" },
3347       { { "t0" }, "$12" },
3348       { { "t1" }, "$13" },
3349       { { "t2" }, "$14" },
3350       { { "t3" }, "$15" },
3351       { { "s0" }, "$16" },
3352       { { "s1" }, "$17" },
3353       { { "s2" }, "$18" },
3354       { { "s3" }, "$19" },
3355       { { "s4" }, "$20" },
3356       { { "s5" }, "$21" },
3357       { { "s6" }, "$22" },
3358       { { "s7" }, "$23" },
3359       { { "t8" }, "$24" },
3360       { { "t9" }, "$25" },
3361       { { "k0" }, "$26" },
3362       { { "k1" }, "$27" },
3363       { { "gp" }, "$28" },
3364       { { "sp" }, "$29" },
3365       { { "fp" }, "$30" },
3366       { { "ra" }, "$31" }
3367     };
3368     Aliases = GCCRegAliases;
3369     NumAliases = llvm::array_lengthof(GCCRegAliases);
3370   }
3371 };
3372
3373 class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3374   virtual void SetDescriptionString(const std::string &Name) {
3375     // Change DescriptionString only if ABI is n32.
3376     if (Name == "n32")
3377       DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3378                           "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3379   }
3380 public:
3381   Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3382     // Default ABI is n64.
3383     DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3384                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3385   }
3386   virtual void getTargetDefines(const LangOptions &Opts,
3387                                 MacroBuilder &Builder) const {
3388     DefineStd(Builder, "mips", Opts);
3389     Builder.defineMacro("_mips");
3390     DefineStd(Builder, "MIPSEB", Opts);
3391     Builder.defineMacro("_MIPSEB");
3392     Builder.defineMacro("__REGISTER_PREFIX__", "");
3393     getArchDefines(Opts, Builder);
3394   }
3395 };
3396
3397 class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3398   virtual void SetDescriptionString(const std::string &Name) {
3399     // Change DescriptionString only if ABI is n32.
3400     if (Name == "n32")
3401       DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3402                           "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3403   }
3404 public:
3405   Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3406     // Default ABI is n64.
3407     DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3408                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3409   }
3410   virtual void getTargetDefines(const LangOptions &Opts,
3411                                 MacroBuilder &Builder) const {
3412     DefineStd(Builder, "mips", Opts);
3413     Builder.defineMacro("_mips");
3414     DefineStd(Builder, "MIPSEL", Opts);
3415     Builder.defineMacro("_MIPSEL");
3416     Builder.defineMacro("__REGISTER_PREFIX__", "");
3417     getArchDefines(Opts, Builder);
3418   }
3419 };
3420 } // end anonymous namespace.
3421
3422 namespace {
3423 class PNaClTargetInfo : public TargetInfo {
3424 public:
3425   PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
3426     this->UserLabelPrefix = "";
3427     this->LongAlign = 32;
3428     this->LongWidth = 32;
3429     this->PointerAlign = 32;
3430     this->PointerWidth = 32;
3431     this->IntMaxType = TargetInfo::SignedLongLong;
3432     this->UIntMaxType = TargetInfo::UnsignedLongLong;
3433     this->Int64Type = TargetInfo::SignedLongLong;
3434     this->DoubleAlign = 64;
3435     this->LongDoubleWidth = 64;
3436     this->LongDoubleAlign = 64;
3437     this->SizeType = TargetInfo::UnsignedInt;
3438     this->PtrDiffType = TargetInfo::SignedInt;
3439     this->IntPtrType = TargetInfo::SignedInt;
3440     this->RegParmMax = 2;
3441     DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3442                         "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3443   }
3444
3445   void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
3446   }
3447   virtual void getArchDefines(const LangOptions &Opts,
3448                               MacroBuilder &Builder) const {
3449     Builder.defineMacro("__le32__");
3450     Builder.defineMacro("__pnacl__");
3451   }
3452   virtual void getTargetDefines(const LangOptions &Opts,
3453                                 MacroBuilder &Builder) const {
3454     DefineStd(Builder, "unix", Opts);
3455     Builder.defineMacro("__ELF__");
3456     if (Opts.POSIXThreads)
3457       Builder.defineMacro("_REENTRANT");
3458     if (Opts.CPlusPlus)
3459       Builder.defineMacro("_GNU_SOURCE");
3460
3461     Builder.defineMacro("__native_client__");
3462     getArchDefines(Opts, Builder);
3463   }
3464   virtual void getTargetBuiltins(const Builtin::Info *&Records,
3465                                  unsigned &NumRecords) const {
3466   }
3467   virtual const char *getVAListDeclaration() const {
3468     return "typedef int __builtin_va_list[4];";
3469   }
3470   virtual void getGCCRegNames(const char * const *&Names,
3471                               unsigned &NumNames) const;
3472   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3473                                 unsigned &NumAliases) const;
3474   virtual bool validateAsmConstraint(const char *&Name,
3475                                      TargetInfo::ConstraintInfo &Info) const {
3476     return false;
3477   }
3478
3479   virtual const char *getClobbers() const {
3480     return "";
3481   }
3482 };
3483
3484 void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3485                                      unsigned &NumNames) const {
3486   Names = NULL;
3487   NumNames = 0;
3488 }
3489
3490 void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3491                                        unsigned &NumAliases) const {
3492   Aliases = NULL;
3493   NumAliases = 0;
3494 }
3495 } // end anonymous namespace.
3496
3497
3498 //===----------------------------------------------------------------------===//
3499 // Driver code
3500 //===----------------------------------------------------------------------===//
3501
3502 static TargetInfo *AllocateTarget(const std::string &T) {
3503   llvm::Triple Triple(T);
3504   llvm::Triple::OSType os = Triple.getOS();
3505
3506   switch (Triple.getArch()) {
3507   default:
3508     return NULL;
3509
3510   case llvm::Triple::arm:
3511   case llvm::Triple::thumb:
3512     if (Triple.isOSDarwin())
3513       return new DarwinARMTargetInfo(T);
3514
3515     switch (os) {
3516     case llvm::Triple::Linux:
3517       return new LinuxTargetInfo<ARMTargetInfo>(T);
3518     case llvm::Triple::FreeBSD:
3519       return new FreeBSDTargetInfo<ARMTargetInfo>(T);
3520     case llvm::Triple::NetBSD:
3521       return new NetBSDTargetInfo<ARMTargetInfo>(T);
3522     case llvm::Triple::RTEMS:
3523       return new RTEMSTargetInfo<ARMTargetInfo>(T);
3524     default:
3525       return new ARMTargetInfo(T);
3526     }
3527
3528   case llvm::Triple::bfin:
3529     if ( os == llvm::Triple::RTEMS )
3530       return new RTEMSTargetInfo<BlackfinTargetInfo>(T);
3531     return new BlackfinTargetInfo(T);
3532
3533   case llvm::Triple::msp430:
3534     return new MSP430TargetInfo(T);
3535
3536   case llvm::Triple::mips:
3537     switch (os) {
3538     case llvm::Triple::Linux:
3539       return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
3540     case llvm::Triple::RTEMS:
3541       return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
3542     case llvm::Triple::FreeBSD:
3543       return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
3544     case llvm::Triple::NetBSD:
3545       return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
3546     default:
3547       return new Mips32EBTargetInfo(T);
3548     }
3549
3550   case llvm::Triple::mipsel:
3551     switch (os) {
3552     case llvm::Triple::Linux:
3553       return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
3554     case llvm::Triple::RTEMS:
3555       return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
3556     case llvm::Triple::FreeBSD:
3557       return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
3558     case llvm::Triple::NetBSD:
3559       return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
3560     default:
3561       return new Mips32ELTargetInfo(T);
3562     }
3563
3564   case llvm::Triple::mips64:
3565     switch (os) {
3566     case llvm::Triple::Linux:
3567       return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3568     case llvm::Triple::RTEMS:
3569       return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3570     case llvm::Triple::FreeBSD:
3571       return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3572     case llvm::Triple::NetBSD:
3573       return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3574     default:
3575       return new Mips64EBTargetInfo(T);
3576     }
3577
3578   case llvm::Triple::mips64el:
3579     switch (os) {
3580     case llvm::Triple::Linux:
3581       return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3582     case llvm::Triple::RTEMS:
3583       return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3584     case llvm::Triple::FreeBSD:
3585       return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3586     case llvm::Triple::NetBSD:
3587       return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3588     default:
3589       return new Mips64ELTargetInfo(T);
3590     }
3591
3592   case llvm::Triple::le32:
3593     switch (os) {
3594       case llvm::Triple::NativeClient:
3595         return new PNaClTargetInfo(T);
3596       default:
3597         return NULL;
3598     }
3599
3600   case llvm::Triple::ppc:
3601     if (Triple.isOSDarwin())
3602       return new DarwinPPC32TargetInfo(T);
3603     switch (os) {
3604     case llvm::Triple::Linux:
3605       return new LinuxTargetInfo<PPC32TargetInfo>(T);
3606     case llvm::Triple::FreeBSD:
3607       return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
3608     case llvm::Triple::NetBSD:
3609       return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3610     case llvm::Triple::RTEMS:
3611       return new RTEMSTargetInfo<PPC32TargetInfo>(T);
3612     default:
3613       return new PPC32TargetInfo(T);
3614     }
3615
3616   case llvm::Triple::ppc64:
3617     if (Triple.isOSDarwin())
3618       return new DarwinPPC64TargetInfo(T);
3619     switch (os) {
3620     case llvm::Triple::Linux:
3621       return new LinuxTargetInfo<PPC64TargetInfo>(T);
3622     case llvm::Triple::Lv2:
3623       return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
3624     case llvm::Triple::FreeBSD:
3625       return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
3626     case llvm::Triple::NetBSD:
3627       return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3628     default:
3629       return new PPC64TargetInfo(T);
3630     }
3631
3632   case llvm::Triple::ptx32:
3633     return new PTX32TargetInfo(T);
3634   case llvm::Triple::ptx64:
3635     return new PTX64TargetInfo(T);
3636
3637   case llvm::Triple::mblaze:
3638     return new MBlazeTargetInfo(T);
3639
3640   case llvm::Triple::sparc:
3641     switch (os) {
3642     case llvm::Triple::Linux:
3643       return new LinuxTargetInfo<SparcV8TargetInfo>(T);
3644     case llvm::Triple::AuroraUX:
3645       return new AuroraUXSparcV8TargetInfo(T);
3646     case llvm::Triple::Solaris:
3647       return new SolarisSparcV8TargetInfo(T);
3648     case llvm::Triple::NetBSD:
3649       return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3650     case llvm::Triple::RTEMS:
3651       return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
3652     default:
3653       return new SparcV8TargetInfo(T);
3654     }
3655
3656   // FIXME: Need a real SPU target.
3657   case llvm::Triple::cellspu:
3658     return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3659
3660   case llvm::Triple::systemz:
3661     return new SystemZTargetInfo(T);
3662
3663   case llvm::Triple::tce:
3664     return new TCETargetInfo(T);
3665
3666   case llvm::Triple::x86:
3667     if (Triple.isOSDarwin())
3668       return new DarwinI386TargetInfo(T);
3669
3670     switch (os) {
3671     case llvm::Triple::AuroraUX:
3672       return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
3673     case llvm::Triple::Linux:
3674       return new LinuxTargetInfo<X86_32TargetInfo>(T);
3675     case llvm::Triple::DragonFly:
3676       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
3677     case llvm::Triple::NetBSD:
3678       return new NetBSDTargetInfo<X86_32TargetInfo>(T);
3679     case llvm::Triple::OpenBSD:
3680       return new OpenBSDI386TargetInfo(T);
3681     case llvm::Triple::FreeBSD:
3682       return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
3683     case llvm::Triple::Minix:
3684       return new MinixTargetInfo<X86_32TargetInfo>(T);
3685     case llvm::Triple::Solaris:
3686       return new SolarisTargetInfo<X86_32TargetInfo>(T);
3687     case llvm::Triple::Cygwin:
3688       return new CygwinX86_32TargetInfo(T);
3689     case llvm::Triple::MinGW32:
3690       return new MinGWX86_32TargetInfo(T);
3691     case llvm::Triple::Win32:
3692       return new VisualStudioWindowsX86_32TargetInfo(T);
3693     case llvm::Triple::Haiku:
3694       return new HaikuX86_32TargetInfo(T);
3695     case llvm::Triple::RTEMS:
3696       return new RTEMSX86_32TargetInfo(T);
3697     default:
3698       return new X86_32TargetInfo(T);
3699     }
3700
3701   case llvm::Triple::x86_64:
3702     if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
3703       return new DarwinX86_64TargetInfo(T);
3704
3705     switch (os) {
3706     case llvm::Triple::AuroraUX:
3707       return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
3708     case llvm::Triple::Linux:
3709       return new LinuxTargetInfo<X86_64TargetInfo>(T);
3710     case llvm::Triple::DragonFly:
3711       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
3712     case llvm::Triple::NetBSD:
3713       return new NetBSDTargetInfo<X86_64TargetInfo>(T);
3714     case llvm::Triple::OpenBSD:
3715       return new OpenBSDX86_64TargetInfo(T);
3716     case llvm::Triple::FreeBSD:
3717       return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
3718     case llvm::Triple::Solaris:
3719       return new SolarisTargetInfo<X86_64TargetInfo>(T);
3720     case llvm::Triple::MinGW32:
3721       return new MinGWX86_64TargetInfo(T);
3722     case llvm::Triple::Win32:   // This is what Triple.h supports now.
3723       return new VisualStudioWindowsX86_64TargetInfo(T);
3724     default:
3725       return new X86_64TargetInfo(T);
3726     }
3727   }
3728 }
3729
3730 /// CreateTargetInfo - Return the target info object for the specified target
3731 /// triple.
3732 TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
3733                                          TargetOptions &Opts) {
3734   llvm::Triple Triple(Opts.Triple);
3735
3736   // Construct the target
3737   llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
3738   if (!Target) {
3739     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
3740     return 0;
3741   }
3742
3743   // Set the target CPU if specified.
3744   if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
3745     Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
3746     return 0;
3747   }
3748
3749   // Set the target ABI if specified.
3750   if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
3751     Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
3752     return 0;
3753   }
3754
3755   // Set the target C++ ABI.
3756   if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
3757     Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
3758     return 0;
3759   }
3760
3761   // Compute the default target features, we need the target to handle this
3762   // because features may have dependencies on one another.
3763   llvm::StringMap<bool> Features;
3764   Target->getDefaultFeatures(Features);
3765
3766   // Apply the user specified deltas.
3767   for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
3768          ie = Opts.Features.end(); it != ie; ++it) {
3769     const char *Name = it->c_str();
3770
3771     // Apply the feature via the target.
3772     if ((Name[0] != '-' && Name[0] != '+') ||
3773         !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
3774       Diags.Report(diag::err_target_invalid_feature) << Name;
3775       return 0;
3776     }
3777   }
3778
3779   // Add the features to the compile options.
3780   //
3781   // FIXME: If we are completely confident that we have the right set, we only
3782   // need to pass the minuses.
3783   Opts.Features.clear();
3784   for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
3785          ie = Features.end(); it != ie; ++it)
3786     Opts.Features.push_back(std::string(it->second ? "+" : "-") +
3787                             it->first().str());
3788   Target->HandleTargetFeatures(Opts.Features);
3789
3790   return Target.take();
3791 }