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 "llvm/Support/TargetParser.h"
  16 #include <cstring>
  17 using namespace llvm;
  18
  19 const char *Triple::getArchTypeName(ArchType Kind) {
  20   switch (Kind) {
  21   case UnknownArch: return "unknown";
  22
  23   case aarch64:     return "aarch64";
  24   case aarch64_be:  return "aarch64_be";
  25   case arm:         return "arm";
  26   case armeb:       return "armeb";
  27   case bpf:         return "bpf";
  28   case hexagon:     return "hexagon";
  29   case mips:        return "mips";
  30   case mipsel:      return "mipsel";
  31   case mips64:      return "mips64";
  32   case mips64el:    return "mips64el";
  33   case msp430:      return "msp430";
  34   case ppc64:       return "powerpc64";
  35   case ppc64le:     return "powerpc64le";
  36   case ppc:         return "powerpc";
  37   case r600:        return "r600";
  38   case amdgcn:      return "amdgcn";
  39   case sparc:       return "sparc";
  40   case sparcv9:     return "sparcv9";
  41   case sparcel:     return "sparcel";
  42   case systemz:     return "s390x";
  43   case tce:         return "tce";
  44   case thumb:       return "thumb";
  45   case thumbeb:     return "thumbeb";
  46   case x86:         return "i386";
  47   case x86_64:      return "x86_64";
  48   case xcore:       return "xcore";
  49   case nvptx:       return "nvptx";
  50   case nvptx64:     return "nvptx64";
  51   case le32:        return "le32";
  52   case le64:        return "le64";
  53   case amdil:       return "amdil";
  54   case amdil64:     return "amdil64";
  55   case hsail:       return "hsail";
  56   case hsail64:     return "hsail64";
  57   case spir:        return "spir";
  58   case spir64:      return "spir64";
  59   case kalimba:     return "kalimba";
  60   }
  61
  62   llvm_unreachable("Invalid ArchType!");
  63 }
  64
  65 const char *Triple::getArchTypePrefix(ArchType Kind) {
  66   switch (Kind) {
  67   default:
  68     return nullptr;
  69
  70   case aarch64:
  71   case aarch64_be:  return "aarch64";
  72
  73   case arm:
  74   case armeb:
  75   case thumb:
  76   case thumbeb:     return "arm";
  77
  78   case ppc64:
  79   case ppc64le:
  80   case ppc:         return "ppc";
  81
  82   case mips:
  83   case mipsel:
  84   case mips64:
  85   case mips64el:    return "mips";
  86
  87   case hexagon:     return "hexagon";
  88
  89   case amdgcn:
  90   case r600:        return "amdgpu";
  91
  92   case bpf:         return "bpf";
  93
  94   case sparcv9:
  95   case sparcel:
  96   case sparc:       return "sparc";
  97
  98   case systemz:     return "s390";
  99
 100   case x86:
 101   case x86_64:      return "x86";
 102
 103   case xcore:       return "xcore";
 104
 105   case nvptx:       return "nvptx";
 106   case nvptx64:     return "nvptx";
 107
 108   case le32:        return "le32";
 109   case le64:        return "le64";
 110
 111   case amdil:
 112   case amdil64:     return "amdil";
 113
 114   case hsail:
 115   case hsail64:     return "hsail";
 116
 117   case spir:
 118   case spir64:      return "spir";
 119   case kalimba:     return "kalimba";
 120   }
 121 }
 122
 123 const char *Triple::getVendorTypeName(VendorType Kind) {
 124   switch (Kind) {
 125   case UnknownVendor: return "unknown";
 126
 127   case Apple: return "apple";
 128   case PC: return "pc";
 129   case SCEI: return "scei";
 130   case BGP: return "bgp";
 131   case BGQ: return "bgq";
 132   case Freescale: return "fsl";
 133   case IBM: return "ibm";
 134   case ImaginationTechnologies: return "img";
 135   case MipsTechnologies: return "mti";
 136   case NVIDIA: return "nvidia";
 137   case CSR: return "csr";
 138   }
 139
 140   llvm_unreachable("Invalid VendorType!");
 141 }
 142
 143 const char *Triple::getOSTypeName(OSType Kind) {
 144   switch (Kind) {
 145   case UnknownOS: return "unknown";
 146
 147   case CloudABI: return "cloudabi";
 148   case Darwin: return "darwin";
 149   case DragonFly: return "dragonfly";
 150   case FreeBSD: return "freebsd";
 151   case IOS: return "ios";
 152   case KFreeBSD: return "kfreebsd";
 153   case Linux: return "linux";
 154   case Lv2: return "lv2";
 155   case MacOSX: return "macosx";
 156   case NetBSD: return "netbsd";
 157   case OpenBSD: return "openbsd";
 158   case Solaris: return "solaris";
 159   case Win32: return "windows";
 160   case Haiku: return "haiku";
 161   case Minix: return "minix";
 162   case RTEMS: return "rtems";
 163   case NaCl: return "nacl";
 164   case CNK: return "cnk";
 165   case Bitrig: return "bitrig";
 166   case AIX: return "aix";
 167   case CUDA: return "cuda";
 168   case NVCL: return "nvcl";
 169   case AMDHSA: return "amdhsa";
 170   case PS4: return "ps4";
 171   }
 172
 173   llvm_unreachable("Invalid OSType");
 174 }
 175
 176 const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
 177   switch (Kind) {
 178   case UnknownEnvironment: return "unknown";
 179   case GNU: return "gnu";
 180   case GNUEABIHF: return "gnueabihf";
 181   case GNUEABI: return "gnueabi";
 182   case GNUX32: return "gnux32";
 183   case CODE16: return "code16";
 184   case EABI: return "eabi";
 185   case EABIHF: return "eabihf";
 186   case Android: return "android";
 187   case MSVC: return "msvc";
 188   case Itanium: return "itanium";
 189   case Cygnus: return "cygnus";
 190   }
 191
 192   llvm_unreachable("Invalid EnvironmentType!");
 193 }
 194
 195 Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) {
 196   return StringSwitch<Triple::ArchType>(Name)
 197     .Case("aarch64", aarch64)
 198     .Case("aarch64_be", aarch64_be)
 199     .Case("arm64", aarch64) // "arm64" is an alias for "aarch64"
 200     .Case("arm", arm)
 201     .Case("armeb", armeb)
 202     .Case("bpf", bpf)
 203     .Case("mips", mips)
 204     .Case("mipsel", mipsel)
 205     .Case("mips64", mips64)
 206     .Case("mips64el", mips64el)
 207     .Case("msp430", msp430)
 208     .Case("ppc64", ppc64)
 209     .Case("ppc32", ppc)
 210     .Case("ppc", ppc)
 211     .Case("ppc64le", ppc64le)
 212     .Case("r600", r600)
 213     .Case("amdgcn", amdgcn)
 214     .Case("hexagon", hexagon)
 215     .Case("sparc", sparc)
 216     .Case("sparcel", sparcel)
 217     .Case("sparcv9", sparcv9)
 218     .Case("systemz", systemz)
 219     .Case("tce", tce)
 220     .Case("thumb", thumb)
 221     .Case("thumbeb", thumbeb)
 222     .Case("x86", x86)
 223     .Case("x86-64", x86_64)
 224     .Case("xcore", xcore)
 225     .Case("nvptx", nvptx)
 226     .Case("nvptx64", nvptx64)
 227     .Case("le32", le32)
 228     .Case("le64", le64)
 229     .Case("amdil", amdil)
 230     .Case("amdil64", amdil64)
 231     .Case("hsail", hsail)
 232     .Case("hsail64", hsail64)
 233     .Case("spir", spir)
 234     .Case("spir64", spir64)
 235     .Case("kalimba", kalimba)
 236     .Default(UnknownArch);
 237 }
 238
 239 static Triple::ArchType parseARMArch(StringRef ArchName) {
 240   unsigned ISA = ARMTargetParser::parseArchISA(ArchName);
 241   unsigned ENDIAN = ARMTargetParser::parseArchEndian(ArchName);
 242
 243   Triple::ArchType arch = Triple::UnknownArch;
 244   switch (ENDIAN) {
 245   case ARM::EK_LITTLE: {
 246     switch (ISA) {
 247     case ARM::IK_ARM:
 248       arch = Triple::arm;
 249       break;
 250     case ARM::IK_THUMB:
 251       arch = Triple::thumb;
 252       break;
 253     case ARM::IK_AARCH64:
 254       arch = Triple::aarch64;
 255       break;
 256     }
 257     break;
 258   }
 259   case ARM::EK_BIG: {
 260     switch (ISA) {
 261     case ARM::IK_ARM:
 262       arch = Triple::armeb;
 263       break;
 264     case ARM::IK_THUMB:
 265       arch = Triple::thumbeb;
 266       break;
 267     case ARM::IK_AARCH64:
 268       arch = Triple::aarch64_be;
 269       break;
 270     }
 271     break;
 272   }
 273   }
 274
 275   ArchName = ARMTargetParser::getCanonicalArchName(ArchName);
 276   if (ArchName.empty())
 277     return Triple::UnknownArch;
 278
 279   // Thumb only exists in v4+
 280   if (ISA == ARM::IK_THUMB &&
 281       (ArchName.startswith("v2") || ArchName.startswith("v3")))
 282     return Triple::UnknownArch;
 283
 284   // Thumb only for v6m
 285   unsigned Profile = ARMTargetParser::parseArchProfile(ArchName);
 286   unsigned Version = ARMTargetParser::parseArchVersion(ArchName);
 287   if (Profile == ARM::PK_M && Version == 6) {
 288     if (ENDIAN == ARM::EK_BIG)
 289       return Triple::thumbeb;
 290     else
 291       return Triple::thumb;
 292   }
 293
 294   return arch;
 295 }
 296
 297 static Triple::ArchType parseArch(StringRef ArchName) {
 298   Triple::ArchType ARMArch(parseARMArch(ArchName));
 299
 300   return StringSwitch<Triple::ArchType>(ArchName)
 301     .Cases("i386", "i486", "i586", "i686", Triple::x86)
 302     // FIXME: Do we need to support these?
 303     .Cases("i786", "i886", "i986", Triple::x86)
 304     .Cases("amd64", "x86_64", "x86_64h", Triple::x86_64)
 305     .Case("powerpc", Triple::ppc)
 306     .Cases("powerpc64", "ppu", Triple::ppc64)
 307     .Case("powerpc64le", Triple::ppc64le)
 308     .Case("xscale", Triple::arm)
 309     .Case("xscaleeb", Triple::armeb)
 310     .StartsWith("arm", ARMArch)
 311     .StartsWith("thumb", ARMArch)
 312     .StartsWith("aarch64", ARMArch)
 313     .Case("msp430", Triple::msp430)
 314     .Cases("mips", "mipseb", "mipsallegrex", Triple::mips)
 315     .Cases("mipsel", "mipsallegrexel", Triple::mipsel)
 316     .Cases("mips64", "mips64eb", Triple::mips64)
 317     .Case("mips64el", Triple::mips64el)
 318     .Case("r600", Triple::r600)
 319     .Case("amdgcn", Triple::amdgcn)
 320     .Case("bpf", Triple::bpf)
 321     .Case("hexagon", Triple::hexagon)
 322     .Case("s390x", Triple::systemz)
 323     .Case("sparc", Triple::sparc)
 324     .Case("sparcel", Triple::sparcel)
 325     .Cases("sparcv9", "sparc64", Triple::sparcv9)
 326     .Case("tce", Triple::tce)
 327     .Case("xcore", Triple::xcore)
 328     .Case("nvptx", Triple::nvptx)
 329     .Case("nvptx64", Triple::nvptx64)
 330     .Case("le32", Triple::le32)
 331     .Case("le64", Triple::le64)
 332     .Case("amdil", Triple::amdil)
 333     .Case("amdil64", Triple::amdil64)
 334     .Case("hsail", Triple::hsail)
 335     .Case("hsail64", Triple::hsail64)
 336     .Case("spir", Triple::spir)
 337     .Case("spir64", Triple::spir64)
 338     .StartsWith("kalimba", Triple::kalimba)
 339     .Default(Triple::UnknownArch);
 340 }
 341
 342 static Triple::VendorType parseVendor(StringRef VendorName) {
 343   return StringSwitch<Triple::VendorType>(VendorName)
 344     .Case("apple", Triple::Apple)
 345     .Case("pc", Triple::PC)
 346     .Case("scei", Triple::SCEI)
 347     .Case("bgp", Triple::BGP)
 348     .Case("bgq", Triple::BGQ)
 349     .Case("fsl", Triple::Freescale)
 350     .Case("ibm", Triple::IBM)
 351     .Case("img", Triple::ImaginationTechnologies)
 352     .Case("mti", Triple::MipsTechnologies)
 353     .Case("nvidia", Triple::NVIDIA)
 354     .Case("csr", Triple::CSR)
 355     .Default(Triple::UnknownVendor);
 356 }
 357
 358 static Triple::OSType parseOS(StringRef OSName) {
 359   return StringSwitch<Triple::OSType>(OSName)
 360     .StartsWith("cloudabi", Triple::CloudABI)
 361     .StartsWith("darwin", Triple::Darwin)
 362     .StartsWith("dragonfly", Triple::DragonFly)
 363     .StartsWith("freebsd", Triple::FreeBSD)
 364     .StartsWith("ios", Triple::IOS)
 365     .StartsWith("kfreebsd", Triple::KFreeBSD)
 366     .StartsWith("linux", Triple::Linux)
 367     .StartsWith("lv2", Triple::Lv2)
 368     .StartsWith("macosx", Triple::MacOSX)
 369     .StartsWith("netbsd", Triple::NetBSD)
 370     .StartsWith("openbsd", Triple::OpenBSD)
 371     .StartsWith("solaris", Triple::Solaris)
 372     .StartsWith("win32", Triple::Win32)
 373     .StartsWith("windows", Triple::Win32)
 374     .StartsWith("haiku", Triple::Haiku)
 375     .StartsWith("minix", Triple::Minix)
 376     .StartsWith("rtems", Triple::RTEMS)
 377     .StartsWith("nacl", Triple::NaCl)
 378     .StartsWith("cnk", Triple::CNK)
 379     .StartsWith("bitrig", Triple::Bitrig)
 380     .StartsWith("aix", Triple::AIX)
 381     .StartsWith("cuda", Triple::CUDA)
 382     .StartsWith("nvcl", Triple::NVCL)
 383     .StartsWith("amdhsa", Triple::AMDHSA)
 384     .StartsWith("ps4", Triple::PS4)
 385     .Default(Triple::UnknownOS);
 386 }
 387
 388 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
 389   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
 390     .StartsWith("eabihf", Triple::EABIHF)
 391     .StartsWith("eabi", Triple::EABI)
 392     .StartsWith("gnueabihf", Triple::GNUEABIHF)
 393     .StartsWith("gnueabi", Triple::GNUEABI)
 394     .StartsWith("gnux32", Triple::GNUX32)
 395     .StartsWith("code16", Triple::CODE16)
 396     .StartsWith("gnu", Triple::GNU)
 397     .StartsWith("android", Triple::Android)
 398     .StartsWith("msvc", Triple::MSVC)
 399     .StartsWith("itanium", Triple::Itanium)
 400     .StartsWith("cygnus", Triple::Cygnus)
 401     .Default(Triple::UnknownEnvironment);
 402 }
 403
 404 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
 405   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
 406     .EndsWith("coff", Triple::COFF)
 407     .EndsWith("elf", Triple::ELF)
 408     .EndsWith("macho", Triple::MachO)
 409     .Default(Triple::UnknownObjectFormat);
 410 }
 411
 412 static Triple::SubArchType parseSubArch(StringRef SubArchName) {
 413   StringRef ARMSubArch = ARMTargetParser::getCanonicalArchName(SubArchName);
 414
 415   // For now, this is the small part. Early return.
 416   if (ARMSubArch.empty())
 417     return StringSwitch<Triple::SubArchType>(SubArchName)
 418       .EndsWith("kalimba3", Triple::KalimbaSubArch_v3)
 419       .EndsWith("kalimba4", Triple::KalimbaSubArch_v4)
 420       .EndsWith("kalimba5", Triple::KalimbaSubArch_v5)
 421       .Default(Triple::NoSubArch);
 422
 423   // ARM sub arch.
 424   switch(ARMTargetParser::parseArch(ARMSubArch)) {
 425   case ARM::AK_ARMV4:
 426     return Triple::NoSubArch;
 427   case ARM::AK_ARMV4T:
 428     return Triple::ARMSubArch_v4t;
 429   case ARM::AK_ARMV5:
 430   case ARM::AK_ARMV5T:
 431   case ARM::AK_ARMV5E:
 432     return Triple::ARMSubArch_v5;
 433   case ARM::AK_ARMV5TE:
 434   case ARM::AK_IWMMXT:
 435   case ARM::AK_IWMMXT2:
 436   case ARM::AK_XSCALE:
 437   case ARM::AK_ARMV5TEJ:
 438     return Triple::ARMSubArch_v5te;
 439   case ARM::AK_ARMV6:
 440   case ARM::AK_ARMV6J:
 441   case ARM::AK_ARMV6Z:
 442     return Triple::ARMSubArch_v6;
 443   case ARM::AK_ARMV6K:
 444   case ARM::AK_ARMV6ZK:
 445   case ARM::AK_ARMV6HL:
 446     return Triple::ARMSubArch_v6k;
 447   case ARM::AK_ARMV6T2:
 448     return Triple::ARMSubArch_v6t2;
 449   case ARM::AK_ARMV6M:
 450   case ARM::AK_ARMV6SM:
 451     return Triple::ARMSubArch_v6m;
 452   case ARM::AK_ARMV7:
 453   case ARM::AK_ARMV7A:
 454   case ARM::AK_ARMV7R:
 455   case ARM::AK_ARMV7L:
 456   case ARM::AK_ARMV7HL:
 457     return Triple::ARMSubArch_v7;
 458   case ARM::AK_ARMV7M:
 459     return Triple::ARMSubArch_v7m;
 460   case ARM::AK_ARMV7S:
 461     return Triple::ARMSubArch_v7s;
 462   case ARM::AK_ARMV7EM:
 463     return Triple::ARMSubArch_v7em;
 464   case ARM::AK_ARMV8A:
 465     return Triple::ARMSubArch_v8;
 466   case ARM::AK_ARMV8_1A:
 467     return Triple::ARMSubArch_v8_1a;
 468   default:
 469     return Triple::NoSubArch;
 470   }
 471 }
 472
 473 static const char *getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
 474   switch (Kind) {
 475   case Triple::UnknownObjectFormat: return "";
 476   case Triple::COFF: return "coff";
 477   case Triple::ELF: return "elf";
 478   case Triple::MachO: return "macho";
 479   }
 480   llvm_unreachable("unknown object format type");
 481 }
 482
 483 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
 484   switch (T.getArch()) {
 485   default:
 486     break;
 487   case Triple::hexagon:
 488   case Triple::mips:
 489   case Triple::mipsel:
 490   case Triple::mips64:
 491   case Triple::mips64el:
 492   case Triple::r600:
 493   case Triple::amdgcn:
 494   case Triple::sparc:
 495   case Triple::sparcv9:
 496   case Triple::systemz:
 497   case Triple::xcore:
 498   case Triple::ppc64le:
 499     return Triple::ELF;
 500
 501   case Triple::ppc:
 502   case Triple::ppc64:
 503     if (T.isOSDarwin())
 504       return Triple::MachO;
 505     return Triple::ELF;
 506   }
 507
 508   if (T.isOSDarwin())
 509     return Triple::MachO;
 510   else if (T.isOSWindows())
 511     return Triple::COFF;
 512   return Triple::ELF;
 513 }
 514
 515 /// \brief Construct a triple from the string representation provided.
 516 ///
 517 /// This stores the string representation and parses the various pieces into
 518 /// enum members.
 519 Triple::Triple(const Twine &Str)
 520     : Data(Str.str()),
 521       Arch(parseArch(getArchName())),
 522       SubArch(parseSubArch(getArchName())),
 523       Vendor(parseVendor(getVendorName())),
 524       OS(parseOS(getOSName())),
 525       Environment(parseEnvironment(getEnvironmentName())),
 526       ObjectFormat(parseFormat(getEnvironmentName())) {
 527   if (ObjectFormat == Triple::UnknownObjectFormat)
 528     ObjectFormat = getDefaultFormat(*this);
 529 }
 530
 531 /// \brief Construct a triple from string representations of the architecture,
 532 /// vendor, and OS.
 533 ///
 534 /// This joins each argument into a canonical string representation and parses
 535 /// them into enum members. It leaves the environment unknown and omits it from
 536 /// the string representation.
 537 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr)
 538     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()),
 539       Arch(parseArch(ArchStr.str())),
 540       SubArch(parseSubArch(ArchStr.str())),
 541       Vendor(parseVendor(VendorStr.str())),
 542       OS(parseOS(OSStr.str())),
 543       Environment(), ObjectFormat(Triple::UnknownObjectFormat) {
 544   ObjectFormat = getDefaultFormat(*this);
 545 }
 546
 547 /// \brief Construct a triple from string representations of the architecture,
 548 /// vendor, OS, and environment.
 549 ///
 550 /// This joins each argument into a canonical string representation and parses
 551 /// them into enum members.
 552 Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
 553                const Twine &EnvironmentStr)
 554     : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
 555             EnvironmentStr).str()),
 556       Arch(parseArch(ArchStr.str())),
 557       SubArch(parseSubArch(ArchStr.str())),
 558       Vendor(parseVendor(VendorStr.str())),
 559       OS(parseOS(OSStr.str())),
 560       Environment(parseEnvironment(EnvironmentStr.str())),
 561       ObjectFormat(parseFormat(EnvironmentStr.str())) {
 562   if (ObjectFormat == Triple::UnknownObjectFormat)
 563     ObjectFormat = getDefaultFormat(*this);
 564 }
 565
 566 std::string Triple::normalize(StringRef Str) {
 567   bool IsMinGW32 = false;
 568   bool IsCygwin = false;
 569
 570   // Parse into components.
 571   SmallVector<StringRef, 4> Components;
 572   Str.split(Components, "-");
 573
 574   // If the first component corresponds to a known architecture, preferentially
 575   // use it for the architecture.  If the second component corresponds to a
 576   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
 577   // component movement when a component parses as (eg) both a valid arch and a
 578   // valid os.
 579   ArchType Arch = UnknownArch;
 580   if (Components.size() > 0)
 581     Arch = parseArch(Components[0]);
 582   VendorType Vendor = UnknownVendor;
 583   if (Components.size() > 1)
 584     Vendor = parseVendor(Components[1]);
 585   OSType OS = UnknownOS;
 586   if (Components.size() > 2) {
 587     OS = parseOS(Components[2]);
 588     IsCygwin = Components[2].startswith("cygwin");
 589     IsMinGW32 = Components[2].startswith("mingw");
 590   }
 591   EnvironmentType Environment = UnknownEnvironment;
 592   if (Components.size() > 3)
 593     Environment = parseEnvironment(Components[3]);
 594   ObjectFormatType ObjectFormat = UnknownObjectFormat;
 595   if (Components.size() > 4)
 596     ObjectFormat = parseFormat(Components[4]);
 597
 598   // Note which components are already in their final position.  These will not
 599   // be moved.
 600   bool Found[4];
 601   Found[0] = Arch != UnknownArch;
 602   Found[1] = Vendor != UnknownVendor;
 603   Found[2] = OS != UnknownOS;
 604   Found[3] = Environment != UnknownEnvironment;
 605
 606   // If they are not there already, permute the components into their canonical
 607   // positions by seeing if they parse as a valid architecture, and if so moving
 608   // the component to the architecture position etc.
 609   for (unsigned Pos = 0; Pos != array_lengthof(Found); ++Pos) {
 610     if (Found[Pos])
 611       continue; // Already in the canonical position.
 612
 613     for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
 614       // Do not reparse any components that already matched.
 615       if (Idx < array_lengthof(Found) && Found[Idx])
 616         continue;
 617
 618       // Does this component parse as valid for the target position?
 619       bool Valid = false;
 620       StringRef Comp = Components[Idx];
 621       switch (Pos) {
 622       default: llvm_unreachable("unexpected component type!");
 623       case 0:
 624         Arch = parseArch(Comp);
 625         Valid = Arch != UnknownArch;
 626         break;
 627       case 1:
 628         Vendor = parseVendor(Comp);
 629         Valid = Vendor != UnknownVendor;
 630         break;
 631       case 2:
 632         OS = parseOS(Comp);
 633         IsCygwin = Comp.startswith("cygwin");
 634         IsMinGW32 = Comp.startswith("mingw");
 635         Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
 636         break;
 637       case 3:
 638         Environment = parseEnvironment(Comp);
 639         Valid = Environment != UnknownEnvironment;
 640         if (!Valid) {
 641           ObjectFormat = parseFormat(Comp);
 642           Valid = ObjectFormat != UnknownObjectFormat;
 643         }
 644         break;
 645       }
 646       if (!Valid)
 647         continue; // Nope, try the next component.
 648
 649       // Move the component to the target position, pushing any non-fixed
 650       // components that are in the way to the right.  This tends to give
 651       // good results in the common cases of a forgotten vendor component
 652       // or a wrongly positioned environment.
 653       if (Pos < Idx) {
 654         // Insert left, pushing the existing components to the right.  For
 655         // example, a-b-i386 -> i386-a-b when moving i386 to the front.
 656         StringRef CurrentComponent(""); // The empty component.
 657         // Replace the component we are moving with an empty component.
 658         std::swap(CurrentComponent, Components[Idx]);
 659         // Insert the component being moved at Pos, displacing any existing
 660         // components to the right.
 661         for (unsigned i = Pos; !CurrentComponent.empty(); ++i) {
 662           // Skip over any fixed components.
 663           while (i < array_lengthof(Found) && Found[i])
 664             ++i;
 665           // Place the component at the new position, getting the component
 666           // that was at this position - it will be moved right.
 667           std::swap(CurrentComponent, Components[i]);
 668         }
 669       } else if (Pos > Idx) {
 670         // Push right by inserting empty components until the component at Idx
 671         // reaches the target position Pos.  For example, pc-a -> -pc-a when
 672         // moving pc to the second position.
 673         do {
 674           // Insert one empty component at Idx.
 675           StringRef CurrentComponent(""); // The empty component.
 676           for (unsigned i = Idx; i < Components.size();) {
 677             // Place the component at the new position, getting the component
 678             // that was at this position - it will be moved right.
 679             std::swap(CurrentComponent, Components[i]);
 680             // If it was placed on top of an empty component then we are done.
 681             if (CurrentComponent.empty())
 682               break;
 683             // Advance to the next component, skipping any fixed components.
 684             while (++i < array_lengthof(Found) && Found[i])
 685               ;
 686           }
 687           // The last component was pushed off the end - append it.
 688           if (!CurrentComponent.empty())
 689             Components.push_back(CurrentComponent);
 690
 691           // Advance Idx to the component's new position.
 692           while (++Idx < array_lengthof(Found) && Found[Idx])
 693             ;
 694         } while (Idx < Pos); // Add more until the final position is reached.
 695       }
 696       assert(Pos < Components.size() && Components[Pos] == Comp &&
 697              "Component moved wrong!");
 698       Found[Pos] = true;
 699       break;
 700     }
 701   }
 702
 703   // Special case logic goes here.  At this point Arch, Vendor and OS have the
 704   // correct values for the computed components.
 705
 706   if (OS == Triple::Win32) {
 707     Components.resize(4);
 708     Components[2] = "windows";
 709     if (Environment == UnknownEnvironment) {
 710       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
 711         Components[3] = "msvc";
 712       else
 713         Components[3] = getObjectFormatTypeName(ObjectFormat);
 714     }
 715   } else if (IsMinGW32) {
 716     Components.resize(4);
 717     Components[2] = "windows";
 718     Components[3] = "gnu";
 719   } else if (IsCygwin) {
 720     Components.resize(4);
 721     Components[2] = "windows";
 722     Components[3] = "cygnus";
 723   }
 724   if (IsMinGW32 || IsCygwin ||
 725       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
 726     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
 727       Components.resize(5);
 728       Components[4] = getObjectFormatTypeName(ObjectFormat);
 729     }
 730   }
 731
 732   // Stick the corrected components back together to form the normalized string.
 733   std::string Normalized;
 734   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 735     if (i) Normalized += '-';
 736     Normalized += Components[i];
 737   }
 738   return Normalized;
 739 }
 740
 741 StringRef Triple::getArchName() const {
 742   return StringRef(Data).split('-').first;           // Isolate first component
 743 }
 744
 745 StringRef Triple::getVendorName() const {
 746   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 747   return Tmp.split('-').first;                       // Isolate second component
 748 }
 749
 750 StringRef Triple::getOSName() const {
 751   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 752   Tmp = Tmp.split('-').second;                       // Strip second component
 753   return Tmp.split('-').first;                       // Isolate third component
 754 }
 755
 756 StringRef Triple::getEnvironmentName() const {
 757   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 758   Tmp = Tmp.split('-').second;                       // Strip second component
 759   return Tmp.split('-').second;                      // Strip third component
 760 }
 761
 762 StringRef Triple::getOSAndEnvironmentName() const {
 763   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 764   return Tmp.split('-').second;                      // Strip second component
 765 }
 766
 767 static unsigned EatNumber(StringRef &Str) {
 768   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 769   unsigned Result = 0;
 770
 771   do {
 772     // Consume the leading digit.
 773     Result = Result*10 + (Str[0] - '0');
 774
 775     // Eat the digit.
 776     Str = Str.substr(1);
 777   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 778
 779   return Result;
 780 }
 781
 782 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 783                           unsigned &Micro) const {
 784   StringRef OSName = getOSName();
 785
 786   // For Android, we care about the Android version rather than the Linux
 787   // version.
 788   if (getEnvironment() == Android) {
 789     OSName = getEnvironmentName().substr(strlen("android"));
 790     if (OSName.startswith("eabi"))
 791       OSName = OSName.substr(strlen("eabi"));
 792   }
 793
 794   // Assume that the OS portion of the triple starts with the canonical name.
 795   StringRef OSTypeName = getOSTypeName(getOS());
 796   if (OSName.startswith(OSTypeName))
 797     OSName = OSName.substr(OSTypeName.size());
 798
 799   // Any unset version defaults to 0.
 800   Major = Minor = Micro = 0;
 801
 802   // Parse up to three components.
 803   unsigned *Components[3] = { &Major, &Minor, &Micro };
 804   for (unsigned i = 0; i != 3; ++i) {
 805     if (OSName.empty() || OSName[0] < '0' || OSName[0] > '9')
 806       break;
 807
 808     // Consume the leading number.
 809     *Components[i] = EatNumber(OSName);
 810
 811     // Consume the separator, if present.
 812     if (OSName.startswith("."))
 813       OSName = OSName.substr(1);
 814   }
 815 }
 816
 817 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
 818                               unsigned &Micro) const {
 819   getOSVersion(Major, Minor, Micro);
 820
 821   switch (getOS()) {
 822   default: llvm_unreachable("unexpected OS for Darwin triple");
 823   case Darwin:
 824     // Default to darwin8, i.e., MacOSX 10.4.
 825     if (Major == 0)
 826       Major = 8;
 827     // Darwin version numbers are skewed from OS X versions.
 828     if (Major < 4)
 829       return false;
 830     Micro = 0;
 831     Minor = Major - 4;
 832     Major = 10;
 833     break;
 834   case MacOSX:
 835     // Default to 10.4.
 836     if (Major == 0) {
 837       Major = 10;
 838       Minor = 4;
 839     }
 840     if (Major != 10)
 841       return false;
 842     break;
 843   case IOS:
 844     // Ignore the version from the triple.  This is only handled because the
 845     // the clang driver combines OS X and IOS support into a common Darwin
 846     // toolchain that wants to know the OS X version number even when targeting
 847     // IOS.
 848     Major = 10;
 849     Minor = 4;
 850     Micro = 0;
 851     break;
 852   }
 853   return true;
 854 }
 855
 856 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
 857                            unsigned &Micro) const {
 858   switch (getOS()) {
 859   default: llvm_unreachable("unexpected OS for Darwin triple");
 860   case Darwin:
 861   case MacOSX:
 862     // Ignore the version from the triple.  This is only handled because the
 863     // the clang driver combines OS X and IOS support into a common Darwin
 864     // toolchain that wants to know the iOS version number even when targeting
 865     // OS X.
 866     Major = 5;
 867     Minor = 0;
 868     Micro = 0;
 869     break;
 870   case IOS:
 871     getOSVersion(Major, Minor, Micro);
 872     // Default to 5.0 (or 7.0 for arm64).
 873     if (Major == 0)
 874       Major = (getArch() == aarch64) ? 7 : 5;
 875     break;
 876   }
 877 }
 878
 879 void Triple::setTriple(const Twine &Str) {
 880   *this = Triple(Str);
 881 }
 882
 883 void Triple::setArch(ArchType Kind) {
 884   setArchName(getArchTypeName(Kind));
 885 }
 886
 887 void Triple::setVendor(VendorType Kind) {
 888   setVendorName(getVendorTypeName(Kind));
 889 }
 890
 891 void Triple::setOS(OSType Kind) {
 892   setOSName(getOSTypeName(Kind));
 893 }
 894
 895 void Triple::setEnvironment(EnvironmentType Kind) {
 896   if (ObjectFormat == getDefaultFormat(*this))
 897     return setEnvironmentName(getEnvironmentTypeName(Kind));
 898
 899   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
 900                       getObjectFormatTypeName(ObjectFormat)).str());
 901 }
 902
 903 void Triple::setObjectFormat(ObjectFormatType Kind) {
 904   if (Environment == UnknownEnvironment)
 905     return setEnvironmentName(getObjectFormatTypeName(Kind));
 906
 907   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
 908                       getObjectFormatTypeName(Kind)).str());
 909 }
 910
 911 void Triple::setArchName(StringRef Str) {
 912   // Work around a miscompilation bug for Twines in gcc 4.0.3.
 913   SmallString<64> Triple;
 914   Triple += Str;
 915   Triple += "-";
 916   Triple += getVendorName();
 917   Triple += "-";
 918   Triple += getOSAndEnvironmentName();
 919   setTriple(Triple);
 920 }
 921
 922 void Triple::setVendorName(StringRef Str) {
 923   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
 924 }
 925
 926 void Triple::setOSName(StringRef Str) {
 927   if (hasEnvironment())
 928     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
 929               "-" + getEnvironmentName());
 930   else
 931     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 932 }
 933
 934 void Triple::setEnvironmentName(StringRef Str) {
 935   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
 936             "-" + Str);
 937 }
 938
 939 void Triple::setOSAndEnvironmentName(StringRef Str) {
 940   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 941 }
 942
 943 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
 944   switch (Arch) {
 945   case llvm::Triple::UnknownArch:
 946     return 0;
 947
 948   case llvm::Triple::msp430:
 949     return 16;
 950
 951   case llvm::Triple::arm:
 952   case llvm::Triple::armeb:
 953   case llvm::Triple::hexagon:
 954   case llvm::Triple::le32:
 955   case llvm::Triple::mips:
 956   case llvm::Triple::mipsel:
 957   case llvm::Triple::nvptx:
 958   case llvm::Triple::ppc:
 959   case llvm::Triple::r600:
 960   case llvm::Triple::sparc:
 961   case llvm::Triple::sparcel:
 962   case llvm::Triple::tce:
 963   case llvm::Triple::thumb:
 964   case llvm::Triple::thumbeb:
 965   case llvm::Triple::x86:
 966   case llvm::Triple::xcore:
 967   case llvm::Triple::amdil:
 968   case llvm::Triple::hsail:
 969   case llvm::Triple::spir:
 970   case llvm::Triple::kalimba:
 971     return 32;
 972
 973   case llvm::Triple::aarch64:
 974   case llvm::Triple::aarch64_be:
 975   case llvm::Triple::amdgcn:
 976   case llvm::Triple::bpf:
 977   case llvm::Triple::le64:
 978   case llvm::Triple::mips64:
 979   case llvm::Triple::mips64el:
 980   case llvm::Triple::nvptx64:
 981   case llvm::Triple::ppc64:
 982   case llvm::Triple::ppc64le:
 983   case llvm::Triple::sparcv9:
 984   case llvm::Triple::systemz:
 985   case llvm::Triple::x86_64:
 986   case llvm::Triple::amdil64:
 987   case llvm::Triple::hsail64:
 988   case llvm::Triple::spir64:
 989     return 64;
 990   }
 991   llvm_unreachable("Invalid architecture value");
 992 }
 993
 994 bool Triple::isArch64Bit() const {
 995   return getArchPointerBitWidth(getArch()) == 64;
 996 }
 997
 998 bool Triple::isArch32Bit() const {
 999   return getArchPointerBitWidth(getArch()) == 32;
1000 }
1001
1002 bool Triple::isArch16Bit() const {
1003   return getArchPointerBitWidth(getArch()) == 16;
1004 }
1005
1006 Triple Triple::get32BitArchVariant() const {
1007   Triple T(*this);
1008   switch (getArch()) {
1009   case Triple::UnknownArch:
1010   case Triple::aarch64:
1011   case Triple::aarch64_be:
1012   case Triple::amdgcn:
1013   case Triple::bpf:
1014   case Triple::msp430:
1015   case Triple::systemz:
1016   case Triple::ppc64le:
1017     T.setArch(UnknownArch);
1018     break;
1019
1020   case Triple::amdil:
1021   case Triple::hsail:
1022   case Triple::spir:
1023   case Triple::arm:
1024   case Triple::armeb:
1025   case Triple::hexagon:
1026   case Triple::kalimba:
1027   case Triple::le32:
1028   case Triple::mips:
1029   case Triple::mipsel:
1030   case Triple::nvptx:
1031   case Triple::ppc:
1032   case Triple::r600:
1033   case Triple::sparc:
1034   case Triple::sparcel:
1035   case Triple::tce:
1036   case Triple::thumb:
1037   case Triple::thumbeb:
1038   case Triple::x86:
1039   case Triple::xcore:
1040     // Already 32-bit.
1041     break;
1042
1043   case Triple::le64:      T.setArch(Triple::le32);    break;
1044   case Triple::mips64:    T.setArch(Triple::mips);    break;
1045   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
1046   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
1047   case Triple::ppc64:     T.setArch(Triple::ppc);     break;
1048   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
1049   case Triple::x86_64:    T.setArch(Triple::x86);     break;
1050   case Triple::amdil64:   T.setArch(Triple::amdil);   break;
1051   case Triple::hsail64:   T.setArch(Triple::hsail);   break;
1052   case Triple::spir64:    T.setArch(Triple::spir);    break;
1053   }
1054   return T;
1055 }
1056
1057 Triple Triple::get64BitArchVariant() const {
1058   Triple T(*this);
1059   switch (getArch()) {
1060   case Triple::UnknownArch:
1061   case Triple::arm:
1062   case Triple::armeb:
1063   case Triple::hexagon:
1064   case Triple::kalimba:
1065   case Triple::msp430:
1066   case Triple::r600:
1067   case Triple::tce:
1068   case Triple::thumb:
1069   case Triple::thumbeb:
1070   case Triple::xcore:
1071   case Triple::sparcel:
1072     T.setArch(UnknownArch);
1073     break;
1074
1075   case Triple::aarch64:
1076   case Triple::aarch64_be:
1077   case Triple::bpf:
1078   case Triple::le64:
1079   case Triple::amdil64:
1080   case Triple::amdgcn:
1081   case Triple::hsail64:
1082   case Triple::spir64:
1083   case Triple::mips64:
1084   case Triple::mips64el:
1085   case Triple::nvptx64:
1086   case Triple::ppc64:
1087   case Triple::ppc64le:
1088   case Triple::sparcv9:
1089   case Triple::systemz:
1090   case Triple::x86_64:
1091     // Already 64-bit.
1092     break;
1093
1094   case Triple::le32:    T.setArch(Triple::le64);      break;
1095   case Triple::mips:    T.setArch(Triple::mips64);    break;
1096   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
1097   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
1098   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
1099   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
1100   case Triple::x86:     T.setArch(Triple::x86_64);    break;
1101   case Triple::amdil:   T.setArch(Triple::amdil64);   break;
1102   case Triple::hsail:   T.setArch(Triple::hsail64);   break;
1103   case Triple::spir:    T.setArch(Triple::spir64);    break;
1104   }
1105   return T;
1106 }
1107
1108 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1109   if (MArch.empty())
1110     MArch = getArchName();
1111
1112   // Some defaults are forced.
1113   switch (getOS()) {
1114   case llvm::Triple::FreeBSD:
1115   case llvm::Triple::NetBSD:
1116     MArch = ARMTargetParser::getCanonicalArchName(MArch);
1117     if (!MArch.empty() && MArch == "v6")
1118       return "arm1176jzf-s";
1119     break;
1120   case llvm::Triple::Win32:
1121     // FIXME: this is invalid for WindowsCE
1122     return "cortex-a9";
1123   default:
1124     break;
1125   }
1126
1127   MArch = ARMTargetParser::getCanonicalArchName(MArch);
1128   if (MArch.empty())
1129     return nullptr;
1130
1131   const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1132   if (CPU)
1133     return CPU;
1134
1135   // If no specific architecture version is requested, return the minimum CPU
1136   // required by the OS and environment.
1137   switch (getOS()) {
1138   case llvm::Triple::NetBSD:
1139     switch (getEnvironment()) {
1140     case llvm::Triple::GNUEABIHF:
1141     case llvm::Triple::GNUEABI:
1142     case llvm::Triple::EABIHF:
1143     case llvm::Triple::EABI:
1144       return "arm926ej-s";
1145     default:
1146       return "strongarm";
1147     }
1148   case llvm::Triple::NaCl:
1149     return "cortex-a8";
1150   default:
1151     switch (getEnvironment()) {
1152     case llvm::Triple::EABIHF:
1153     case llvm::Triple::GNUEABIHF:
1154       return "arm1176jzf-s";
1155     default:
1156       return "arm7tdmi";
1157     }
1158   }
1159
1160   llvm_unreachable("invalid arch name");
1161 }