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