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