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 <algorithm>
  30 using namespace clang;
  31
  32 //===----------------------------------------------------------------------===//
  33 //  Common code shared among targets.
  34 //===----------------------------------------------------------------------===//
  35
  36 /// DefineStd - Define a macro name and standard variants.  For example if
  37 /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
  38 /// when in GNU mode.
  39 static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
  40                       const LangOptions &Opts) {
  41   assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
  42
  43   // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
  44   // in the user's namespace.
  45   if (Opts.GNUMode)
  46     Builder.defineMacro(MacroName);
  47
  48   // Define __unix.
  49   Builder.defineMacro("__" + MacroName);
  50
  51   // Define __unix__.
  52   Builder.defineMacro("__" + MacroName + "__");
  53 }
  54
  55 //===----------------------------------------------------------------------===//
  56 // Defines specific to certain operating systems.
  57 //===----------------------------------------------------------------------===//
  58
  59 namespace {
  60 template<typename TgtInfo>
  61 class OSTargetInfo : public TgtInfo {
  62 protected:
  63   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
  64                             MacroBuilder &Builder) const=0;
  65 public:
  66   OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
  67   virtual void getTargetDefines(const LangOptions &Opts,
  68                                 MacroBuilder &Builder) const {
  69     TgtInfo::getTargetDefines(Opts, Builder);
  70     getOSDefines(Opts, TgtInfo::getTriple(), Builder);
  71   }
  72
  73 };
  74 } // end anonymous namespace
  75
  76
  77 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
  78                              const llvm::Triple &Triple) {
  79   Builder.defineMacro("__APPLE_CC__", "5621");
  80   Builder.defineMacro("__APPLE__");
  81   Builder.defineMacro("__MACH__");
  82   Builder.defineMacro("OBJC_NEW_PROPERTIES");
  83
  84   // __weak is always defined, for use in blocks and with objc pointers.
  85   Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
  86
  87   // Darwin defines __strong even in C mode (just to nothing).
  88   if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
  89     Builder.defineMacro("__strong", "");
  90   else
  91     Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
  92
  93   if (Opts.Static)
  94     Builder.defineMacro("__STATIC__");
  95   else
  96     Builder.defineMacro("__DYNAMIC__");
  97
  98   if (Opts.POSIXThreads)
  99     Builder.defineMacro("_REENTRANT");
 100
 101   // Get the OS version number from the triple.
 102   unsigned Maj, Min, Rev;
 103
 104   // If no version was given, default to to 10.4.0, for simplifying tests.
 105   if (Triple.getOSName() == "darwin") {
 106     Min = Rev = 0;
 107     Maj = 8;
 108   } else
 109     Triple.getDarwinNumber(Maj, Min, Rev);
 110
 111   // Set the appropriate OS version define.
 112   if (Triple.getEnvironmentName() == "iphoneos") {
 113     assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
 114     char Str[6];
 115     Str[0] = '0' + Maj;
 116     Str[1] = '0' + (Min / 10);
 117     Str[2] = '0' + (Min % 10);
 118     Str[3] = '0' + (Rev / 10);
 119     Str[4] = '0' + (Rev % 10);
 120     Str[5] = '\0';
 121     Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
 122   } else {
 123     // For historical reasons that make little sense, the version passed here is
 124     // the "darwin" version, which drops the 10 and offsets by 4.
 125     Rev = Min;
 126     Min = Maj - 4;
 127     Maj = 10;
 128
 129     assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
 130     assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
 131     char Str[5];
 132     Str[0] = '0' + (Maj / 10);
 133     Str[1] = '0' + (Maj % 10);
 134     Str[2] = '0' + Min;
 135     Str[3] = '0' + Rev;
 136     Str[4] = '\0';
 137     Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
 138   }
 139 }
 140
 141 namespace {
 142 template<typename Target>
 143 class DarwinTargetInfo : public OSTargetInfo<Target> {
 144 protected:
 145   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 146                             MacroBuilder &Builder) const {
 147     getDarwinDefines(Builder, Opts, Triple);
 148   }
 149
 150 public:
 151   DarwinTargetInfo(const std::string& triple) :
 152     OSTargetInfo<Target>(triple) {
 153       this->TLSSupported = false;
 154     }
 155
 156   virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
 157     // Let MCSectionMachO validate this.
 158     llvm::StringRef Segment, Section;
 159     unsigned TAA, StubSize;
 160     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
 161                                                        TAA, StubSize);
 162   }
 163 };
 164
 165
 166 // DragonFlyBSD Target
 167 template<typename Target>
 168 class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
 169 protected:
 170   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 171                             MacroBuilder &Builder) const {
 172     // DragonFly defines; list based off of gcc output
 173     Builder.defineMacro("__DragonFly__");
 174     Builder.defineMacro("__DragonFly_cc_version", "100001");
 175     Builder.defineMacro("__ELF__");
 176     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 177     Builder.defineMacro("__tune_i386__");
 178     DefineStd(Builder, "unix", Opts);
 179   }
 180 public:
 181   DragonFlyBSDTargetInfo(const std::string &triple)
 182     : OSTargetInfo<Target>(triple) {}
 183 };
 184
 185 // FreeBSD Target
 186 template<typename Target>
 187 class FreeBSDTargetInfo : public OSTargetInfo<Target> {
 188 protected:
 189   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 190                             MacroBuilder &Builder) const {
 191     // FreeBSD defines; list based off of gcc output
 192
 193     // FIXME: Move version number handling to llvm::Triple.
 194     llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
 195
 196     Builder.defineMacro("__FreeBSD__", Release);
 197     Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
 198     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
 199     DefineStd(Builder, "unix", Opts);
 200     Builder.defineMacro("__ELF__");
 201   }
 202 public:
 203   FreeBSDTargetInfo(const std::string &triple)
 204     : OSTargetInfo<Target>(triple) {
 205       this->UserLabelPrefix = "";
 206     }
 207 };
 208
 209 // Linux target
 210 template<typename Target>
 211 class LinuxTargetInfo : public OSTargetInfo<Target> {
 212 protected:
 213   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 214                             MacroBuilder &Builder) const {
 215     // Linux defines; list based off of gcc output
 216     DefineStd(Builder, "unix", Opts);
 217     DefineStd(Builder, "linux", Opts);
 218     Builder.defineMacro("__gnu_linux__");
 219     Builder.defineMacro("__ELF__");
 220     if (Opts.POSIXThreads)
 221       Builder.defineMacro("_REENTRANT");
 222     if (Opts.CPlusPlus)
 223       Builder.defineMacro("_GNU_SOURCE");
 224   }
 225 public:
 226   LinuxTargetInfo(const std::string& triple)
 227     : OSTargetInfo<Target>(triple) {
 228     this->UserLabelPrefix = "";
 229   }
 230 };
 231
 232 // NetBSD Target
 233 template<typename Target>
 234 class NetBSDTargetInfo : public OSTargetInfo<Target> {
 235 protected:
 236   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 237                             MacroBuilder &Builder) const {
 238     // NetBSD defines; list based off of gcc output
 239     Builder.defineMacro("__NetBSD__");
 240     Builder.defineMacro("__unix__");
 241     Builder.defineMacro("__ELF__");
 242     if (Opts.POSIXThreads)
 243       Builder.defineMacro("_POSIX_THREADS");
 244   }
 245 public:
 246   NetBSDTargetInfo(const std::string &triple)
 247     : OSTargetInfo<Target>(triple) {
 248       this->UserLabelPrefix = "";
 249     }
 250 };
 251
 252 // OpenBSD Target
 253 template<typename Target>
 254 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 255 protected:
 256   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 257                             MacroBuilder &Builder) const {
 258     // OpenBSD defines; list based off of gcc output
 259
 260     Builder.defineMacro("__OpenBSD__");
 261     DefineStd(Builder, "unix", Opts);
 262     Builder.defineMacro("__ELF__");
 263     if (Opts.POSIXThreads)
 264       Builder.defineMacro("_POSIX_THREADS");
 265   }
 266 public:
 267   OpenBSDTargetInfo(const std::string &triple)
 268     : OSTargetInfo<Target>(triple) {}
 269 };
 270
 271 // PSP Target
 272 template<typename Target>
 273 class PSPTargetInfo : public OSTargetInfo<Target> {
 274 protected:
 275   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 276                             MacroBuilder &Builder) const {
 277     // PSP defines; list based on the output of the pspdev gcc toolchain.
 278     Builder.defineMacro("PSP");
 279     Builder.defineMacro("_PSP");
 280     Builder.defineMacro("__psp__");
 281     Builder.defineMacro("__ELF__");
 282   }
 283 public:
 284   PSPTargetInfo(const std::string& triple)
 285     : OSTargetInfo<Target>(triple) {
 286     this->UserLabelPrefix = "";
 287   }
 288 };
 289
 290 // PS3 PPU Target
 291 template<typename Target>
 292 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
 293 protected:
 294   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 295                             MacroBuilder &Builder) const {
 296     // PS3 PPU defines.
 297     Builder.defineMacro("__PPC__");
 298     Builder.defineMacro("__PPU__");
 299     Builder.defineMacro("__CELLOS_LV2__");
 300     Builder.defineMacro("__ELF__");
 301     Builder.defineMacro("__LP32__");
 302   }
 303 public:
 304   PS3PPUTargetInfo(const std::string& triple)
 305     : OSTargetInfo<Target>(triple) {
 306     this->UserLabelPrefix = "";
 307     this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
 308     this->SizeType = TargetInfo::UnsignedInt;
 309   }
 310 };
 311
 312 // FIXME: Need a real SPU target.
 313 // PS3 SPU Target
 314 template<typename Target>
 315 class PS3SPUTargetInfo : public OSTargetInfo<Target> {
 316 protected:
 317   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 318                             MacroBuilder &Builder) const {
 319     // PS3 PPU defines.
 320     Builder.defineMacro("__SPU__");
 321     Builder.defineMacro("__ELF__");
 322   }
 323 public:
 324   PS3SPUTargetInfo(const std::string& triple)
 325     : OSTargetInfo<Target>(triple) {
 326     this->UserLabelPrefix = "";
 327   }
 328 };
 329
 330 // AuroraUX target
 331 template<typename Target>
 332 class AuroraUXTargetInfo : public OSTargetInfo<Target> {
 333 protected:
 334   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 335                             MacroBuilder &Builder) const {
 336     DefineStd(Builder, "sun", Opts);
 337     DefineStd(Builder, "unix", Opts);
 338     Builder.defineMacro("__ELF__");
 339     Builder.defineMacro("__svr4__");
 340     Builder.defineMacro("__SVR4");
 341   }
 342 public:
 343   AuroraUXTargetInfo(const std::string& triple)
 344     : OSTargetInfo<Target>(triple) {
 345     this->UserLabelPrefix = "";
 346     this->WCharType = this->SignedLong;
 347     // FIXME: WIntType should be SignedLong
 348   }
 349 };
 350
 351 // Solaris target
 352 template<typename Target>
 353 class SolarisTargetInfo : public OSTargetInfo<Target> {
 354 protected:
 355   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 356                             MacroBuilder &Builder) const {
 357     DefineStd(Builder, "sun", Opts);
 358     DefineStd(Builder, "unix", Opts);
 359     Builder.defineMacro("__ELF__");
 360     Builder.defineMacro("__svr4__");
 361     Builder.defineMacro("__SVR4");
 362   }
 363 public:
 364   SolarisTargetInfo(const std::string& triple)
 365     : OSTargetInfo<Target>(triple) {
 366     this->UserLabelPrefix = "";
 367     this->WCharType = this->SignedLong;
 368     // FIXME: WIntType should be SignedLong
 369   }
 370 };
 371 } // end anonymous namespace.
 372
 373 //===----------------------------------------------------------------------===//
 374 // Specific target implementations.
 375 //===----------------------------------------------------------------------===//
 376
 377 namespace {
 378 // PPC abstract base class
 379 class PPCTargetInfo : public TargetInfo {
 380   static const Builtin::Info BuiltinInfo[];
 381   static const char * const GCCRegNames[];
 382   static const TargetInfo::GCCRegAlias GCCRegAliases[];
 383
 384 public:
 385   PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
 386
 387   virtual void getTargetBuiltins(const Builtin::Info *&Records,
 388                                  unsigned &NumRecords) const {
 389     Records = BuiltinInfo;
 390     NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
 391   }
 392
 393   virtual void getTargetDefines(const LangOptions &Opts,
 394                                 MacroBuilder &Builder) const;
 395
 396   virtual const char *getVAListDeclaration() const {
 397     return "typedef char* __builtin_va_list;";
 398     // This is the right definition for ABI/V4: System V.4/eabi.
 399     /*return "typedef struct __va_list_tag {"
 400            "  unsigned char gpr;"
 401            "  unsigned char fpr;"
 402            "  unsigned short reserved;"
 403            "  void* overflow_arg_area;"
 404            "  void* reg_save_area;"
 405            "} __builtin_va_list[1];";*/
 406   }
 407   virtual void getGCCRegNames(const char * const *&Names,
 408                               unsigned &NumNames) const;
 409   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
 410                                 unsigned &NumAliases) const;
 411   virtual bool validateAsmConstraint(const char *&Name,
 412                                      TargetInfo::ConstraintInfo &Info) const {
 413     switch (*Name) {
 414     default: return false;
 415     case 'O': // Zero
 416       return true;
 417     case 'b': // Base register
 418     case 'f': // Floating point register
 419       Info.setAllowsRegister();
 420       return true;
 421     }
 422   }
 423   virtual const char *getClobbers() const {
 424     return "";
 425   }
 426 };
 427
 428 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
 429 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
 430 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
 431 #include "clang/Basic/BuiltinsPPC.def"
 432 };
 433
 434
 435 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 436 /// #defines that are not tied to a specific subtarget.
 437 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
 438                                      MacroBuilder &Builder) const {
 439   // Target identification.
 440   Builder.defineMacro("__ppc__");
 441   Builder.defineMacro("_ARCH_PPC");
 442   Builder.defineMacro("__powerpc__");
 443   Builder.defineMacro("__POWERPC__");
 444   if (PointerWidth == 64) {
 445     Builder.defineMacro("_ARCH_PPC64");
 446     Builder.defineMacro("_LP64");
 447     Builder.defineMacro("__LP64__");
 448     Builder.defineMacro("__powerpc64__");
 449     Builder.defineMacro("__ppc64__");
 450   } else {
 451     Builder.defineMacro("__ppc__");
 452   }
 453
 454   // Target properties.
 455   Builder.defineMacro("_BIG_ENDIAN");
 456   Builder.defineMacro("__BIG_ENDIAN__");
 457
 458   // Subtarget options.
 459   Builder.defineMacro("__NATURAL_ALIGNMENT__");
 460   Builder.defineMacro("__REGISTER_PREFIX__", "");
 461
 462   // FIXME: Should be controlled by command line option.
 463   Builder.defineMacro("__LONG_DOUBLE_128__");
 464
 465   if (Opts.AltiVec) {
 466     Builder.defineMacro("__VEC__", "10206");
 467     Builder.defineMacro("__ALTIVEC__");
 468   }
 469 }
 470
 471
 472 const char * const PPCTargetInfo::GCCRegNames[] = {
 473   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 474   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 475   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
 476   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
 477   "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
 478   "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
 479   "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
 480   "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
 481   "mq", "lr", "ctr", "ap",
 482   "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
 483   "xer",
 484   "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
 485   "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
 486   "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
 487   "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
 488   "vrsave", "vscr",
 489   "spe_acc", "spefscr",
 490   "sfp"
 491 };
 492
 493 void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
 494                                    unsigned &NumNames) const {
 495   Names = GCCRegNames;
 496   NumNames = llvm::array_lengthof(GCCRegNames);
 497 }
 498
 499 const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
 500   // While some of these aliases do map to different registers
 501   // they still share the same register name.
 502   { { "0" }, "r0" },
 503   { { "1"}, "r1" },
 504   { { "2" }, "r2" },
 505   { { "3" }, "r3" },
 506   { { "4" }, "r4" },
 507   { { "5" }, "r5" },
 508   { { "6" }, "r6" },
 509   { { "7" }, "r7" },
 510   { { "8" }, "r8" },
 511   { { "9" }, "r9" },
 512   { { "10" }, "r10" },
 513   { { "11" }, "r11" },
 514   { { "12" }, "r12" },
 515   { { "13" }, "r13" },
 516   { { "14" }, "r14" },
 517   { { "15" }, "r15" },
 518   { { "16" }, "r16" },
 519   { { "17" }, "r17" },
 520   { { "18" }, "r18" },
 521   { { "19" }, "r19" },
 522   { { "20" }, "r20" },
 523   { { "21" }, "r21" },
 524   { { "22" }, "r22" },
 525   { { "23" }, "r23" },
 526   { { "24" }, "r24" },
 527   { { "25" }, "r25" },
 528   { { "26" }, "r26" },
 529   { { "27" }, "r27" },
 530   { { "28" }, "r28" },
 531   { { "29" }, "r29" },
 532   { { "30" }, "r30" },
 533   { { "31" }, "r31" },
 534   { { "fr0" }, "f0" },
 535   { { "fr1" }, "f1" },
 536   { { "fr2" }, "f2" },
 537   { { "fr3" }, "f3" },
 538   { { "fr4" }, "f4" },
 539   { { "fr5" }, "f5" },
 540   { { "fr6" }, "f6" },
 541   { { "fr7" }, "f7" },
 542   { { "fr8" }, "f8" },
 543   { { "fr9" }, "f9" },
 544   { { "fr10" }, "f10" },
 545   { { "fr11" }, "f11" },
 546   { { "fr12" }, "f12" },
 547   { { "fr13" }, "f13" },
 548   { { "fr14" }, "f14" },
 549   { { "fr15" }, "f15" },
 550   { { "fr16" }, "f16" },
 551   { { "fr17" }, "f17" },
 552   { { "fr18" }, "f18" },
 553   { { "fr19" }, "f19" },
 554   { { "fr20" }, "f20" },
 555   { { "fr21" }, "f21" },
 556   { { "fr22" }, "f22" },
 557   { { "fr23" }, "f23" },
 558   { { "fr24" }, "f24" },
 559   { { "fr25" }, "f25" },
 560   { { "fr26" }, "f26" },
 561   { { "fr27" }, "f27" },
 562   { { "fr28" }, "f28" },
 563   { { "fr29" }, "f29" },
 564   { { "fr30" }, "f30" },
 565   { { "fr31" }, "f31" },
 566   { { "cc" }, "cr0" },
 567 };
 568
 569 void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
 570                                      unsigned &NumAliases) const {
 571   Aliases = GCCRegAliases;
 572   NumAliases = llvm::array_lengthof(GCCRegAliases);
 573 }
 574 } // end anonymous namespace.
 575
 576 namespace {
 577 class PPC32TargetInfo : public PPCTargetInfo {
 578 public:
 579   PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
 580     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
 581                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
 582
 583     if (getTriple().getOS() == llvm::Triple::FreeBSD)
 584         this->SizeType = TargetInfo::UnsignedInt;
 585   }
 586 };
 587 } // end anonymous namespace.
 588
 589 namespace {
 590 class PPC64TargetInfo : public PPCTargetInfo {
 591 public:
 592   PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
 593     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
 594     IntMaxType = SignedLong;
 595     UIntMaxType = UnsignedLong;
 596     Int64Type = SignedLong;
 597     DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
 598                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
 599   }
 600 };
 601 } // end anonymous namespace.
 602
 603 namespace {
 604 // MBlaze abstract base class
 605 class MBlazeTargetInfo : public TargetInfo {
 606   static const char * const GCCRegNames[];
 607   static const TargetInfo::GCCRegAlias GCCRegAliases[];
 608
 609 public:
 610   MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
 611     DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
 612                         "v64:32:32-v128:32:32-n32";
 613   }
 614
 615   virtual void getTargetBuiltins(const Builtin::Info *&Records,
 616                                  unsigned &NumRecords) const {
 617     // FIXME: Implement.
 618     Records = 0;
 619     NumRecords = 0;
 620   }
 621
 622   virtual void getTargetDefines(const LangOptions &Opts,
 623                                 MacroBuilder &Builder) const;
 624
 625   virtual const char *getVAListDeclaration() const {
 626     return "typedef char* __builtin_va_list;";
 627   }
 628   virtual const char *getTargetPrefix() const {
 629     return "mblaze";
 630   }
 631   virtual void getGCCRegNames(const char * const *&Names,
 632                               unsigned &NumNames) const;
 633   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
 634                                 unsigned &NumAliases) const;
 635   virtual bool validateAsmConstraint(const char *&Name,
 636                                      TargetInfo::ConstraintInfo &Info) const {
 637     switch (*Name) {
 638     default: return false;
 639     case 'O': // Zero
 640       return true;
 641     case 'b': // Base register
 642     case 'f': // Floating point register
 643       Info.setAllowsRegister();
 644       return true;
 645     }
 646   }
 647   virtual const char *getClobbers() const {
 648     return "";
 649   }
 650 };
 651
 652 /// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
 653 /// #defines that are not tied to a specific subtarget.
 654 void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
 655                                      MacroBuilder &Builder) const {
 656   // Target identification.
 657   Builder.defineMacro("__microblaze__");
 658   Builder.defineMacro("_ARCH_MICROBLAZE");
 659   Builder.defineMacro("__MICROBLAZE__");
 660
 661   // Target properties.
 662   Builder.defineMacro("_BIG_ENDIAN");
 663   Builder.defineMacro("__BIG_ENDIAN__");
 664
 665   // Subtarget options.
 666   Builder.defineMacro("__REGISTER_PREFIX__", "");
 667 }
 668
 669
 670 const char * const MBlazeTargetInfo::GCCRegNames[] = {
 671   "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
 672   "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
 673   "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
 674   "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",
 675   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
 676   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
 677   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
 678   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
 679   "hi",   "lo",   "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
 680   "$fcc5","$fcc6","$fcc7","$ap",  "$rap", "$frp"
 681 };
 682
 683 void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
 684                                    unsigned &NumNames) const {
 685   Names = GCCRegNames;
 686   NumNames = llvm::array_lengthof(GCCRegNames);
 687 }
 688
 689 const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
 690   { {"f0"},  "r0" },
 691   { {"f1"},  "r1" },
 692   { {"f2"},  "r2" },
 693   { {"f3"},  "r3" },
 694   { {"f4"},  "r4" },
 695   { {"f5"},  "r5" },
 696   { {"f6"},  "r6" },
 697   { {"f7"},  "r7" },
 698   { {"f8"},  "r8" },
 699   { {"f9"},  "r9" },
 700   { {"f10"}, "r10" },
 701   { {"f11"}, "r11" },
 702   { {"f12"}, "r12" },
 703   { {"f13"}, "r13" },
 704   { {"f14"}, "r14" },
 705   { {"f15"}, "r15" },
 706   { {"f16"}, "r16" },
 707   { {"f17"}, "r17" },
 708   { {"f18"}, "r18" },
 709   { {"f19"}, "r19" },
 710   { {"f20"}, "r20" },
 711   { {"f21"}, "r21" },
 712   { {"f22"}, "r22" },
 713   { {"f23"}, "r23" },
 714   { {"f24"}, "r24" },
 715   { {"f25"}, "r25" },
 716   { {"f26"}, "r26" },
 717   { {"f27"}, "r27" },
 718   { {"f28"}, "r28" },
 719   { {"f29"}, "r29" },
 720   { {"f30"}, "r30" },
 721   { {"f31"}, "r31" },
 722 };
 723
 724 void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
 725                                      unsigned &NumAliases) const {
 726   Aliases = GCCRegAliases;
 727   NumAliases = llvm::array_lengthof(GCCRegAliases);
 728 }
 729 } // end anonymous namespace.
 730
 731 namespace {
 732 // Namespace for x86 abstract base class
 733 const Builtin::Info BuiltinInfo[] = {
 734 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
 735 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
 736 #include "clang/Basic/BuiltinsX86.def"
 737 };
 738
 739 static const char* const GCCRegNames[] = {
 740   "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
 741   "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
 742   "argp", "flags", "fspr", "dirflag", "frame",
 743   "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
 744   "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
 745   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 746   "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
 747 };
 748
 749 const TargetInfo::GCCRegAlias GCCRegAliases[] = {
 750   { { "al", "ah", "eax", "rax" }, "ax" },
 751   { { "bl", "bh", "ebx", "rbx" }, "bx" },
 752   { { "cl", "ch", "ecx", "rcx" }, "cx" },
 753   { { "dl", "dh", "edx", "rdx" }, "dx" },
 754   { { "esi", "rsi" }, "si" },
 755   { { "edi", "rdi" }, "di" },
 756   { { "esp", "rsp" }, "sp" },
 757   { { "ebp", "rbp" }, "bp" },
 758 };
 759
 760 // X86 target abstract base class; x86-32 and x86-64 are very close, so
 761 // most of the implementation can be shared.
 762 class X86TargetInfo : public TargetInfo {
 763   enum X86SSEEnum {
 764     NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
 765   } SSELevel;
 766   enum AMD3DNowEnum {
 767     NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
 768   } AMD3DNowLevel;
 769
 770   bool HasAES;
 771
 772 public:
 773   X86TargetInfo(const std::string& triple)
 774     : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
 775       HasAES(false) {
 776     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
 777   }
 778   virtual void getTargetBuiltins(const Builtin::Info *&Records,
 779                                  unsigned &NumRecords) const {
 780     Records = BuiltinInfo;
 781     NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
 782   }
 783   virtual void getGCCRegNames(const char * const *&Names,
 784                               unsigned &NumNames) const {
 785     Names = GCCRegNames;
 786     NumNames = llvm::array_lengthof(GCCRegNames);
 787   }
 788   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
 789                                 unsigned &NumAliases) const {
 790     Aliases = GCCRegAliases;
 791     NumAliases = llvm::array_lengthof(GCCRegAliases);
 792   }
 793   virtual bool validateAsmConstraint(const char *&Name,
 794                                      TargetInfo::ConstraintInfo &info) const;
 795   virtual std::string convertConstraint(const char Constraint) const;
 796   virtual const char *getClobbers() const {
 797     return "~{dirflag},~{fpsr},~{flags}";
 798   }
 799   virtual void getTargetDefines(const LangOptions &Opts,
 800                                 MacroBuilder &Builder) const;
 801   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
 802                                  const std::string &Name,
 803                                  bool Enabled) const;
 804   virtual void getDefaultFeatures(const std::string &CPU,
 805                                   llvm::StringMap<bool> &Features) const;
 806   virtual void HandleTargetFeatures(std::vector<std::string> &Features);
 807 };
 808
 809 void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
 810                                        llvm::StringMap<bool> &Features) const {
 811   // FIXME: This should not be here.
 812   Features["3dnow"] = false;
 813   Features["3dnowa"] = false;
 814   Features["mmx"] = false;
 815   Features["sse"] = false;
 816   Features["sse2"] = false;
 817   Features["sse3"] = false;
 818   Features["ssse3"] = false;
 819   Features["sse41"] = false;
 820   Features["sse42"] = false;
 821   Features["aes"] = false;
 822
 823   // LLVM does not currently recognize this.
 824   // Features["sse4a"] = false;
 825
 826   // FIXME: This *really* should not be here.
 827
 828   // X86_64 always has SSE2.
 829   if (PointerWidth == 64)
 830     Features["sse2"] = Features["sse"] = Features["mmx"] = true;
 831
 832   if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
 833       CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
 834     ;
 835   else if (CPU == "pentium-mmx" || CPU == "pentium2")
 836     setFeatureEnabled(Features, "mmx", true);
 837   else if (CPU == "pentium3")
 838     setFeatureEnabled(Features, "sse", true);
 839   else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
 840     setFeatureEnabled(Features, "sse2", true);
 841   else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
 842     setFeatureEnabled(Features, "sse3", true);
 843   else if (CPU == "core2")
 844     setFeatureEnabled(Features, "ssse3", true);
 845   else if (CPU == "penryn") {
 846     setFeatureEnabled(Features, "sse4", true);
 847     Features["sse42"] = false;
 848   } else if (CPU == "atom")
 849     setFeatureEnabled(Features, "sse3", true);
 850   else if (CPU == "corei7") {
 851     setFeatureEnabled(Features, "sse4", true);
 852     setFeatureEnabled(Features, "aes", true);
 853   }
 854   else if (CPU == "k6" || CPU == "winchip-c6")
 855     setFeatureEnabled(Features, "mmx", true);
 856   else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
 857            CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
 858     setFeatureEnabled(Features, "mmx", true);
 859     setFeatureEnabled(Features, "3dnow", true);
 860   } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
 861     setFeatureEnabled(Features, "sse", true);
 862     setFeatureEnabled(Features, "3dnowa", true);
 863   } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
 864            CPU == "athlon-fx") {
 865     setFeatureEnabled(Features, "sse2", true);
 866     setFeatureEnabled(Features, "3dnowa", true);
 867   } else if (CPU == "c3-2")
 868     setFeatureEnabled(Features, "sse", true);
 869 }
 870
 871 bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
 872                                       const std::string &Name,
 873                                       bool Enabled) const {
 874   // FIXME: This *really* should not be here.  We need some way of translating
 875   // options into llvm subtarget features.
 876   if (!Features.count(Name) &&
 877       (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
 878     return false;
 879
 880   if (Enabled) {
 881     if (Name == "mmx")
 882       Features["mmx"] = true;
 883     else if (Name == "sse")
 884       Features["mmx"] = Features["sse"] = true;
 885     else if (Name == "sse2")
 886       Features["mmx"] = Features["sse"] = Features["sse2"] = true;
 887     else if (Name == "sse3")
 888       Features["mmx"] = Features["sse"] = Features["sse2"] =
 889         Features["sse3"] = true;
 890     else if (Name == "ssse3")
 891       Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
 892         Features["ssse3"] = true;
 893     else if (Name == "sse4" || Name == "sse4.2")
 894       Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
 895         Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
 896     else if (Name == "sse4.1")
 897       Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
 898         Features["ssse3"] = Features["sse41"] = true;
 899     else if (Name == "3dnow")
 900       Features["3dnowa"] = true;
 901     else if (Name == "3dnowa")
 902       Features["3dnow"] = Features["3dnowa"] = true;
 903     else if (Name == "aes")
 904       Features["aes"] = true;
 905   } else {
 906     if (Name == "mmx")
 907       Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
 908         Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
 909     else if (Name == "sse")
 910       Features["sse"] = Features["sse2"] = Features["sse3"] =
 911         Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
 912     else if (Name == "sse2")
 913       Features["sse2"] = Features["sse3"] = Features["ssse3"] =
 914         Features["sse41"] = Features["sse42"] = false;
 915     else if (Name == "sse3")
 916       Features["sse3"] = Features["ssse3"] = Features["sse41"] =
 917         Features["sse42"] = false;
 918     else if (Name == "ssse3")
 919       Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
 920     else if (Name == "sse4")
 921       Features["sse41"] = Features["sse42"] = false;
 922     else if (Name == "sse4.2")
 923       Features["sse42"] = false;
 924     else if (Name == "sse4.1")
 925       Features["sse41"] = Features["sse42"] = false;
 926     else if (Name == "3dnow")
 927       Features["3dnow"] = Features["3dnowa"] = false;
 928     else if (Name == "3dnowa")
 929       Features["3dnowa"] = false;
 930     else if (Name == "aes")
 931       Features["aes"] = false;
 932   }
 933
 934   return true;
 935 }
 936
 937 /// HandleTargetOptions - Perform initialization based on the user
 938 /// configured set of features.
 939 void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
 940   // Remember the maximum enabled sselevel.
 941   for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
 942     // Ignore disabled features.
 943     if (Features[i][0] == '-')
 944       continue;
 945
 946     if (Features[i].substr(1) == "aes") {
 947       HasAES = true;
 948       continue;
 949     }
 950
 951     assert(Features[i][0] == '+' && "Invalid target feature!");
 952     X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
 953       .Case("sse42", SSE42)
 954       .Case("sse41", SSE41)
 955       .Case("ssse3", SSSE3)
 956       .Case("sse3", SSE3)
 957       .Case("sse2", SSE2)
 958       .Case("sse", SSE1)
 959       .Case("mmx", MMX)
 960       .Default(NoMMXSSE);
 961     SSELevel = std::max(SSELevel, Level);
 962
 963     AMD3DNowEnum ThreeDNowLevel =
 964       llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
 965         .Case("3dnowa", AMD3DNowAthlon)
 966         .Case("3dnow", AMD3DNow)
 967         .Default(NoAMD3DNow);
 968
 969     AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
 970   }
 971 }
 972
 973 /// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
 974 /// that are not tied to a specific subtarget.
 975 void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
 976                                      MacroBuilder &Builder) const {
 977   // Target identification.
 978   if (PointerWidth == 64) {
 979     Builder.defineMacro("_LP64");
 980     Builder.defineMacro("__LP64__");
 981     Builder.defineMacro("__amd64__");
 982     Builder.defineMacro("__amd64");
 983     Builder.defineMacro("__x86_64");
 984     Builder.defineMacro("__x86_64__");
 985   } else {
 986     DefineStd(Builder, "i386", Opts);
 987   }
 988
 989   if (HasAES)
 990     Builder.defineMacro("__AES__");
 991
 992   // Target properties.
 993   Builder.defineMacro("__LITTLE_ENDIAN__");
 994
 995   // Subtarget options.
 996   Builder.defineMacro("__nocona");
 997   Builder.defineMacro("__nocona__");
 998   Builder.defineMacro("__tune_nocona__");
 999   Builder.defineMacro("__REGISTER_PREFIX__", "");
1000
1001   // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1002   // functions in glibc header files that use FP Stack inline asm which the
1003   // backend can't deal with (PR879).
1004   Builder.defineMacro("__NO_MATH_INLINES");
1005
1006   // Each case falls through to the previous one here.
1007   switch (SSELevel) {
1008   case SSE42:
1009     Builder.defineMacro("__SSE4_2__");
1010   case SSE41:
1011     Builder.defineMacro("__SSE4_1__");
1012   case SSSE3:
1013     Builder.defineMacro("__SSSE3__");
1014   case SSE3:
1015     Builder.defineMacro("__SSE3__");
1016   case SSE2:
1017     Builder.defineMacro("__SSE2__");
1018     Builder.defineMacro("__SSE2_MATH__");  // -mfp-math=sse always implied.
1019   case SSE1:
1020     Builder.defineMacro("__SSE__");
1021     Builder.defineMacro("__SSE_MATH__");   // -mfp-math=sse always implied.
1022   case MMX:
1023     Builder.defineMacro("__MMX__");
1024   case NoMMXSSE:
1025     break;
1026   }
1027
1028   // Each case falls through to the previous one here.
1029   switch (AMD3DNowLevel) {
1030   case AMD3DNowAthlon:
1031     Builder.defineMacro("__3dNOW_A__");
1032   case AMD3DNow:
1033     Builder.defineMacro("__3dNOW__");
1034   case NoAMD3DNow:
1035     break;
1036   }
1037 }
1038
1039
1040 bool
1041 X86TargetInfo::validateAsmConstraint(const char *&Name,
1042                                      TargetInfo::ConstraintInfo &Info) const {
1043   switch (*Name) {
1044   default: return false;
1045   case 'a': // eax.
1046   case 'b': // ebx.
1047   case 'c': // ecx.
1048   case 'd': // edx.
1049   case 'S': // esi.
1050   case 'D': // edi.
1051   case 'A': // edx:eax.
1052   case 't': // top of floating point stack.
1053   case 'u': // second from top of floating point stack.
1054   case 'q': // Any register accessible as [r]l: a, b, c, and d.
1055   case 'y': // Any MMX register.
1056   case 'x': // Any SSE register.
1057   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
1058   case 'e': // 32-bit signed integer constant for use with zero-extending
1059             // x86_64 instructions.
1060   case 'Z': // 32-bit unsigned integer constant for use with zero-extending
1061             // x86_64 instructions.
1062   case 'N': // unsigned 8-bit integer constant for use with in and out
1063             // instructions.
1064   case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1065     Info.setAllowsRegister();
1066     return true;
1067   }
1068 }
1069
1070 std::string
1071 X86TargetInfo::convertConstraint(const char Constraint) const {
1072   switch (Constraint) {
1073   case 'a': return std::string("{ax}");
1074   case 'b': return std::string("{bx}");
1075   case 'c': return std::string("{cx}");
1076   case 'd': return std::string("{dx}");
1077   case 'S': return std::string("{si}");
1078   case 'D': return std::string("{di}");
1079   case 't': // top of floating point stack.
1080     return std::string("{st}");
1081   case 'u': // second from top of floating point stack.
1082     return std::string("{st(1)}"); // second from top of floating point stack.
1083   default:
1084     return std::string(1, Constraint);
1085   }
1086 }
1087 } // end anonymous namespace
1088
1089 namespace {
1090 // X86-32 generic target
1091 class X86_32TargetInfo : public X86TargetInfo {
1092 public:
1093   X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1094     DoubleAlign = LongLongAlign = 32;
1095     LongDoubleWidth = 96;
1096     LongDoubleAlign = 32;
1097     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1098                         "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
1099                         "a0:0:64-f80:32:32-n8:16:32";
1100     SizeType = UnsignedInt;
1101     PtrDiffType = SignedInt;
1102     IntPtrType = SignedInt;
1103     RegParmMax = 3;
1104   }
1105   virtual const char *getVAListDeclaration() const {
1106     return "typedef char* __builtin_va_list;";
1107   }
1108
1109   int getEHDataRegisterNumber(unsigned RegNo) const {
1110     if (RegNo == 0) return 0;
1111     if (RegNo == 1) return 2;
1112     return -1;
1113   }
1114 };
1115 } // end anonymous namespace
1116
1117 namespace {
1118 class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1119 public:
1120   OpenBSDI386TargetInfo(const std::string& triple) :
1121     OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1122     SizeType = UnsignedLong;
1123     IntPtrType = SignedLong;
1124     PtrDiffType = SignedLong;
1125   }
1126 };
1127 } // end anonymous namespace
1128
1129 namespace {
1130 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
1131 public:
1132   DarwinI386TargetInfo(const std::string& triple) :
1133     DarwinTargetInfo<X86_32TargetInfo>(triple) {
1134     LongDoubleWidth = 128;
1135     LongDoubleAlign = 128;
1136     SizeType = UnsignedLong;
1137     IntPtrType = SignedLong;
1138     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1139                         "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
1140                         "a0:0:64-f80:128:128-n8:16:32";
1141     HasAlignMac68kSupport = true;
1142   }
1143
1144 };
1145 } // end anonymous namespace
1146
1147 namespace {
1148 // x86-32 Windows target
1149 class WindowsX86_32TargetInfo : public X86_32TargetInfo {
1150 public:
1151   WindowsX86_32TargetInfo(const std::string& triple)
1152     : X86_32TargetInfo(triple) {
1153     TLSSupported = false;
1154     WCharType = UnsignedShort;
1155     DoubleAlign = LongLongAlign = 64;
1156     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1157                         "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1158                         "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
1159   }
1160   virtual void getTargetDefines(const LangOptions &Opts,
1161                                 MacroBuilder &Builder) const {
1162     X86_32TargetInfo::getTargetDefines(Opts, Builder);
1163     // This list is based off of the the list of things MingW defines
1164     Builder.defineMacro("_WIN32");
1165     DefineStd(Builder, "WIN32", Opts);
1166     DefineStd(Builder, "WINNT", Opts);
1167     Builder.defineMacro("_X86_");
1168   }
1169 };
1170 } // end anonymous namespace
1171
1172 namespace {
1173
1174 // x86-32 Windows Visual Studio target
1175 class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1176 public:
1177   VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1178     : WindowsX86_32TargetInfo(triple) {
1179   }
1180   virtual void getTargetDefines(const LangOptions &Opts,
1181                                 MacroBuilder &Builder) const {
1182     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1183     // The value of the following reflects processor type.
1184     // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1185     // We lost the original triple, so we use the default.
1186     Builder.defineMacro("_M_IX86", "600");
1187   }
1188 };
1189 } // end anonymous namespace
1190
1191 namespace {
1192 // x86-32 MinGW target
1193 class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1194 public:
1195   MinGWX86_32TargetInfo(const std::string& triple)
1196     : WindowsX86_32TargetInfo(triple) {
1197   }
1198   virtual void getTargetDefines(const LangOptions &Opts,
1199                                 MacroBuilder &Builder) const {
1200     WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1201     Builder.defineMacro("__MSVCRT__");
1202     Builder.defineMacro("__MINGW32__");
1203     Builder.defineMacro("__declspec", "__declspec");
1204   }
1205 };
1206 } // end anonymous namespace
1207
1208 namespace {
1209 // x86-32 Cygwin target
1210 class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1211 public:
1212   CygwinX86_32TargetInfo(const std::string& triple)
1213     : X86_32TargetInfo(triple) {
1214     TLSSupported = false;
1215     WCharType = UnsignedShort;
1216     DoubleAlign = LongLongAlign = 64;
1217     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1218                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1219                         "a0:0:64-f80:32:32-n8:16:32";
1220   }
1221   virtual void getTargetDefines(const LangOptions &Opts,
1222                                 MacroBuilder &Builder) const {
1223     X86_32TargetInfo::getTargetDefines(Opts, Builder);
1224     Builder.defineMacro("__CYGWIN__");
1225     Builder.defineMacro("__CYGWIN32__");
1226     DefineStd(Builder, "unix", Opts);
1227     if (Opts.CPlusPlus)
1228       Builder.defineMacro("_GNU_SOURCE");
1229   }
1230 };
1231 } // end anonymous namespace
1232
1233 namespace {
1234 // x86-32 Haiku target
1235 class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1236 public:
1237   HaikuX86_32TargetInfo(const std::string& triple)
1238     : X86_32TargetInfo(triple) {
1239     SizeType = UnsignedLong;
1240     IntPtrType = SignedLong;
1241     PtrDiffType = SignedLong;
1242   }
1243   virtual void getTargetDefines(const LangOptions &Opts,
1244                                 MacroBuilder &Builder) const {
1245     X86_32TargetInfo::getTargetDefines(Opts, Builder);
1246     Builder.defineMacro("__INTEL__");
1247     Builder.defineMacro("__HAIKU__");
1248   }
1249 };
1250 } // end anonymous namespace
1251
1252 namespace {
1253 // x86-64 generic target
1254 class X86_64TargetInfo : public X86TargetInfo {
1255 public:
1256   X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
1257     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1258     LongDoubleWidth = 128;
1259     LongDoubleAlign = 128;
1260     IntMaxType = SignedLong;
1261     UIntMaxType = UnsignedLong;
1262     Int64Type = SignedLong;
1263     RegParmMax = 6;
1264
1265     DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1266                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1267                         "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
1268   }
1269   virtual const char *getVAListDeclaration() const {
1270     return "typedef struct __va_list_tag {"
1271            "  unsigned gp_offset;"
1272            "  unsigned fp_offset;"
1273            "  void* overflow_arg_area;"
1274            "  void* reg_save_area;"
1275            "} __va_list_tag;"
1276            "typedef __va_list_tag __builtin_va_list[1];";
1277   }
1278
1279   int getEHDataRegisterNumber(unsigned RegNo) const {
1280     if (RegNo == 0) return 0;
1281     if (RegNo == 1) return 1;
1282     return -1;
1283   }
1284 };
1285 } // end anonymous namespace
1286
1287 namespace {
1288 // x86-64 Windows target
1289 class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1290 public:
1291   WindowsX86_64TargetInfo(const std::string& triple)
1292     : X86_64TargetInfo(triple) {
1293     TLSSupported = false;
1294     WCharType = UnsignedShort;
1295     LongWidth = LongAlign = 32;
1296     DoubleAlign = LongLongAlign = 64;
1297   }
1298   virtual void getTargetDefines(const LangOptions &Opts,
1299                                 MacroBuilder &Builder) const {
1300     X86_64TargetInfo::getTargetDefines(Opts, Builder);
1301     Builder.defineMacro("_WIN64");
1302     DefineStd(Builder, "WIN64", Opts);
1303   }
1304 };
1305 } // end anonymous namespace
1306
1307 namespace {
1308 // x86-64 Windows Visual Studio target
1309 class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1310 public:
1311   VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1312     : WindowsX86_64TargetInfo(triple) {
1313   }
1314   virtual void getTargetDefines(const LangOptions &Opts,
1315                                 MacroBuilder &Builder) const {
1316     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1317     Builder.defineMacro("_M_X64");
1318   }
1319   virtual const char *getVAListDeclaration() const {
1320     return "typedef char* va_list;";
1321   }
1322 };
1323 } // end anonymous namespace
1324
1325 namespace {
1326 // x86-64 MinGW target
1327 class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1328 public:
1329   MinGWX86_64TargetInfo(const std::string& triple)
1330     : WindowsX86_64TargetInfo(triple) {
1331   }
1332   virtual void getTargetDefines(const LangOptions &Opts,
1333                                 MacroBuilder &Builder) const {
1334     WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1335     Builder.defineMacro("__MSVCRT__");
1336     Builder.defineMacro("__MINGW64__");
1337     Builder.defineMacro("__declspec");
1338   }
1339 };
1340 } // end anonymous namespace
1341
1342 namespace {
1343 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1344 public:
1345   DarwinX86_64TargetInfo(const std::string& triple)
1346       : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1347     Int64Type = SignedLongLong;
1348   }
1349 };
1350 } // end anonymous namespace
1351
1352 namespace {
1353 class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1354 public:
1355   OpenBSDX86_64TargetInfo(const std::string& triple)
1356       : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1357     IntMaxType = SignedLongLong;
1358     UIntMaxType = UnsignedLongLong;
1359     Int64Type = SignedLongLong;
1360   }
1361 };
1362 } // end anonymous namespace
1363
1364 namespace {
1365 class ARMTargetInfo : public TargetInfo {
1366   // Possible FPU choices.
1367   enum FPUMode {
1368     NoFPU,
1369     VFP2FPU,
1370     VFP3FPU,
1371     NeonFPU
1372   };
1373
1374   static bool FPUModeIsVFP(FPUMode Mode) {
1375     return Mode >= VFP2FPU && Mode <= NeonFPU;
1376   }
1377
1378   static const TargetInfo::GCCRegAlias GCCRegAliases[];
1379   static const char * const GCCRegNames[];
1380
1381   std::string ABI, CPU;
1382
1383   unsigned FPU : 3;
1384
1385   unsigned IsThumb : 1;
1386
1387   // Initialized via features.
1388   unsigned SoftFloat : 1;
1389   unsigned SoftFloatABI : 1;
1390
1391   static const Builtin::Info BuiltinInfo[];
1392
1393 public:
1394   ARMTargetInfo(const std::string &TripleStr)
1395     : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
1396   {
1397     SizeType = UnsignedInt;
1398     PtrDiffType = SignedInt;
1399
1400     // {} in inline assembly are neon specifiers, not assembly variant
1401     // specifiers.
1402     NoAsmVariants = true;
1403
1404     // FIXME: Should we just treat this as a feature?
1405     IsThumb = getTriple().getArchName().startswith("thumb");
1406     if (IsThumb) {
1407       DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1408                            "i64:64:64-f32:32:32-f64:64:64-"
1409                            "v64:64:64-v128:128:128-a0:0:32-n32");
1410     } else {
1411       DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1412                            "i64:64:64-f32:32:32-f64:64:64-"
1413                            "v64:64:64-v128:128:128-a0:0:64-n32");
1414     }
1415   }
1416   virtual const char *getABI() const { return ABI.c_str(); }
1417   virtual bool setABI(const std::string &Name) {
1418     ABI = Name;
1419
1420     // The defaults (above) are for AAPCS, check if we need to change them.
1421     //
1422     // FIXME: We need support for -meabi... we could just mangle it into the
1423     // name.
1424     if (Name == "apcs-gnu") {
1425       DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
1426       SizeType = UnsignedLong;
1427
1428       // Do not respect the alignment of bit-field types when laying out
1429       // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1430       UseBitFieldTypeAlignment = false;
1431
1432       if (IsThumb) {
1433         DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1434                              "i64:32:32-f32:32:32-f64:32:32-"
1435                              "v64:64:64-v128:128:128-a0:0:32-n32");
1436       } else {
1437         DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1438                              "i64:32:32-f32:32:32-f64:32:32-"
1439                              "v64:64:64-v128:128:128-a0:0:64-n32");
1440       }
1441
1442       // FIXME: Override "preferred align" for double and long long.
1443     } else if (Name == "aapcs") {
1444       // FIXME: Enumerated types are variable width in straight AAPCS.
1445     } else if (Name == "aapcs-linux") {
1446       ;
1447     } else
1448       return false;
1449
1450     return true;
1451   }
1452
1453   void getDefaultFeatures(const std::string &CPU,
1454                           llvm::StringMap<bool> &Features) const {
1455     // FIXME: This should not be here.
1456     Features["vfp2"] = false;
1457     Features["vfp3"] = false;
1458     Features["neon"] = false;
1459
1460     if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1461       Features["vfp2"] = true;
1462     else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1463       Features["neon"] = true;
1464   }
1465
1466   virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1467                                  const std::string &Name,
1468                                  bool Enabled) const {
1469     if (Name == "soft-float" || Name == "soft-float-abi") {
1470       Features[Name] = Enabled;
1471     } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1472       // These effectively are a single option, reset them when any is enabled.
1473       if (Enabled)
1474         Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1475       Features[Name] = Enabled;
1476     } else
1477       return false;
1478
1479     return true;
1480   }
1481
1482   virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
1483     FPU = NoFPU;
1484     SoftFloat = SoftFloatABI = false;
1485     for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1486       if (Features[i] == "+soft-float")
1487         SoftFloat = true;
1488       else if (Features[i] == "+soft-float-abi")
1489         SoftFloatABI = true;
1490       else if (Features[i] == "+vfp2")
1491         FPU = VFP2FPU;
1492       else if (Features[i] == "+vfp3")
1493         FPU = VFP3FPU;
1494       else if (Features[i] == "+neon")
1495         FPU = NeonFPU;
1496     }
1497
1498     // Remove front-end specific options which the backend handles differently.
1499     std::vector<std::string>::iterator it;
1500     it = std::find(Features.begin(), Features.end(), "+soft-float");
1501     if (it != Features.end())
1502       Features.erase(it);
1503     it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1504     if (it != Features.end())
1505       Features.erase(it);
1506   }
1507
1508   static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1509     return llvm::StringSwitch<const char*>(Name)
1510       .Cases("arm8", "arm810", "4")
1511       .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1512       .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1513       .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1514       .Case("ep9312", "4T")
1515       .Cases("arm10tdmi", "arm1020t", "5T")
1516       .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1517       .Case("arm926ej-s", "5TEJ")
1518       .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1519       .Cases("xscale", "iwmmxt", "5TE")
1520       .Case("arm1136j-s", "6J")
1521       .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
1522       .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
1523       .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1524       .Cases("cortex-a8", "cortex-a9", "7A")
1525       .Default(0);
1526   }
1527   virtual bool setCPU(const std::string &Name) {
1528     if (!getCPUDefineSuffix(Name))
1529       return false;
1530
1531     CPU = Name;
1532     return true;
1533   }
1534   virtual void getTargetDefines(const LangOptions &Opts,
1535                                 MacroBuilder &Builder) const {
1536     // Target identification.
1537     Builder.defineMacro("__arm");
1538     Builder.defineMacro("__arm__");
1539
1540     // Target properties.
1541     Builder.defineMacro("__ARMEL__");
1542     Builder.defineMacro("__LITTLE_ENDIAN__");
1543     Builder.defineMacro("__REGISTER_PREFIX__", "");
1544
1545     llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
1546     Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
1547
1548     // Subtarget options.
1549
1550     // FIXME: It's more complicated than this and we don't really support
1551     // interworking.
1552     if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
1553       Builder.defineMacro("__THUMB_INTERWORK__");
1554
1555     if (ABI == "aapcs" || ABI == "aapcs-linux")
1556       Builder.defineMacro("__ARM_EABI__");
1557
1558     if (SoftFloat)
1559       Builder.defineMacro("__SOFTFP__");
1560
1561     if (CPU == "xscale")
1562       Builder.defineMacro("__XSCALE__");
1563
1564     bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
1565     if (IsThumb) {
1566       Builder.defineMacro("__THUMBEL__");
1567       Builder.defineMacro("__thumb__");
1568       if (IsThumb2)
1569         Builder.defineMacro("__thumb2__");
1570     }
1571
1572     // Note, this is always on in gcc, even though it doesn't make sense.
1573     Builder.defineMacro("__APCS_32__");
1574
1575     if (FPUModeIsVFP((FPUMode) FPU))
1576       Builder.defineMacro("__VFP_FP__");
1577
1578     // This only gets set when Neon instructions are actually available, unlike
1579     // the VFP define, hence the soft float and arch check. This is subtly
1580     // different from gcc, we follow the intent which was that it should be set
1581     // when Neon instructions are actually available.
1582     if (FPU == NeonFPU && !SoftFloat && IsThumb2)
1583       Builder.defineMacro("__ARM_NEON__");
1584   }
1585   virtual void getTargetBuiltins(const Builtin::Info *&Records,
1586                                  unsigned &NumRecords) const {
1587     Records = BuiltinInfo;
1588     NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
1589   }
1590   virtual const char *getVAListDeclaration() const {
1591     return "typedef char* __builtin_va_list;";
1592   }
1593   virtual void getGCCRegNames(const char * const *&Names,
1594                               unsigned &NumNames) const;
1595   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1596                                 unsigned &NumAliases) const;
1597   virtual bool validateAsmConstraint(const char *&Name,
1598                                      TargetInfo::ConstraintInfo &Info) const {
1599     // FIXME: Check if this is complete
1600     switch (*Name) {
1601     default:
1602     case 'l': // r0-r7
1603     case 'h': // r8-r15
1604     case 'w': // VFP Floating point register single precision
1605     case 'P': // VFP Floating point register double precision
1606       Info.setAllowsRegister();
1607       return true;
1608     }
1609     return false;
1610   }
1611   virtual const char *getClobbers() const {
1612     // FIXME: Is this really right?
1613     return "";
1614   }
1615 };
1616
1617 const char * const ARMTargetInfo::GCCRegNames[] = {
1618   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1619   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1620 };
1621
1622 void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1623                                        unsigned &NumNames) const {
1624   Names = GCCRegNames;
1625   NumNames = llvm::array_lengthof(GCCRegNames);
1626 }
1627
1628 const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1629
1630   { { "a1" }, "r0" },
1631   { { "a2" }, "r1" },
1632   { { "a3" }, "r2" },
1633   { { "a4" }, "r3" },
1634   { { "v1" }, "r4" },
1635   { { "v2" }, "r5" },
1636   { { "v3" }, "r6" },
1637   { { "v4" }, "r7" },
1638   { { "v5" }, "r8" },
1639   { { "v6", "rfp" }, "r9" },
1640   { { "sl" }, "r10" },
1641   { { "fp" }, "r11" },
1642   { { "ip" }, "r12" },
1643   { { "sp" }, "r13" },
1644   { { "lr" }, "r14" },
1645   { { "pc" }, "r15" },
1646 };
1647
1648 void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1649                                        unsigned &NumAliases) const {
1650   Aliases = GCCRegAliases;
1651   NumAliases = llvm::array_lengthof(GCCRegAliases);
1652 }
1653
1654 const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1655 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1656 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1657 #include "clang/Basic/BuiltinsARM.def"
1658 };
1659 } // end anonymous namespace.
1660
1661
1662 namespace {
1663 class DarwinARMTargetInfo :
1664   public DarwinTargetInfo<ARMTargetInfo> {
1665 protected:
1666   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1667                             MacroBuilder &Builder) const {
1668     getDarwinDefines(Builder, Opts, Triple);
1669   }
1670
1671 public:
1672   DarwinARMTargetInfo(const std::string& triple)
1673     : DarwinTargetInfo<ARMTargetInfo>(triple) {
1674     HasAlignMac68kSupport = true;
1675   }
1676 };
1677 } // end anonymous namespace.
1678
1679 namespace {
1680 class SparcV8TargetInfo : public TargetInfo {
1681   static const TargetInfo::GCCRegAlias GCCRegAliases[];
1682   static const char * const GCCRegNames[];
1683 public:
1684   SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1685     // FIXME: Support Sparc quad-precision long double?
1686     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1687                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
1688   }
1689   virtual void getTargetDefines(const LangOptions &Opts,
1690                                 MacroBuilder &Builder) const {
1691     DefineStd(Builder, "sparc", Opts);
1692     Builder.defineMacro("__sparcv8");
1693     Builder.defineMacro("__REGISTER_PREFIX__", "");
1694   }
1695   virtual void getTargetBuiltins(const Builtin::Info *&Records,
1696                                  unsigned &NumRecords) const {
1697     // FIXME: Implement!
1698   }
1699   virtual const char *getVAListDeclaration() const {
1700     return "typedef void* __builtin_va_list;";
1701   }
1702   virtual void getGCCRegNames(const char * const *&Names,
1703                               unsigned &NumNames) const;
1704   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1705                                 unsigned &NumAliases) const;
1706   virtual bool validateAsmConstraint(const char *&Name,
1707                                      TargetInfo::ConstraintInfo &info) const {
1708     // FIXME: Implement!
1709     return false;
1710   }
1711   virtual const char *getClobbers() const {
1712     // FIXME: Implement!
1713     return "";
1714   }
1715 };
1716
1717 const char * const SparcV8TargetInfo::GCCRegNames[] = {
1718   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1719   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1720   "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1721   "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1722 };
1723
1724 void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
1725                                        unsigned &NumNames) const {
1726   Names = GCCRegNames;
1727   NumNames = llvm::array_lengthof(GCCRegNames);
1728 }
1729
1730 const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
1731   { { "g0" }, "r0" },
1732   { { "g1" }, "r1" },
1733   { { "g2" }, "r2" },
1734   { { "g3" }, "r3" },
1735   { { "g4" }, "r4" },
1736   { { "g5" }, "r5" },
1737   { { "g6" }, "r6" },
1738   { { "g7" }, "r7" },
1739   { { "o0" }, "r8" },
1740   { { "o1" }, "r9" },
1741   { { "o2" }, "r10" },
1742   { { "o3" }, "r11" },
1743   { { "o4" }, "r12" },
1744   { { "o5" }, "r13" },
1745   { { "o6", "sp" }, "r14" },
1746   { { "o7" }, "r15" },
1747   { { "l0" }, "r16" },
1748   { { "l1" }, "r17" },
1749   { { "l2" }, "r18" },
1750   { { "l3" }, "r19" },
1751   { { "l4" }, "r20" },
1752   { { "l5" }, "r21" },
1753   { { "l6" }, "r22" },
1754   { { "l7" }, "r23" },
1755   { { "i0" }, "r24" },
1756   { { "i1" }, "r25" },
1757   { { "i2" }, "r26" },
1758   { { "i3" }, "r27" },
1759   { { "i4" }, "r28" },
1760   { { "i5" }, "r29" },
1761   { { "i6", "fp" }, "r30" },
1762   { { "i7" }, "r31" },
1763 };
1764
1765 void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1766                                          unsigned &NumAliases) const {
1767   Aliases = GCCRegAliases;
1768   NumAliases = llvm::array_lengthof(GCCRegAliases);
1769 }
1770 } // end anonymous namespace.
1771
1772 namespace {
1773 class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1774 public:
1775   AuroraUXSparcV8TargetInfo(const std::string& triple) :
1776       AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1777     SizeType = UnsignedInt;
1778     PtrDiffType = SignedInt;
1779   }
1780 };
1781 class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
1782 public:
1783   SolarisSparcV8TargetInfo(const std::string& triple) :
1784       SolarisTargetInfo<SparcV8TargetInfo>(triple) {
1785     SizeType = UnsignedInt;
1786     PtrDiffType = SignedInt;
1787   }
1788 };
1789 } // end anonymous namespace.
1790
1791 namespace {
1792   class PIC16TargetInfo : public TargetInfo{
1793   public:
1794     PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
1795       TLSSupported = false;
1796       IntWidth = 16;
1797       LongWidth = LongLongWidth = 32;
1798       PointerWidth = 16;
1799       IntAlign = 8;
1800       LongAlign = LongLongAlign = 8;
1801       PointerAlign = 8;
1802       SizeType = UnsignedInt;
1803       IntMaxType = SignedLong;
1804       UIntMaxType = UnsignedLong;
1805       IntPtrType = SignedShort;
1806       PtrDiffType = SignedInt;
1807       SigAtomicType = SignedLong;
1808       FloatWidth = 32;
1809       FloatAlign = 32;
1810       DoubleWidth = 32;
1811       DoubleAlign = 32;
1812       LongDoubleWidth = 32;
1813       LongDoubleAlign = 32;
1814       FloatFormat = &llvm::APFloat::IEEEsingle;
1815       DoubleFormat = &llvm::APFloat::IEEEsingle;
1816       LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1817       DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32-n8";
1818
1819     }
1820     virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1821     virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
1822     virtual void getTargetDefines(const LangOptions &Opts,
1823                                 MacroBuilder &Builder) const {
1824       Builder.defineMacro("__pic16");
1825       Builder.defineMacro("__PIC16");
1826       Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1827       Builder.defineMacro("ram", "__attribute__((address_space(0)))");
1828       Builder.defineMacro("__section(SectName)",
1829              "__attribute__((section(SectName)))");
1830       Builder.defineMacro("near",
1831              "__attribute__((section(\"Address=NEAR\")))");
1832       Builder.defineMacro("__address(Addr)",
1833              "__attribute__((section(\"Address=\"#Addr)))");
1834       Builder.defineMacro("__config(conf)", "asm(\"CONFIG \"#conf)");
1835       Builder.defineMacro("__idlocs(value)", "asm(\"__IDLOCS \"#value)");
1836       Builder.defineMacro("interrupt",
1837              "__attribute__((section(\"interrupt=0x4\"))) \
1838              __attribute__((used))");
1839     }
1840     virtual void getTargetBuiltins(const Builtin::Info *&Records,
1841                                    unsigned &NumRecords) const {}
1842     virtual const char *getVAListDeclaration() const {
1843       return "typedef char* __builtin_va_list;";
1844     }
1845     virtual const char *getClobbers() const {
1846       return "";
1847     }
1848     virtual void getGCCRegNames(const char * const *&Names,
1849                                 unsigned &NumNames) const {}
1850     virtual bool validateAsmConstraint(const char *&Name,
1851                                        TargetInfo::ConstraintInfo &info) const {
1852       return true;
1853     }
1854     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1855                                   unsigned &NumAliases) const {}
1856     virtual bool useGlobalsForAutomaticVariables() const {return true;}
1857   };
1858 }
1859
1860 namespace {
1861   class MSP430TargetInfo : public TargetInfo {
1862     static const char * const GCCRegNames[];
1863   public:
1864     MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1865       TLSSupported = false;
1866       IntWidth = 16; IntAlign = 16;
1867       LongWidth = 32; LongLongWidth = 64;
1868       LongAlign = LongLongAlign = 16;
1869       PointerWidth = 16; PointerAlign = 16;
1870       SizeType = UnsignedInt;
1871       IntMaxType = SignedLong;
1872       UIntMaxType = UnsignedLong;
1873       IntPtrType = SignedShort;
1874       PtrDiffType = SignedInt;
1875       SigAtomicType = SignedLong;
1876       DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
1877    }
1878     virtual void getTargetDefines(const LangOptions &Opts,
1879                                   MacroBuilder &Builder) const {
1880       Builder.defineMacro("MSP430");
1881       Builder.defineMacro("__MSP430__");
1882       // FIXME: defines for different 'flavours' of MCU
1883     }
1884     virtual void getTargetBuiltins(const Builtin::Info *&Records,
1885                                    unsigned &NumRecords) const {
1886      // FIXME: Implement.
1887       Records = 0;
1888       NumRecords = 0;
1889     }
1890     virtual void getGCCRegNames(const char * const *&Names,
1891                                 unsigned &NumNames) const;
1892     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1893                                   unsigned &NumAliases) const {
1894       // No aliases.
1895       Aliases = 0;
1896       NumAliases = 0;
1897     }
1898     virtual bool validateAsmConstraint(const char *&Name,
1899                                        TargetInfo::ConstraintInfo &info) const {
1900       // No target constraints for now.
1901       return false;
1902     }
1903     virtual const char *getClobbers() const {
1904       // FIXME: Is this really right?
1905       return "";
1906     }
1907     virtual const char *getVAListDeclaration() const {
1908       // FIXME: implement
1909       return "typedef char* __builtin_va_list;";
1910    }
1911   };
1912
1913   const char * const MSP430TargetInfo::GCCRegNames[] = {
1914     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1915     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1916   };
1917
1918   void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1919                                         unsigned &NumNames) const {
1920     Names = GCCRegNames;
1921     NumNames = llvm::array_lengthof(GCCRegNames);
1922   }
1923 }
1924
1925
1926 namespace {
1927   class SystemZTargetInfo : public TargetInfo {
1928     static const char * const GCCRegNames[];
1929   public:
1930     SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1931       TLSSupported = false;
1932       IntWidth = IntAlign = 32;
1933       LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1934       PointerWidth = PointerAlign = 64;
1935       DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1936       "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
1937    }
1938     virtual void getTargetDefines(const LangOptions &Opts,
1939                                   MacroBuilder &Builder) const {
1940       Builder.defineMacro("__s390__");
1941       Builder.defineMacro("__s390x__");
1942     }
1943     virtual void getTargetBuiltins(const Builtin::Info *&Records,
1944                                    unsigned &NumRecords) const {
1945       // FIXME: Implement.
1946       Records = 0;
1947       NumRecords = 0;
1948     }
1949
1950     virtual void getGCCRegNames(const char * const *&Names,
1951                                 unsigned &NumNames) const;
1952     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1953                                   unsigned &NumAliases) const {
1954       // No aliases.
1955       Aliases = 0;
1956       NumAliases = 0;
1957     }
1958     virtual bool validateAsmConstraint(const char *&Name,
1959                                        TargetInfo::ConstraintInfo &info) const {
1960       // FIXME: implement
1961       return true;
1962     }
1963     virtual const char *getClobbers() const {
1964       // FIXME: Is this really right?
1965       return "";
1966     }
1967     virtual const char *getVAListDeclaration() const {
1968       // FIXME: implement
1969       return "typedef char* __builtin_va_list;";
1970    }
1971   };
1972
1973   const char * const SystemZTargetInfo::GCCRegNames[] = {
1974     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1975     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1976   };
1977
1978   void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1979                                          unsigned &NumNames) const {
1980     Names = GCCRegNames;
1981     NumNames = llvm::array_lengthof(GCCRegNames);
1982   }
1983 }
1984
1985 namespace {
1986   class BlackfinTargetInfo : public TargetInfo {
1987     static const char * const GCCRegNames[];
1988   public:
1989     BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1990       TLSSupported = false;
1991       DoubleAlign = 32;
1992       LongLongAlign = 32;
1993       LongDoubleAlign = 32;
1994       DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
1995     }
1996
1997     virtual void getTargetDefines(const LangOptions &Opts,
1998                                   MacroBuilder &Builder) const {
1999       DefineStd(Builder, "bfin", Opts);
2000       DefineStd(Builder, "BFIN", Opts);
2001       Builder.defineMacro("__ADSPBLACKFIN__");
2002       // FIXME: This one is really dependent on -mcpu
2003       Builder.defineMacro("__ADSPLPBLACKFIN__");
2004       // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2005     }
2006
2007     virtual void getTargetBuiltins(const Builtin::Info *&Records,
2008                                    unsigned &NumRecords) const {
2009       // FIXME: Implement.
2010       Records = 0;
2011       NumRecords = 0;
2012     }
2013
2014     virtual void getGCCRegNames(const char * const *&Names,
2015                                 unsigned &NumNames) const;
2016
2017     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2018                                   unsigned &NumAliases) const {
2019       // No aliases.
2020       Aliases = 0;
2021       NumAliases = 0;
2022     }
2023
2024     virtual bool validateAsmConstraint(const char *&Name,
2025                                        TargetInfo::ConstraintInfo &Info) const {
2026       if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2027         Info.setAllowsRegister();
2028         return true;
2029       }
2030       return false;
2031     }
2032
2033     virtual const char *getClobbers() const {
2034       return "";
2035     }
2036
2037     virtual const char *getVAListDeclaration() const {
2038       return "typedef char* __builtin_va_list;";
2039     }
2040   };
2041
2042   const char * const BlackfinTargetInfo::GCCRegNames[] = {
2043     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2044     "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2045     "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2046     "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2047     "a0", "a1", "cc",
2048     "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2049     "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2050   };
2051
2052   void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2053                                           unsigned &NumNames) const {
2054     Names = GCCRegNames;
2055     NumNames = llvm::array_lengthof(GCCRegNames);
2056   }
2057 }
2058
2059 namespace {
2060
2061   // LLVM and Clang cannot be used directly to output native binaries for
2062   // target, but is used to compile C code to llvm bitcode with correct
2063   // type and alignment information.
2064   //
2065   // TCE uses the llvm bitcode as input and uses it for generating customized
2066   // target processor and program binary. TCE co-design environment is
2067   // publicly available in http://tce.cs.tut.fi
2068
2069   class TCETargetInfo : public TargetInfo{
2070   public:
2071     TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2072       TLSSupported = false;
2073       IntWidth = 32;
2074       LongWidth = LongLongWidth = 32;
2075       PointerWidth = 32;
2076       IntAlign = 32;
2077       LongAlign = LongLongAlign = 32;
2078       PointerAlign = 32;
2079       SizeType = UnsignedInt;
2080       IntMaxType = SignedLong;
2081       UIntMaxType = UnsignedLong;
2082       IntPtrType = SignedInt;
2083       PtrDiffType = SignedInt;
2084       FloatWidth = 32;
2085       FloatAlign = 32;
2086       DoubleWidth = 32;
2087       DoubleAlign = 32;
2088       LongDoubleWidth = 32;
2089       LongDoubleAlign = 32;
2090       FloatFormat = &llvm::APFloat::IEEEsingle;
2091       DoubleFormat = &llvm::APFloat::IEEEsingle;
2092       LongDoubleFormat = &llvm::APFloat::IEEEsingle;
2093       DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2094                           "i16:16:32-i32:32:32-i64:32:32-"
2095                           "f32:32:32-f64:64:64-v64:64:64-"
2096                           "v128:128:128-a0:0:64-n32";
2097     }
2098
2099     virtual void getTargetDefines(const LangOptions &Opts,
2100                                   MacroBuilder &Builder) const {
2101       DefineStd(Builder, "tce", Opts);
2102       Builder.defineMacro("__TCE__");
2103       Builder.defineMacro("__TCE_V1__");
2104     }
2105     virtual void getTargetBuiltins(const Builtin::Info *&Records,
2106                                    unsigned &NumRecords) const {}
2107     virtual const char *getClobbers() const {
2108       return "";
2109     }
2110     virtual const char *getVAListDeclaration() const {
2111       return "typedef void* __builtin_va_list;";
2112     }
2113     virtual void getGCCRegNames(const char * const *&Names,
2114                                 unsigned &NumNames) const {}
2115     virtual bool validateAsmConstraint(const char *&Name,
2116                                        TargetInfo::ConstraintInfo &info) const {
2117       return true;
2118     }
2119     virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2120                                   unsigned &NumAliases) const {}
2121   };
2122 }
2123
2124 namespace {
2125 class MipsTargetInfo : public TargetInfo {
2126   std::string ABI, CPU;
2127   static const TargetInfo::GCCRegAlias GCCRegAliases[];
2128   static const char * const GCCRegNames[];
2129 public:
2130   MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
2131     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2132                         "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2133   }
2134   virtual const char *getABI() const { return ABI.c_str(); }
2135   virtual bool setABI(const std::string &Name) {
2136
2137     if ((Name == "o32") || (Name == "eabi")) {
2138       ABI = Name;
2139       return true;
2140     } else
2141       return false;
2142   }
2143   virtual bool setCPU(const std::string &Name) {
2144     CPU = Name;
2145     return true;
2146   }
2147   void getDefaultFeatures(const std::string &CPU,
2148                           llvm::StringMap<bool> &Features) const {
2149     Features[ABI] = true;
2150     Features[CPU] = true;
2151   }
2152   virtual void getArchDefines(const LangOptions &Opts,
2153                                 MacroBuilder &Builder) const {
2154     if (ABI == "o32")
2155       Builder.defineMacro("__mips_o32");
2156     else if (ABI == "eabi")
2157       Builder.defineMacro("__mips_eabi");
2158   }
2159   virtual void getTargetDefines(const LangOptions &Opts,
2160                                 MacroBuilder &Builder) const {
2161     DefineStd(Builder, "mips", Opts);
2162     Builder.defineMacro("_mips");
2163     DefineStd(Builder, "MIPSEB", Opts);
2164     Builder.defineMacro("_MIPSEB");
2165     Builder.defineMacro("__REGISTER_PREFIX__", "");
2166     getArchDefines(Opts, Builder);
2167   }
2168   virtual void getTargetBuiltins(const Builtin::Info *&Records,
2169                                  unsigned &NumRecords) const {
2170     // FIXME: Implement!
2171   }
2172   virtual const char *getVAListDeclaration() const {
2173     return "typedef void* __builtin_va_list;";
2174   }
2175   virtual void getGCCRegNames(const char * const *&Names,
2176                               unsigned &NumNames) const;
2177   virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2178                                 unsigned &NumAliases) const;
2179   virtual bool validateAsmConstraint(const char *&Name,
2180                                      TargetInfo::ConstraintInfo &Info) const {
2181     switch (*Name) {
2182     default:
2183     case 'r': // CPU registers.
2184     case 'd': // Equivalent to "r" unless generating MIPS16 code.
2185     case 'y': // Equivalent to "r", backwards compatibility only.
2186     case 'f': // floating-point registers.
2187       Info.setAllowsRegister();
2188       return true;
2189     }
2190     return false;
2191   }
2192
2193   virtual const char *getClobbers() const {
2194     // FIXME: Implement!
2195     return "";
2196   }
2197 };
2198
2199 const char * const MipsTargetInfo::GCCRegNames[] = {
2200   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
2201   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
2202   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
2203   "$24",  "$25",  "$26",  "$27",  "$28",  "$sp",  "$fp",  "$31",
2204   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
2205   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2206   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2207   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2208   "hi",   "lo",   "",     "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2209   "$fcc5","$fcc6","$fcc7"
2210 };
2211
2212 void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2213                                        unsigned &NumNames) const {
2214   Names = GCCRegNames;
2215   NumNames = llvm::array_lengthof(GCCRegNames);
2216 }
2217
2218 const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2219   { { "at" },  "$1" },
2220   { { "v0" },  "$2" },
2221   { { "v1" },  "$3" },
2222   { { "a0" },  "$4" },
2223   { { "a1" },  "$5" },
2224   { { "a2" },  "$6" },
2225   { { "a3" },  "$7" },
2226   { { "t0" },  "$8" },
2227   { { "t1" },  "$9" },
2228   { { "t2" }, "$10" },
2229   { { "t3" }, "$11" },
2230   { { "t4" }, "$12" },
2231   { { "t5" }, "$13" },
2232   { { "t6" }, "$14" },
2233   { { "t7" }, "$15" },
2234   { { "s0" }, "$16" },
2235   { { "s1" }, "$17" },
2236   { { "s2" }, "$18" },
2237   { { "s3" }, "$19" },
2238   { { "s4" }, "$20" },
2239   { { "s5" }, "$21" },
2240   { { "s6" }, "$22" },
2241   { { "s7" }, "$23" },
2242   { { "t8" }, "$24" },
2243   { { "t9" }, "$25" },
2244   { { "k0" }, "$26" },
2245   { { "k1" }, "$27" },
2246   { { "gp" }, "$28" },
2247   { { "sp" }, "$29" },
2248   { { "fp" }, "$30" },
2249   { { "ra" }, "$31" }
2250 };
2251
2252 void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2253                                          unsigned &NumAliases) const {
2254   Aliases = GCCRegAliases;
2255   NumAliases = llvm::array_lengthof(GCCRegAliases);
2256 }
2257 } // end anonymous namespace.
2258
2259 namespace {
2260 class MipselTargetInfo : public MipsTargetInfo {
2261 public:
2262   MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2263     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2264                         "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2265   }
2266
2267   virtual void getTargetDefines(const LangOptions &Opts,
2268                                 MacroBuilder &Builder) const;
2269 };
2270
2271 void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
2272                                         MacroBuilder &Builder) const {
2273   DefineStd(Builder, "mips", Opts);
2274   Builder.defineMacro("_mips");
2275   DefineStd(Builder, "MIPSEL", Opts);
2276   Builder.defineMacro("_MIPSEL");
2277   Builder.defineMacro("__REGISTER_PREFIX__", "");
2278   getArchDefines(Opts, Builder);
2279 }
2280 } // end anonymous namespace.
2281
2282 //===----------------------------------------------------------------------===//
2283 // Driver code
2284 //===----------------------------------------------------------------------===//
2285
2286 static TargetInfo *AllocateTarget(const std::string &T) {
2287   llvm::Triple Triple(T);
2288   llvm::Triple::OSType os = Triple.getOS();
2289
2290   switch (Triple.getArch()) {
2291   default:
2292     return NULL;
2293
2294   case llvm::Triple::arm:
2295   case llvm::Triple::thumb:
2296     switch (os) {
2297     case llvm::Triple::Darwin:
2298       return new DarwinARMTargetInfo(T);
2299     case llvm::Triple::FreeBSD:
2300       return new FreeBSDTargetInfo<ARMTargetInfo>(T);
2301     default:
2302       return new ARMTargetInfo(T);
2303     }
2304
2305   case llvm::Triple::bfin:
2306     return new BlackfinTargetInfo(T);
2307
2308   case llvm::Triple::msp430:
2309     return new MSP430TargetInfo(T);
2310
2311   case llvm::Triple::mips:
2312     if (os == llvm::Triple::Psp)
2313       return new PSPTargetInfo<MipsTargetInfo>(T);
2314     if (os == llvm::Triple::Linux)
2315       return new LinuxTargetInfo<MipsTargetInfo>(T);
2316     return new MipsTargetInfo(T);
2317
2318   case llvm::Triple::mipsel:
2319     if (os == llvm::Triple::Psp)
2320       return new PSPTargetInfo<MipselTargetInfo>(T);
2321     if (os == llvm::Triple::Linux)
2322       return new LinuxTargetInfo<MipselTargetInfo>(T);
2323     return new MipselTargetInfo(T);
2324
2325   case llvm::Triple::pic16:
2326     return new PIC16TargetInfo(T);
2327
2328   case llvm::Triple::ppc:
2329     if (os == llvm::Triple::Darwin)
2330       return new DarwinTargetInfo<PPCTargetInfo>(T);
2331     else if (os == llvm::Triple::FreeBSD)
2332       return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
2333     return new PPC32TargetInfo(T);
2334
2335   case llvm::Triple::ppc64:
2336     if (os == llvm::Triple::Darwin)
2337       return new DarwinTargetInfo<PPC64TargetInfo>(T);
2338     else if (os == llvm::Triple::Lv2)
2339       return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
2340     else if (os == llvm::Triple::FreeBSD)
2341       return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
2342     return new PPC64TargetInfo(T);
2343
2344   case llvm::Triple::mblaze:
2345     return new MBlazeTargetInfo(T);
2346
2347   case llvm::Triple::sparc:
2348     if (os == llvm::Triple::AuroraUX)
2349       return new AuroraUXSparcV8TargetInfo(T);
2350     if (os == llvm::Triple::Solaris)
2351       return new SolarisSparcV8TargetInfo(T);
2352     return new SparcV8TargetInfo(T);
2353
2354   // FIXME: Need a real SPU target.
2355   case llvm::Triple::cellspu:
2356     return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2357
2358   case llvm::Triple::systemz:
2359     return new SystemZTargetInfo(T);
2360
2361   case llvm::Triple::tce:
2362     return new TCETargetInfo(T);
2363
2364   case llvm::Triple::x86:
2365     switch (os) {
2366     case llvm::Triple::AuroraUX:
2367       return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
2368     case llvm::Triple::Darwin:
2369       return new DarwinI386TargetInfo(T);
2370     case llvm::Triple::Linux:
2371       return new LinuxTargetInfo<X86_32TargetInfo>(T);
2372     case llvm::Triple::DragonFly:
2373       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2374     case llvm::Triple::NetBSD:
2375       return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2376     case llvm::Triple::OpenBSD:
2377       return new OpenBSDI386TargetInfo(T);
2378     case llvm::Triple::FreeBSD:
2379       return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2380     case llvm::Triple::Solaris:
2381       return new SolarisTargetInfo<X86_32TargetInfo>(T);
2382     case llvm::Triple::Cygwin:
2383       return new CygwinX86_32TargetInfo(T);
2384     case llvm::Triple::MinGW32:
2385       return new MinGWX86_32TargetInfo(T);
2386     case llvm::Triple::Win32:
2387       return new VisualStudioWindowsX86_32TargetInfo(T);
2388     case llvm::Triple::Haiku:
2389       return new HaikuX86_32TargetInfo(T);
2390     default:
2391       return new X86_32TargetInfo(T);
2392     }
2393
2394   case llvm::Triple::x86_64:
2395     switch (os) {
2396     case llvm::Triple::AuroraUX:
2397       return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
2398     case llvm::Triple::Darwin:
2399       return new DarwinX86_64TargetInfo(T);
2400     case llvm::Triple::Linux:
2401       return new LinuxTargetInfo<X86_64TargetInfo>(T);
2402     case llvm::Triple::DragonFly:
2403       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
2404     case llvm::Triple::NetBSD:
2405       return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2406     case llvm::Triple::OpenBSD:
2407       return new OpenBSDX86_64TargetInfo(T);
2408     case llvm::Triple::FreeBSD:
2409       return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2410     case llvm::Triple::Solaris:
2411       return new SolarisTargetInfo<X86_64TargetInfo>(T);
2412     case llvm::Triple::MinGW64:
2413       return new MinGWX86_64TargetInfo(T);
2414     case llvm::Triple::Win32:   // This is what Triple.h supports now.
2415       return new VisualStudioWindowsX86_64TargetInfo(T);
2416     default:
2417       return new X86_64TargetInfo(T);
2418     }
2419   }
2420 }
2421
2422 /// CreateTargetInfo - Return the target info object for the specified target
2423 /// triple.
2424 TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
2425                                          TargetOptions &Opts) {
2426   llvm::Triple Triple(Opts.Triple);
2427
2428   // Construct the target
2429   llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2430   if (!Target) {
2431     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2432     return 0;
2433   }
2434
2435   // Set the target CPU if specified.
2436   if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2437     Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2438     return 0;
2439   }
2440
2441   // Set the target ABI if specified.
2442   if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2443     Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2444     return 0;
2445   }
2446
2447   // Compute the default target features, we need the target to handle this
2448   // because features may have dependencies on one another.
2449   llvm::StringMap<bool> Features;
2450   Target->getDefaultFeatures(Opts.CPU, Features);
2451
2452   // Apply the user specified deltas.
2453   for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2454          ie = Opts.Features.end(); it != ie; ++it) {
2455     const char *Name = it->c_str();
2456
2457     // Apply the feature via the target.
2458     if ((Name[0] != '-' && Name[0] != '+') ||
2459         !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2460       Diags.Report(diag::err_target_invalid_feature) << Name;
2461       return 0;
2462     }
2463   }
2464
2465   // Add the features to the compile options.
2466   //
2467   // FIXME: If we are completely confident that we have the right set, we only
2468   // need to pass the minuses.
2469   Opts.Features.clear();
2470   for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2471          ie = Features.end(); it != ie; ++it)
2472     Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2473   Target->HandleTargetFeatures(Opts.Features);
2474
2475   return Target.take();
2476 }