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