lib/Support/Triple.cpp

   1 //===--- Triple.cpp - Target triple helper class --------------------------===//
   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 #include "llvm/ADT/Triple.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/SmallString.h"
  13 #include "llvm/ADT/StringSwitch.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include <cstring>
  16 using namespace llvm;
  17
  18 const char *Triple::getArchTypeName(ArchType Kind) {
  19   switch (Kind) {
  20   case UnknownArch: return "unknown";
  21
  22   case aarch64: return "aarch64";
  23   case arm:     return "arm";
  24   case hexagon: return "hexagon";
  25   case mips:    return "mips";
  26   case mipsel:  return "mipsel";
  27   case mips64:  return "mips64";
  28   case mips64el:return "mips64el";
  29   case msp430:  return "msp430";
  30   case ppc64:   return "powerpc64";
  31   case ppc:     return "powerpc";
  32   case r600:    return "r600";
  33   case sparc:   return "sparc";
  34   case sparcv9: return "sparcv9";
  35   case systemz: return "s390x";
  36   case tce:     return "tce";
  37   case thumb:   return "thumb";
  38   case x86:     return "i386";
  39   case x86_64:  return "x86_64";
  40   case xcore:   return "xcore";
  41   case mblaze:  return "mblaze";
  42   case nvptx:   return "nvptx";
  43   case nvptx64: return "nvptx64";
  44   case le32:    return "le32";
  45   case amdil:   return "amdil";
  46   case spir:    return "spir";
  47   case spir64:  return "spir64";
  48   }
  49
  50   llvm_unreachable("Invalid ArchType!");
  51 }
  52
  53 const char *Triple::getArchTypePrefix(ArchType Kind) {
  54   switch (Kind) {
  55   default:
  56     return 0;
  57
  58   case aarch64: return "aarch64";
  59
  60   case arm:
  61   case thumb:   return "arm";
  62
  63   case ppc64:
  64   case ppc:     return "ppc";
  65
  66   case mblaze:  return "mblaze";
  67
  68   case mips:
  69   case mipsel:
  70   case mips64:
  71   case mips64el:return "mips";
  72
  73   case hexagon: return "hexagon";
  74
  75   case r600:    return "r600";
  76
  77   case sparcv9:
  78   case sparc:   return "sparc";
  79
  80   case systemz: return "systemz";
  81
  82   case x86:
  83   case x86_64:  return "x86";
  84
  85   case xcore:   return "xcore";
  86
  87   case nvptx:   return "nvptx";
  88   case nvptx64: return "nvptx";
  89   case le32:    return "le32";
  90   case amdil:   return "amdil";
  91   case spir:    return "spir";
  92   case spir64:  return "spir";
  93   }
  94 }
  95
  96 const char *Triple::getVendorTypeName(VendorType Kind) {
  97   switch (Kind) {
  98   case UnknownVendor: return "unknown";
  99
 100   case Apple: return "apple";
 101   case PC: return "pc";
 102   case SCEI: return "scei";
 103   case BGP: return "bgp";
 104   case BGQ: return "bgq";
 105   case Freescale: return "fsl";
 106   case IBM: return "ibm";
 107   }
 108
 109   llvm_unreachable("Invalid VendorType!");
 110 }
 111
 112 const char *Triple::getOSTypeName(OSType Kind) {
 113   switch (Kind) {
 114   case UnknownOS: return "unknown";
 115
 116   case AuroraUX: return "auroraux";
 117   case Cygwin: return "cygwin";
 118   case Darwin: return "darwin";
 119   case DragonFly: return "dragonfly";
 120   case FreeBSD: return "freebsd";
 121   case IOS: return "ios";
 122   case KFreeBSD: return "kfreebsd";
 123   case Linux: return "linux";
 124   case Lv2: return "lv2";
 125   case MacOSX: return "macosx";
 126   case MinGW32: return "mingw32";
 127   case NetBSD: return "netbsd";
 128   case OpenBSD: return "openbsd";
 129   case Solaris: return "solaris";
 130   case Win32: return "win32";
 131   case Haiku: return "haiku";
 132   case Minix: return "minix";
 133   case RTEMS: return "rtems";
 134   case NaCl: return "nacl";
 135   case CNK: return "cnk";
 136   case Bitrig: return "bitrig";
 137   case AIX: return "aix";
 138   }
 139
 140   llvm_unreachable("Invalid OSType");
 141 }
 142
 143 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
 144   switch (Kind) {
 145   case UnknownEnvironment: return "unknown";
 146   case GNU: return "gnu";
 147   case GNUEABIHF: return "gnueabihf";
 148   case GNUEABI: return "gnueabi";
 149   case GNUX32: return "gnux32";
 150   case EABI: return "eabi";
 151   case MachO: return "macho";
 152   case Android: return "android";
 153   case ELF: return "elf";
 154   }
 155
 156   llvm_unreachable("Invalid EnvironmentType!");
 157 }
 158
 159 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
 160   return StringSwitch<Triple::ArchType>(Name)
 161     .Case("aarch64", aarch64)
 162     .Case("arm", arm)
 163     .Case("mips", mips)
 164     .Case("mipsel", mipsel)
 165     .Case("mips64", mips64)
 166     .Case("mips64el", mips64el)
 167     .Case("msp430", msp430)
 168     .Case("ppc64", ppc64)
 169     .Case("ppc32", ppc)
 170     .Case("ppc", ppc)
 171     .Case("mblaze", mblaze)
 172     .Case("r600", r600)
 173     .Case("hexagon", hexagon)
 174     .Case("sparc", sparc)
 175     .Case("sparcv9", sparcv9)
 176     .Case("systemz", systemz)
 177     .Case("tce", tce)
 178     .Case("thumb", thumb)
 179     .Case("x86", x86)
 180     .Case("x86-64", x86_64)
 181     .Case("xcore", xcore)
 182     .Case("nvptx", nvptx)
 183     .Case("nvptx64", nvptx64)
 184     .Case("le32", le32)
 185     .Case("amdil", amdil)
 186     .Case("spir", spir)
 187     .Case("spir64", spir64)
 188     .Default(UnknownArch);
 189 }
 190
 191 // Returns architecture name that is understood by the target assembler.
 192 const char *Triple::getArchNameForAssembler() {
 193   if (!isOSDarwin() && getVendor() != Triple::Apple)
 194     return NULL;
 195
 196   return StringSwitch<const char*>(getArchName())
 197     .Case("i386", "i386")
 198     .Case("x86_64", "x86_64")
 199     .Case("powerpc", "ppc")
 200     .Case("powerpc64", "ppc64")
 201     .Cases("mblaze", "microblaze", "mblaze")
 202     .Case("arm", "arm")
 203     .Cases("armv4t", "thumbv4t", "armv4t")
 204     .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5")
 205     .Cases("armv6", "thumbv6", "armv6")
 206     .Cases("armv7", "thumbv7", "armv7")
 207     .Case("r600", "r600")
 208     .Case("nvptx", "nvptx")
 209     .Case("nvptx64", "nvptx64")
 210     .Case("le32", "le32")
 211     .Case("amdil", "amdil")
 212     .Case("spir", "spir")
 213     .Case("spir64", "spir64")
 214     .Default(NULL);
 215 }
 216
 217 static Triple::ArchType parseArch(StringRef ArchName) {
 218   return StringSwitch<Triple::ArchType>(ArchName)
 219     .Cases("i386", "i486", "i586", "i686", Triple::x86)
 220     // FIXME: Do we need to support these?
 221     .Cases("i786", "i886", "i986", Triple::x86)
 222     .Cases("amd64", "x86_64", Triple::x86_64)
 223     .Case("powerpc", Triple::ppc)
 224     .Cases("powerpc64", "ppu", Triple::ppc64)
 225     .Case("mblaze", Triple::mblaze)
 226     .Case("aarch64", Triple::aarch64)
 227     .Cases("arm", "xscale", Triple::arm)
 228     // FIXME: It would be good to replace these with explicit names for all the
 229     // various suffixes supported.
 230     .StartsWith("armv", Triple::arm)
 231     .Case("thumb", Triple::thumb)
 232     .StartsWith("thumbv", Triple::thumb)
 233     .Case("msp430", Triple::msp430)
 234     .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
 235     .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
 236     .Cases("mips64", "mips64eb", Triple::mips64)
 237     .Case("mips64el", Triple::mips64el)
 238     .Case("r600", Triple::r600)
 239     .Case("hexagon", Triple::hexagon)
 240     .Case("s390x", Triple::systemz)
 241     .Case("sparc", Triple::sparc)
 242     .Cases("sparcv9", "sparc64", Triple::sparcv9)
 243     .Case("tce", Triple::tce)
 244     .Case("xcore", Triple::xcore)
 245     .Case("nvptx", Triple::nvptx)
 246     .Case("nvptx64", Triple::nvptx64)
 247     .Case("le32", Triple::le32)
 248     .Case("amdil", Triple::amdil)
 249     .Case("spir", Triple::spir)
 250     .Case("spir64", Triple::spir64)
 251     .Default(Triple::UnknownArch);
 252 }
 253
 254 static Triple::VendorType parseVendor(StringRef VendorName) {
 255   return StringSwitch<Triple::VendorType>(VendorName)
 256     .Case("apple", Triple::Apple)
 257     .Case("pc", Triple::PC)
 258     .Case("scei", Triple::SCEI)
 259     .Case("bgp", Triple::BGP)
 260     .Case("bgq", Triple::BGQ)
 261     .Case("fsl", Triple::Freescale)
 262     .Case("ibm", Triple::IBM)
 263     .Default(Triple::UnknownVendor);
 264 }
 265
 266 static Triple::OSType parseOS(StringRef OSName) {
 267   return StringSwitch<Triple::OSType>(OSName)
 268     .StartsWith("auroraux", Triple::AuroraUX)
 269     .StartsWith("cygwin", Triple::Cygwin)
 270     .StartsWith("darwin", Triple::Darwin)
 271     .StartsWith("dragonfly", Triple::DragonFly)
 272     .StartsWith("freebsd", Triple::FreeBSD)
 273     .StartsWith("ios", Triple::IOS)
 274     .StartsWith("kfreebsd", Triple::KFreeBSD)
 275     .StartsWith("linux", Triple::Linux)
 276     .StartsWith("lv2", Triple::Lv2)
 277     .StartsWith("macosx", Triple::MacOSX)
 278     .StartsWith("mingw32", Triple::MinGW32)
 279     .StartsWith("netbsd", Triple::NetBSD)
 280     .StartsWith("openbsd", Triple::OpenBSD)
 281     .StartsWith("solaris", Triple::Solaris)
 282     .StartsWith("win32", Triple::Win32)
 283     .StartsWith("haiku", Triple::Haiku)
 284     .StartsWith("minix", Triple::Minix)
 285     .StartsWith("rtems", Triple::RTEMS)
 286     .StartsWith("nacl", Triple::NaCl)
 287     .StartsWith("cnk", Triple::CNK)
 288     .StartsWith("bitrig", Triple::Bitrig)
 289     .StartsWith("aix", Triple::AIX)
 290     .Default(Triple::UnknownOS);
 291 }
 292
 293 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
 294   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
 295     .StartsWith("eabi", Triple::EABI)
 296     .StartsWith("gnueabihf", Triple::GNUEABIHF)
 297     .StartsWith("gnueabi", Triple::GNUEABI)
 298     .StartsWith("gnux32", Triple::GNUX32)
 299     .StartsWith("gnu", Triple::GNU)
 300     .StartsWith("macho", Triple::MachO)
 301     .StartsWith("android", Triple::Android)
 302     .StartsWith("elf", Triple::ELF)
 303     .Default(Triple::UnknownEnvironment);
 304 }
 305
 306 /// \brief Construct a triple from the string representation provided.
 307 ///
 308 /// This stores the string representation and parses the various pieces into
 309 /// enum members.
 310 Triple::Triple(const Twine &Str)
 311     : Data(Str.str()),
 312       Arch(parseArch(getArchName())),
 313       Vendor(parseVendor(getVendorName())),
 314       OS(parseOS(getOSName())),
 315       Environment(parseEnvironment(getEnvironmentName())) {
 316 }
 317
 318 /// \brief Construct a triple from string representations of the architecture,
 319 /// vendor, and OS.
 320 ///
 321 /// This joins each argument into a canonical string representation and parses
 322 /// them into enum members. It leaves the environment unknown and omits it from
 323 /// the string representation.
 324 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
 325     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
 326       Arch(parseArch(ArchStr.str())),
 327       Vendor(parseVendor(VendorStr.str())),
 328       OS(parseOS(OSStr.str())),
 329       Environment() {
 330 }
 331
 332 /// \brief Construct a triple from string representations of the architecture,
 333 /// vendor, OS, and environment.
 334 ///
 335 /// This joins each argument into a canonical string representation and parses
 336 /// them into enum members.
 337 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 338                const Twine &EnvironmentStr)
 339     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
 340             EnvironmentStr).str()),
 341       Arch(parseArch(ArchStr.str())),
 342       Vendor(parseVendor(VendorStr.str())),
 343       OS(parseOS(OSStr.str())),
 344       Environment(parseEnvironment(EnvironmentStr.str())) {
 345 }
 346
 347 std::string Triple::normalize(StringRef Str) {
 348   // Parse into components.
 349   SmallVector<StringRef, 4> Components;
 350   Str.split(Components, "-");
 351
 352   // If the first component corresponds to a known architecture, preferentially
 353   // use it for the architecture.  If the second component corresponds to a
 354   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
 355   // component movement when a component parses as (eg) both a valid arch and a
 356   // valid os.
 357   ArchType Arch = UnknownArch;
 358   if (Components.size() > 0)
 359     Arch = parseArch(Components[0]);
 360   VendorType Vendor = UnknownVendor;
 361   if (Components.size() > 1)
 362     Vendor = parseVendor(Components[1]);
 363   OSType OS = UnknownOS;
 364   if (Components.size() > 2)
 365     OS = parseOS(Components[2]);
 366   EnvironmentType Environment = UnknownEnvironment;
 367   if (Components.size() > 3)
 368     Environment = parseEnvironment(Components[3]);
 369
 370   // Note which components are already in their final position.  These will not
 371   // be moved.
 372   bool Found[4];
 373   Found[0] = Arch != UnknownArch;
 374   Found[1] = Vendor != UnknownVendor;
 375   Found[2] = OS != UnknownOS;
 376   Found[3] = Environment != UnknownEnvironment;
 377
 378   // If they are not there already, permute the components into their canonical
 379   // positions by seeing if they parse as a valid architecture, and if so moving
 380   // the component to the architecture position etc.
 381   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
 382     if (Found[Pos])
 383       continue; // Already in the canonical position.
 384
 385     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
 386       // Do not reparse any components that already matched.
 387       if (Idx < array_lengthof(Found) && Found[Idx])
 388         continue;
 389
 390       // Does this component parse as valid for the target position?
 391       bool Valid = false;
 392       StringRef Comp = Components[Idx];
 393       switch (Pos) {
 394       default: llvm_unreachable("unexpected component type!");
 395       case 0:
 396         Arch = parseArch(Comp);
 397         Valid = Arch != UnknownArch;
 398         break;
 399       case 1:
 400         Vendor = parseVendor(Comp);
 401         Valid = Vendor != UnknownVendor;
 402         break;
 403       case 2:
 404         OS = parseOS(Comp);
 405         Valid = OS != UnknownOS;
 406         break;
 407       case 3:
 408         Environment = parseEnvironment(Comp);
 409         Valid = Environment != UnknownEnvironment;
 410         break;
 411       }
 412       if (!Valid)
 413         continue; // Nope, try the next component.
 414
 415       // Move the component to the target position, pushing any non-fixed
 416       // components that are in the way to the right.  This tends to give
 417       // good results in the common cases of a forgotten vendor component
 418       // or a wrongly positioned environment.
 419       if (Pos < Idx) {
 420         // Insert left, pushing the existing components to the right.  For
 421         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
 422         StringRef CurrentComponent(""); // The empty component.
 423         // Replace the component we are moving with an empty component.
 424         std::swap(CurrentComponent, Components[Idx]);
 425         // Insert the component being moved at Pos, displacing any existing
 426         // components to the right.
 427         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
 428           // Skip over any fixed components.
 429           while (i < array_lengthof(Found) && Found[i])
 430             ++i;
 431           // Place the component at the new position, getting the component
 432           // that was at this position - it will be moved right.
 433           std::swap(CurrentComponent, Components[i]);
 434         }
 435       } else if (Pos > Idx) {
 436         // Push right by inserting empty components until the component at Idx
 437         // reaches the target position Pos.  For example, pc-a -> -pc-a when
 438         // moving pc to the second position.
 439         do {
 440           // Insert one empty component at Idx.
 441           StringRef CurrentComponent(""); // The empty component.
 442           for (unsigned i = Idx; i < Components.size();) {
 443             // Place the component at the new position, getting the component
 444             // that was at this position - it will be moved right.
 445             std::swap(CurrentComponent, Components[i]);
 446             // If it was placed on top of an empty component then we are done.
 447             if (CurrentComponent.empty())
 448               break;
 449             // Advance to the next component, skipping any fixed components.
 450             while (++i < array_lengthof(Found) && Found[i])
 451               ;
 452           }
 453           // The last component was pushed off the end - append it.
 454           if (!CurrentComponent.empty())
 455             Components.push_back(CurrentComponent);
 456
 457           // Advance Idx to the component's new position.
 458           while (++Idx < array_lengthof(Found) && Found[Idx])
 459             ;
 460         } while (Idx < Pos); // Add more until the final position is reached.
 461       }
 462       assert(Pos < Components.size() && Components[Pos] == Comp &&
 463              "Component moved wrong!");
 464       Found[Pos] = true;
 465       break;
 466     }
 467   }
 468
 469   // Special case logic goes here.  At this point Arch, Vendor and OS have the
 470   // correct values for the computed components.
 471
 472   // Stick the corrected components back together to form the normalized string.
 473   std::string Normalized;
 474   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 475     if (i) Normalized += '-';
 476     Normalized += Components[i];
 477   }
 478   return Normalized;
 479 }
 480
 481 StringRef Triple::getArchName() const {
 482   return StringRef(Data).split('-').first;           // Isolate first component
 483 }
 484
 485 StringRef Triple::getVendorName() const {
 486   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 487   return Tmp.split('-').first;                       // Isolate second component
 488 }
 489
 490 StringRef Triple::getOSName() const {
 491   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 492   Tmp = Tmp.split('-').second;                       // Strip second component
 493   return Tmp.split('-').first;                       // Isolate third component
 494 }
 495
 496 StringRef Triple::getEnvironmentName() const {
 497   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 498   Tmp = Tmp.split('-').second;                       // Strip second component
 499   return Tmp.split('-').second;                      // Strip third component
 500 }
 501
 502 StringRef Triple::getOSAndEnvironmentName() const {
 503   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 504   return Tmp.split('-').second;                      // Strip second component
 505 }
 506
 507 static unsigned EatNumber(StringRef &Str) {
 508   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 509   unsigned Result = 0;
 510
 511   do {
 512     // Consume the leading digit.
 513     Result = Result*10 + (Str[0] - '0');
 514
 515     // Eat the digit.
 516     Str = Str.substr(1);
 517   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 518
 519   return Result;
 520 }
 521
 522 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 523                           unsigned &Micro) const {
 524   StringRef OSName = getOSName();
 525
 526   // Assume that the OS portion of the triple starts with the canonical name.
 527   StringRef OSTypeName = getOSTypeName(getOS());
 528   if (OSName.startswith(OSTypeName))
 529     OSName = OSName.substr(OSTypeName.size());
 530
 531   // Any unset version defaults to 0.
 532   Major = Minor = Micro = 0;
 533
 534   // Parse up to three components.
 535   unsigned *Components[3] = { &Major, &Minor, &Micro };
 536   for (unsigned i = 0; i != 3; ++i) {
 537     if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
 538       break;
 539
 540     // Consume the leading number.
 541     *Components[i] = EatNumber(OSName);
 542
 543     // Consume the separator, if present.
 544     if (OSName.startswith("."))
 545       OSName = OSName.substr(1);
 546   }
 547 }
 548
 549 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
 550                               unsigned &Micro) const {
 551   getOSVersion(Major, Minor, Micro);
 552
 553   switch (getOS()) {
 554   default: llvm_unreachable("unexpected OS for Darwin triple");
 555   case Darwin:
 556     // Default to darwin8, i.e., MacOSX 10.4.
 557     if (Major == 0)
 558       Major = 8;
 559     // Darwin version numbers are skewed from OS X versions.
 560     if (Major < 4)
 561       return false;
 562     Micro = 0;
 563     Minor = Major - 4;
 564     Major = 10;
 565     break;
 566   case MacOSX:
 567     // Default to 10.4.
 568     if (Major == 0) {
 569       Major = 10;
 570       Minor = 4;
 571     }
 572     if (Major != 10)
 573       return false;
 574     break;
 575   case IOS:
 576     // Ignore the version from the triple.  This is only handled because the
 577     // the clang driver combines OS X and IOS support into a common Darwin
 578     // toolchain that wants to know the OS X version number even when targeting
 579     // IOS.
 580     Major = 10;
 581     Minor = 4;
 582     Micro = 0;
 583     break;
 584   }
 585   return true;
 586 }
 587
 588 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
 589                            unsigned &Micro) const {
 590   switch (getOS()) {
 591   default: llvm_unreachable("unexpected OS for Darwin triple");
 592   case Darwin:
 593   case MacOSX:
 594     // Ignore the version from the triple.  This is only handled because the
 595     // the clang driver combines OS X and IOS support into a common Darwin
 596     // toolchain that wants to know the iOS version number even when targeting
 597     // OS X.
 598     Major = 3;
 599     Minor = 0;
 600     Micro = 0;
 601     break;
 602   case IOS:
 603     getOSVersion(Major, Minor, Micro);
 604     // Default to 3.0.
 605     if (Major == 0)
 606       Major = 3;
 607     break;
 608   }
 609 }
 610
 611 void Triple::setTriple(const Twine &Str) {
 612   *this = Triple(Str);
 613 }
 614
 615 void Triple::setArch(ArchType Kind) {
 616   setArchName(getArchTypeName(Kind));
 617 }
 618
 619 void Triple::setVendor(VendorType Kind) {
 620   setVendorName(getVendorTypeName(Kind));
 621 }
 622
 623 void Triple::setOS(OSType Kind) {
 624   setOSName(getOSTypeName(Kind));
 625 }
 626
 627 void Triple::setEnvironment(EnvironmentType Kind) {
 628   setEnvironmentName(getEnvironmentTypeName(Kind));
 629 }
 630
 631 void Triple::setArchName(StringRef Str) {
 632   // Work around a miscompilation bug for Twines in gcc 4.0.3.
 633   SmallString<64> Triple;
 634   Triple += Str;
 635   Triple += "-";
 636   Triple += getVendorName();
 637   Triple += "-";
 638   Triple += getOSAndEnvironmentName();
 639   setTriple(Triple.str());
 640 }
 641
 642 void Triple::setVendorName(StringRef Str) {
 643   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
 644 }
 645
 646 void Triple::setOSName(StringRef Str) {
 647   if (hasEnvironment())
 648     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
 649               "-" + getEnvironmentName());
 650   else
 651     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 652 }
 653
 654 void Triple::setEnvironmentName(StringRef Str) {
 655   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
 656             "-" + Str);
 657 }
 658
 659 void Triple::setOSAndEnvironmentName(StringRef Str) {
 660   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 661 }
 662
 663 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
 664   switch (Arch) {
 665   case llvm::Triple::UnknownArch:
 666     return 0;
 667
 668   case llvm::Triple::msp430:
 669     return 16;
 670
 671   case llvm::Triple::amdil:
 672   case llvm::Triple::arm:
 673   case llvm::Triple::hexagon:
 674   case llvm::Triple::le32:
 675   case llvm::Triple::mblaze:
 676   case llvm::Triple::mips:
 677   case llvm::Triple::mipsel:
 678   case llvm::Triple::nvptx:
 679   case llvm::Triple::ppc:
 680   case llvm::Triple::r600:
 681   case llvm::Triple::sparc:
 682   case llvm::Triple::tce:
 683   case llvm::Triple::thumb:
 684   case llvm::Triple::x86:
 685   case llvm::Triple::xcore:
 686   case llvm::Triple::spir:
 687     return 32;
 688
 689   case llvm::Triple::aarch64:
 690   case llvm::Triple::mips64:
 691   case llvm::Triple::mips64el:
 692   case llvm::Triple::nvptx64:
 693   case llvm::Triple::ppc64:
 694   case llvm::Triple::sparcv9:
 695   case llvm::Triple::systemz:
 696   case llvm::Triple::x86_64:
 697   case llvm::Triple::spir64:
 698     return 64;
 699   }
 700   llvm_unreachable("Invalid architecture value");
 701 }
 702
 703 bool Triple::isArch64Bit() const {
 704   return getArchPointerBitWidth(getArch()) == 64;
 705 }
 706
 707 bool Triple::isArch32Bit() const {
 708   return getArchPointerBitWidth(getArch()) == 32;
 709 }
 710
 711 bool Triple::isArch16Bit() const {
 712   return getArchPointerBitWidth(getArch()) == 16;
 713 }
 714
 715 Triple Triple::get32BitArchVariant() const {
 716   Triple T(*this);
 717   switch (getArch()) {
 718   case Triple::UnknownArch:
 719   case Triple::aarch64:
 720   case Triple::msp430:
 721   case Triple::systemz:
 722     T.setArch(UnknownArch);
 723     break;
 724
 725   case Triple::amdil:
 726   case Triple::spir:
 727   case Triple::arm:
 728   case Triple::hexagon:
 729   case Triple::le32:
 730   case Triple::mblaze:
 731   case Triple::mips:
 732   case Triple::mipsel:
 733   case Triple::nvptx:
 734   case Triple::ppc:
 735   case Triple::r600:
 736   case Triple::sparc:
 737   case Triple::tce:
 738   case Triple::thumb:
 739   case Triple::x86:
 740   case Triple::xcore:
 741     // Already 32-bit.
 742     break;
 743
 744   case Triple::mips64:    T.setArch(Triple::mips);    break;
 745   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
 746   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
 747   case Triple::ppc64:     T.setArch(Triple::ppc);   break;
 748   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
 749   case Triple::x86_64:    T.setArch(Triple::x86);     break;
 750   case Triple::spir64:    T.setArch(Triple::spir);    break;
 751   }
 752   return T;
 753 }
 754
 755 Triple Triple::get64BitArchVariant() const {
 756   Triple T(*this);
 757   switch (getArch()) {
 758   case Triple::UnknownArch:
 759   case Triple::amdil:
 760   case Triple::arm:
 761   case Triple::hexagon:
 762   case Triple::le32:
 763   case Triple::mblaze:
 764   case Triple::msp430:
 765   case Triple::r600:
 766   case Triple::tce:
 767   case Triple::thumb:
 768   case Triple::xcore:
 769     T.setArch(UnknownArch);
 770     break;
 771
 772   case Triple::aarch64:
 773   case Triple::spir64:
 774   case Triple::mips64:
 775   case Triple::mips64el:
 776   case Triple::nvptx64:
 777   case Triple::ppc64:
 778   case Triple::sparcv9:
 779   case Triple::systemz:
 780   case Triple::x86_64:
 781     // Already 64-bit.
 782     break;
 783
 784   case Triple::mips:    T.setArch(Triple::mips64);    break;
 785   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
 786   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
 787   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
 788   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
 789   case Triple::x86:     T.setArch(Triple::x86_64);    break;
 790   case Triple::spir:    T.setArch(Triple::spir64);    break;
 791   }
 792   return T;
 793 }