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