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