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   std::string NormalizedEnvironment;
 706   if (Environment == Triple::Android && Components[3].startswith("androideabi")) {
 707     StringRef AndroidVersion = Components[3].drop_front(strlen("androideabi"));
 708     if (AndroidVersion.empty()) {
 709       Components[3] = "android";
 710     } else {
 711       NormalizedEnvironment = Twine("android", AndroidVersion).str();
 712       Components[3] = NormalizedEnvironment;
 713     }
 714   }
 715
 716   if (OS == Triple::Win32) {
 717     Components.resize(4);
 718     Components[2] = "windows";
 719     if (Environment == UnknownEnvironment) {
 720       if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF)
 721         Components[3] = "msvc";
 722       else
 723         Components[3] = getObjectFormatTypeName(ObjectFormat);
 724     }
 725   } else if (IsMinGW32) {
 726     Components.resize(4);
 727     Components[2] = "windows";
 728     Components[3] = "gnu";
 729   } else if (IsCygwin) {
 730     Components.resize(4);
 731     Components[2] = "windows";
 732     Components[3] = "cygnus";
 733   }
 734   if (IsMinGW32 || IsCygwin ||
 735       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
 736     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
 737       Components.resize(5);
 738       Components[4] = getObjectFormatTypeName(ObjectFormat);
 739     }
 740   }
 741
 742   // Stick the corrected components back together to form the normalized string.
 743   std::string Normalized;
 744   for (unsigned i = 0, e = Components.size(); i != e; ++i) {
 745     if (i) Normalized += '-';
 746     Normalized += Components[i];
 747   }
 748   return Normalized;
 749 }
 750
 751 StringRef Triple::getArchName() const {
 752   return StringRef(Data).split('-').first;           // Isolate first component
 753 }
 754
 755 StringRef Triple::getVendorName() const {
 756   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 757   return Tmp.split('-').first;                       // Isolate second component
 758 }
 759
 760 StringRef Triple::getOSName() const {
 761   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 762   Tmp = Tmp.split('-').second;                       // Strip second component
 763   return Tmp.split('-').first;                       // Isolate third component
 764 }
 765
 766 StringRef Triple::getEnvironmentName() const {
 767   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 768   Tmp = Tmp.split('-').second;                       // Strip second component
 769   return Tmp.split('-').second;                      // Strip third component
 770 }
 771
 772 StringRef Triple::getOSAndEnvironmentName() const {
 773   StringRef Tmp = StringRef(Data).split('-').second; // Strip first component
 774   return Tmp.split('-').second;                      // Strip second component
 775 }
 776
 777 static unsigned EatNumber(StringRef &Str) {
 778   assert(!Str.empty() && Str[0] >= '0' && Str[0] <= '9' && "Not a number");
 779   unsigned Result = 0;
 780
 781   do {
 782     // Consume the leading digit.
 783     Result = Result*10 + (Str[0] - '0');
 784
 785     // Eat the digit.
 786     Str = Str.substr(1);
 787   } while (!Str.empty() && Str[0] >= '0' && Str[0] <= '9');
 788
 789   return Result;
 790 }
 791
 792 static void parseVersionFromName(StringRef Name, unsigned &Major,
 793                                  unsigned &Minor, unsigned &Micro) {
 794   // Any unset version defaults to 0.
 795   Major = Minor = Micro = 0;
 796
 797   // Parse up to three components.
 798   unsigned *Components[3] = {&Major, &Minor, &Micro};
 799   for (unsigned i = 0; i != 3; ++i) {
 800     if (Name.empty() || Name[0] < '0' || Name[0] > '9')
 801       break;
 802
 803     // Consume the leading number.
 804     *Components[i] = EatNumber(Name);
 805
 806     // Consume the separator, if present.
 807     if (Name.startswith("."))
 808       Name = Name.substr(1);
 809   }
 810 }
 811
 812 void Triple::getEnvironmentVersion(unsigned &Major, unsigned &Minor,
 813                                    unsigned &Micro) const {
 814   StringRef EnvironmentName = getEnvironmentName();
 815   StringRef EnvironmentTypeName = getEnvironmentTypeName(getEnvironment());
 816   if (EnvironmentName.startswith(EnvironmentTypeName))
 817     EnvironmentName = EnvironmentName.substr(EnvironmentTypeName.size());
 818   parseVersionFromName(EnvironmentName, Major, Minor, Micro);
 819 }
 820
 821 void Triple::getOSVersion(unsigned &Major, unsigned &Minor,
 822                           unsigned &Micro) const {
 823   StringRef OSName = getOSName();
 824
 825   // For Android, we care about the Android version rather than the Linux
 826   // version.
 827   if (getEnvironment() == Android) {
 828     OSName = getEnvironmentName().substr(strlen("android"));
 829     if (OSName.startswith("eabi"))
 830       OSName = OSName.substr(strlen("eabi"));
 831   }
 832
 833   // Assume that the OS portion of the triple starts with the canonical name.
 834   StringRef OSTypeName = getOSTypeName(getOS());
 835   if (OSName.startswith(OSTypeName))
 836     OSName = OSName.substr(OSTypeName.size());
 837
 838   parseVersionFromName(OSName, Major, Minor, Micro);
 839 }
 840
 841 bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor,
 842                               unsigned &Micro) const {
 843   getOSVersion(Major, Minor, Micro);
 844
 845   switch (getOS()) {
 846   default: llvm_unreachable("unexpected OS for Darwin triple");
 847   case Darwin:
 848     // Default to darwin8, i.e., MacOSX 10.4.
 849     if (Major == 0)
 850       Major = 8;
 851     // Darwin version numbers are skewed from OS X versions.
 852     if (Major < 4)
 853       return false;
 854     Micro = 0;
 855     Minor = Major - 4;
 856     Major = 10;
 857     break;
 858   case MacOSX:
 859     // Default to 10.4.
 860     if (Major == 0) {
 861       Major = 10;
 862       Minor = 4;
 863     }
 864     if (Major != 10)
 865       return false;
 866     break;
 867   case IOS:
 868     // Ignore the version from the triple.  This is only handled because the
 869     // the clang driver combines OS X and IOS support into a common Darwin
 870     // toolchain that wants to know the OS X version number even when targeting
 871     // IOS.
 872     Major = 10;
 873     Minor = 4;
 874     Micro = 0;
 875     break;
 876   }
 877   return true;
 878 }
 879
 880 void Triple::getiOSVersion(unsigned &Major, unsigned &Minor,
 881                            unsigned &Micro) const {
 882   switch (getOS()) {
 883   default: llvm_unreachable("unexpected OS for Darwin triple");
 884   case Darwin:
 885   case MacOSX:
 886     // Ignore the version from the triple.  This is only handled because the
 887     // the clang driver combines OS X and IOS support into a common Darwin
 888     // toolchain that wants to know the iOS version number even when targeting
 889     // OS X.
 890     Major = 5;
 891     Minor = 0;
 892     Micro = 0;
 893     break;
 894   case IOS:
 895     getOSVersion(Major, Minor, Micro);
 896     // Default to 5.0 (or 7.0 for arm64).
 897     if (Major == 0)
 898       Major = (getArch() == aarch64) ? 7 : 5;
 899     break;
 900   }
 901 }
 902
 903 void Triple::setTriple(const Twine &Str) {
 904   *this = Triple(Str);
 905 }
 906
 907 void Triple::setArch(ArchType Kind) {
 908   setArchName(getArchTypeName(Kind));
 909 }
 910
 911 void Triple::setVendor(VendorType Kind) {
 912   setVendorName(getVendorTypeName(Kind));
 913 }
 914
 915 void Triple::setOS(OSType Kind) {
 916   setOSName(getOSTypeName(Kind));
 917 }
 918
 919 void Triple::setEnvironment(EnvironmentType Kind) {
 920   if (ObjectFormat == getDefaultFormat(*this))
 921     return setEnvironmentName(getEnvironmentTypeName(Kind));
 922
 923   setEnvironmentName((getEnvironmentTypeName(Kind) + Twine("-") +
 924                       getObjectFormatTypeName(ObjectFormat)).str());
 925 }
 926
 927 void Triple::setObjectFormat(ObjectFormatType Kind) {
 928   if (Environment == UnknownEnvironment)
 929     return setEnvironmentName(getObjectFormatTypeName(Kind));
 930
 931   setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") +
 932                       getObjectFormatTypeName(Kind)).str());
 933 }
 934
 935 void Triple::setArchName(StringRef Str) {
 936   // Work around a miscompilation bug for Twines in gcc 4.0.3.
 937   SmallString<64> Triple;
 938   Triple += Str;
 939   Triple += "-";
 940   Triple += getVendorName();
 941   Triple += "-";
 942   Triple += getOSAndEnvironmentName();
 943   setTriple(Triple);
 944 }
 945
 946 void Triple::setVendorName(StringRef Str) {
 947   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
 948 }
 949
 950 void Triple::setOSName(StringRef Str) {
 951   if (hasEnvironment())
 952     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
 953               "-" + getEnvironmentName());
 954   else
 955     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 956 }
 957
 958 void Triple::setEnvironmentName(StringRef Str) {
 959   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
 960             "-" + Str);
 961 }
 962
 963 void Triple::setOSAndEnvironmentName(StringRef Str) {
 964   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 965 }
 966
 967 static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {
 968   switch (Arch) {
 969   case llvm::Triple::UnknownArch:
 970     return 0;
 971
 972   case llvm::Triple::msp430:
 973     return 16;
 974
 975   case llvm::Triple::arm:
 976   case llvm::Triple::armeb:
 977   case llvm::Triple::hexagon:
 978   case llvm::Triple::le32:
 979   case llvm::Triple::mips:
 980   case llvm::Triple::mipsel:
 981   case llvm::Triple::nvptx:
 982   case llvm::Triple::ppc:
 983   case llvm::Triple::r600:
 984   case llvm::Triple::sparc:
 985   case llvm::Triple::sparcel:
 986   case llvm::Triple::tce:
 987   case llvm::Triple::thumb:
 988   case llvm::Triple::thumbeb:
 989   case llvm::Triple::x86:
 990   case llvm::Triple::xcore:
 991   case llvm::Triple::amdil:
 992   case llvm::Triple::hsail:
 993   case llvm::Triple::spir:
 994   case llvm::Triple::kalimba:
 995     return 32;
 996
 997   case llvm::Triple::aarch64:
 998   case llvm::Triple::aarch64_be:
 999   case llvm::Triple::amdgcn:
1000   case llvm::Triple::bpf:
1001   case llvm::Triple::le64:
1002   case llvm::Triple::mips64:
1003   case llvm::Triple::mips64el:
1004   case llvm::Triple::nvptx64:
1005   case llvm::Triple::ppc64:
1006   case llvm::Triple::ppc64le:
1007   case llvm::Triple::sparcv9:
1008   case llvm::Triple::systemz:
1009   case llvm::Triple::x86_64:
1010   case llvm::Triple::amdil64:
1011   case llvm::Triple::hsail64:
1012   case llvm::Triple::spir64:
1013     return 64;
1014   }
1015   llvm_unreachable("Invalid architecture value");
1016 }
1017
1018 bool Triple::isArch64Bit() const {
1019   return getArchPointerBitWidth(getArch()) == 64;
1020 }
1021
1022 bool Triple::isArch32Bit() const {
1023   return getArchPointerBitWidth(getArch()) == 32;
1024 }
1025
1026 bool Triple::isArch16Bit() const {
1027   return getArchPointerBitWidth(getArch()) == 16;
1028 }
1029
1030 Triple Triple::get32BitArchVariant() const {
1031   Triple T(*this);
1032   switch (getArch()) {
1033   case Triple::UnknownArch:
1034   case Triple::aarch64:
1035   case Triple::aarch64_be:
1036   case Triple::amdgcn:
1037   case Triple::bpf:
1038   case Triple::msp430:
1039   case Triple::systemz:
1040   case Triple::ppc64le:
1041     T.setArch(UnknownArch);
1042     break;
1043
1044   case Triple::amdil:
1045   case Triple::hsail:
1046   case Triple::spir:
1047   case Triple::arm:
1048   case Triple::armeb:
1049   case Triple::hexagon:
1050   case Triple::kalimba:
1051   case Triple::le32:
1052   case Triple::mips:
1053   case Triple::mipsel:
1054   case Triple::nvptx:
1055   case Triple::ppc:
1056   case Triple::r600:
1057   case Triple::sparc:
1058   case Triple::sparcel:
1059   case Triple::tce:
1060   case Triple::thumb:
1061   case Triple::thumbeb:
1062   case Triple::x86:
1063   case Triple::xcore:
1064     // Already 32-bit.
1065     break;
1066
1067   case Triple::le64:      T.setArch(Triple::le32);    break;
1068   case Triple::mips64:    T.setArch(Triple::mips);    break;
1069   case Triple::mips64el:  T.setArch(Triple::mipsel);  break;
1070   case Triple::nvptx64:   T.setArch(Triple::nvptx);   break;
1071   case Triple::ppc64:     T.setArch(Triple::ppc);     break;
1072   case Triple::sparcv9:   T.setArch(Triple::sparc);   break;
1073   case Triple::x86_64:    T.setArch(Triple::x86);     break;
1074   case Triple::amdil64:   T.setArch(Triple::amdil);   break;
1075   case Triple::hsail64:   T.setArch(Triple::hsail);   break;
1076   case Triple::spir64:    T.setArch(Triple::spir);    break;
1077   }
1078   return T;
1079 }
1080
1081 Triple Triple::get64BitArchVariant() const {
1082   Triple T(*this);
1083   switch (getArch()) {
1084   case Triple::UnknownArch:
1085   case Triple::arm:
1086   case Triple::armeb:
1087   case Triple::hexagon:
1088   case Triple::kalimba:
1089   case Triple::msp430:
1090   case Triple::r600:
1091   case Triple::tce:
1092   case Triple::thumb:
1093   case Triple::thumbeb:
1094   case Triple::xcore:
1095   case Triple::sparcel:
1096     T.setArch(UnknownArch);
1097     break;
1098
1099   case Triple::aarch64:
1100   case Triple::aarch64_be:
1101   case Triple::bpf:
1102   case Triple::le64:
1103   case Triple::amdil64:
1104   case Triple::amdgcn:
1105   case Triple::hsail64:
1106   case Triple::spir64:
1107   case Triple::mips64:
1108   case Triple::mips64el:
1109   case Triple::nvptx64:
1110   case Triple::ppc64:
1111   case Triple::ppc64le:
1112   case Triple::sparcv9:
1113   case Triple::systemz:
1114   case Triple::x86_64:
1115     // Already 64-bit.
1116     break;
1117
1118   case Triple::le32:    T.setArch(Triple::le64);      break;
1119   case Triple::mips:    T.setArch(Triple::mips64);    break;
1120   case Triple::mipsel:  T.setArch(Triple::mips64el);  break;
1121   case Triple::nvptx:   T.setArch(Triple::nvptx64);   break;
1122   case Triple::ppc:     T.setArch(Triple::ppc64);     break;
1123   case Triple::sparc:   T.setArch(Triple::sparcv9);   break;
1124   case Triple::x86:     T.setArch(Triple::x86_64);    break;
1125   case Triple::amdil:   T.setArch(Triple::amdil64);   break;
1126   case Triple::hsail:   T.setArch(Triple::hsail64);   break;
1127   case Triple::spir:    T.setArch(Triple::spir64);    break;
1128   }
1129   return T;
1130 }
1131
1132 const char *Triple::getARMCPUForArch(StringRef MArch) const {
1133   if (MArch.empty())
1134     MArch = getArchName();
1135
1136   // Some defaults are forced.
1137   switch (getOS()) {
1138   case llvm::Triple::FreeBSD:
1139   case llvm::Triple::NetBSD:
1140     MArch = ARMTargetParser::getCanonicalArchName(MArch);
1141     if (!MArch.empty() && MArch == "v6")
1142       return "arm1176jzf-s";
1143     break;
1144   case llvm::Triple::Win32:
1145     // FIXME: this is invalid for WindowsCE
1146     return "cortex-a9";
1147   default:
1148     break;
1149   }
1150
1151   MArch = ARMTargetParser::getCanonicalArchName(MArch);
1152   if (MArch.empty())
1153     return nullptr;
1154
1155   const char *CPU = ARMTargetParser::getDefaultCPU(MArch);
1156   if (CPU)
1157     return CPU;
1158
1159   // If no specific architecture version is requested, return the minimum CPU
1160   // required by the OS and environment.
1161   switch (getOS()) {
1162   case llvm::Triple::NetBSD:
1163     switch (getEnvironment()) {
1164     case llvm::Triple::GNUEABIHF:
1165     case llvm::Triple::GNUEABI:
1166     case llvm::Triple::EABIHF:
1167     case llvm::Triple::EABI:
1168       return "arm926ej-s";
1169     default:
1170       return "strongarm";
1171     }
1172   case llvm::Triple::NaCl:
1173     return "cortex-a8";
1174   default:
1175     switch (getEnvironment()) {
1176     case llvm::Triple::EABIHF:
1177     case llvm::Triple::GNUEABIHF:
1178       return "arm1176jzf-s";
1179     default:
1180       return "arm7tdmi";
1181     }
1182   }
1183
1184   llvm_unreachable("invalid arch name");
1185 }