X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FTriple.cpp;h=2b8b39782ccdbdfcbb1b5587a0399cb28a2f7a2d;hb=3cf9f3731222d5c86173c83b6dec9783f40b305c;hp=9e91642d9752733e0700aa8ba1c37bbb4a85a077;hpb=b52cb5e0db7ed753d8bb43f3c4f3ea068fe1066c;p=oota-llvm.git diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp index 9e91642d975..2b8b39782cc 100644 --- a/lib/Support/Triple.cpp +++ b/lib/Support/Triple.cpp @@ -24,6 +24,7 @@ const char *Triple::getArchTypeName(ArchType Kind) { case arm: return "arm"; case armeb: return "armeb"; case arm64: return "arm64"; + case arm64_be: return "arm64_be"; case hexagon: return "hexagon"; case mips: return "mips"; case mipsel: return "mipsel"; @@ -49,6 +50,7 @@ const char *Triple::getArchTypeName(ArchType Kind) { case amdil: return "amdil"; case spir: return "spir"; case spir64: return "spir64"; + case kalimba: return "kalimba"; } llvm_unreachable("Invalid ArchType!"); @@ -57,8 +59,10 @@ const char *Triple::getArchTypeName(ArchType Kind) { const char *Triple::getArchTypePrefix(ArchType Kind) { switch (Kind) { default: - return 0; + return nullptr; + case arm64: + case arm64_be: case aarch64: case aarch64_be: return "aarch64"; @@ -67,8 +71,6 @@ const char *Triple::getArchTypePrefix(ArchType Kind) { case thumb: case thumbeb: return "arm"; - case arm64: return "arm64"; - case ppc64: case ppc64le: case ppc: return "ppc"; @@ -99,6 +101,7 @@ const char *Triple::getArchTypePrefix(ArchType Kind) { case amdil: return "amdil"; case spir: return "spir"; case spir64: return "spir"; + case kalimba: return "kalimba"; } } @@ -113,7 +116,9 @@ const char *Triple::getVendorTypeName(VendorType Kind) { case BGQ: return "bgq"; case Freescale: return "fsl"; case IBM: return "ibm"; + case ImaginationTechnologies: return "img"; case NVIDIA: return "nvidia"; + case CSR: return "csr"; } llvm_unreachable("Invalid VendorType!"); @@ -178,6 +183,7 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { .Case("arm", arm) .Case("armeb", armeb) .Case("arm64", arm64) + .Case("arm64_be", arm64_be) .Case("mips", mips) .Case("mipsel", mipsel) .Case("mips64", mips64) @@ -204,13 +210,14 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { .Case("amdil", amdil) .Case("spir", spir) .Case("spir64", spir64) + .Case("kalimba", kalimba) .Default(UnknownArch); } // Returns architecture name that is understood by the target assembler. const char *Triple::getArchNameForAssembler() { if (!isOSDarwin() && getVendor() != Triple::Apple) - return NULL; + return nullptr; return StringSwitch(getArchName()) .Case("i386", "i386") @@ -225,6 +232,7 @@ const char *Triple::getArchNameForAssembler() { .Cases("armv7", "thumbv7", "armv7") .Case("armeb", "armeb") .Case("arm64", "arm64") + .Case("arm64_be", "arm64") .Case("r600", "r600") .Case("nvptx", "nvptx") .Case("nvptx64", "nvptx64") @@ -232,7 +240,7 @@ const char *Triple::getArchNameForAssembler() { .Case("amdil", "amdil") .Case("spir", "spir") .Case("spir64", "spir64") - .Default(NULL); + .Default(nullptr); } static Triple::ArchType parseArch(StringRef ArchName) { @@ -257,6 +265,7 @@ static Triple::ArchType parseArch(StringRef ArchName) { .Case("thumbeb", Triple::thumbeb) .StartsWith("thumbebv", Triple::thumbeb) .Case("arm64", Triple::arm64) + .Case("arm64_be", Triple::arm64_be) .Case("msp430", Triple::msp430) .Cases("mips", "mipseb", "mipsallegrex", Triple::mips) .Cases("mipsel", "mipsallegrexel", Triple::mipsel) @@ -275,6 +284,7 @@ static Triple::ArchType parseArch(StringRef ArchName) { .Case("amdil", Triple::amdil) .Case("spir", Triple::spir) .Case("spir64", Triple::spir64) + .Case("kalimba", Triple::kalimba) .Default(Triple::UnknownArch); } @@ -287,7 +297,9 @@ static Triple::VendorType parseVendor(StringRef VendorName) { .Case("bgq", Triple::BGQ) .Case("fsl", Triple::Freescale) .Case("ibm", Triple::IBM) + .Case("img", Triple::ImaginationTechnologies) .Case("nvidia", Triple::NVIDIA) + .Case("csr", Triple::CSR) .Default(Triple::UnknownVendor); } @@ -547,24 +559,27 @@ std::string Triple::normalize(StringRef Str) { Components.resize(4); Components[2] = "windows"; if (Environment == UnknownEnvironment) { - if (ObjectFormat == UnknownObjectFormat) + if (ObjectFormat == UnknownObjectFormat || ObjectFormat == Triple::COFF) Components[3] = "msvc"; else Components[3] = getObjectFormatTypeName(ObjectFormat); - } else if (ObjectFormat != UnknownObjectFormat && - ObjectFormat != Triple::COFF) { - Components.resize(5); - Components[4] = getObjectFormatTypeName(ObjectFormat); } } else if (OS == Triple::MinGW32) { Components.resize(4); Components[2] = "windows"; - Components[3] = (ObjectFormat == Triple::ELF) ? "gnuelf" : "gnu"; + Components[3] = "gnu"; } else if (OS == Triple::Cygwin) { Components.resize(4); Components[2] = "windows"; Components[3] = "cygnus"; } + if (OS == Triple::MinGW32 || OS == Triple::Cygwin || + (OS == Triple::Win32 && Environment != UnknownEnvironment)) { + if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) { + Components.resize(5); + Components[4] = getObjectFormatTypeName(ObjectFormat); + } + } // Stick the corrected components back together to form the normalized string. std::string Normalized; @@ -726,7 +741,11 @@ void Triple::setEnvironment(EnvironmentType Kind) { } void Triple::setObjectFormat(ObjectFormatType Kind) { - setEnvironmentName(getObjectFormatTypeName(Kind)); + if (Environment == UnknownEnvironment) + return setEnvironmentName(getObjectFormatTypeName(Kind)); + + setEnvironmentName((getEnvironmentTypeName(Environment) + Twine("-") + + getObjectFormatTypeName(Kind)).str()); } void Triple::setArchName(StringRef Str) { @@ -786,9 +805,11 @@ static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { case llvm::Triple::x86: case llvm::Triple::xcore: case llvm::Triple::spir: + case llvm::Triple::kalimba: return 32; case llvm::Triple::arm64: + case llvm::Triple::arm64_be: case llvm::Triple::aarch64: case llvm::Triple::aarch64_be: case llvm::Triple::mips64: @@ -823,6 +844,8 @@ Triple Triple::get32BitArchVariant() const { case Triple::UnknownArch: case Triple::aarch64: case Triple::aarch64_be: + case Triple::arm64: + case Triple::arm64_be: case Triple::msp430: case Triple::systemz: case Triple::ppc64le: @@ -834,6 +857,7 @@ Triple Triple::get32BitArchVariant() const { case Triple::arm: case Triple::armeb: case Triple::hexagon: + case Triple::kalimba: case Triple::le32: case Triple::mips: case Triple::mipsel: @@ -856,7 +880,6 @@ Triple Triple::get32BitArchVariant() const { case Triple::sparcv9: T.setArch(Triple::sparc); break; case Triple::x86_64: T.setArch(Triple::x86); break; case Triple::spir64: T.setArch(Triple::spir); break; - case Triple::arm64: T.setArch(Triple::arm); break; } return T; } @@ -866,8 +889,10 @@ Triple Triple::get64BitArchVariant() const { switch (getArch()) { case Triple::UnknownArch: case Triple::amdil: + case Triple::arm: case Triple::armeb: case Triple::hexagon: + case Triple::kalimba: case Triple::le32: case Triple::msp430: case Triple::r600: @@ -890,6 +915,7 @@ Triple Triple::get64BitArchVariant() const { case Triple::systemz: case Triple::x86_64: case Triple::arm64: + case Triple::arm64_be: // Already 64-bit. break; @@ -900,7 +926,88 @@ Triple Triple::get64BitArchVariant() const { case Triple::sparc: T.setArch(Triple::sparcv9); break; case Triple::x86: T.setArch(Triple::x86_64); break; case Triple::spir: T.setArch(Triple::spir64); break; - case Triple::arm: T.setArch(Triple::arm64); break; } return T; } + +// FIXME: tblgen this. +const char *Triple::getARMCPUForArch(StringRef MArch) const { + if (MArch.empty()) + MArch = getArchName(); + + switch (getOS()) { + case llvm::Triple::NetBSD: + if (MArch == "armv6") + return "arm1176jzf-s"; + break; + case llvm::Triple::Win32: + // FIXME: this is invalid for WindowsCE + return "cortex-a9"; + default: + break; + } + + const char *result = nullptr; + size_t offset = StringRef::npos; + if (MArch.startswith("arm")) + offset = 3; + if (MArch.startswith("thumb")) + offset = 5; + if (offset != StringRef::npos && MArch.substr(offset, 2) == "eb") + offset += 2; + if (offset != StringRef::npos) + result = llvm::StringSwitch(MArch.substr(offset)) + .Cases("v2", "v2a", "arm2") + .Case("v3", "arm6") + .Case("v3m", "arm7m") + .Case("v4", "strongarm") + .Case("v4t", "arm7tdmi") + .Cases("v5", "v5t", "arm10tdmi") + .Cases("v5e", "v5te", "arm1022e") + .Case("v5tej", "arm926ej-s") + .Cases("v6", "v6k", "arm1136jf-s") + .Case("v6j", "arm1136j-s") + .Cases("v6z", "v6zk", "arm1176jzf-s") + .Case("v6t2", "arm1156t2-s") + .Cases("v6m", "v6-m", "cortex-m0") + .Cases("v7", "v7a", "v7-a", "v7l", "v7-l", "cortex-a8") + .Cases("v7s", "v7-s", "swift") + .Cases("v7r", "v7-r", "cortex-r4") + .Cases("v7m", "v7-m", "cortex-m3") + .Cases("v7em", "v7e-m", "cortex-m4") + .Cases("v8", "v8a", "v8-a", "cortex-a53") + .Default(nullptr); + else + result = llvm::StringSwitch(MArch) + .Case("ep9312", "ep9312") + .Case("iwmmxt", "iwmmxt") + .Case("xscale", "xscale") + .Default(nullptr); + + if (result) + return result; + + // If all else failed, return the most base CPU with thumb interworking + // supported by LLVM. + // FIXME: Should warn once that we're falling back. + switch (getOS()) { + case llvm::Triple::NetBSD: + switch (getEnvironment()) { + case llvm::Triple::GNUEABIHF: + case llvm::Triple::GNUEABI: + case llvm::Triple::EABIHF: + case llvm::Triple::EABI: + return "arm926ej-s"; + default: + return "strongarm"; + } + default: + switch (getEnvironment()) { + case llvm::Triple::EABIHF: + case llvm::Triple::GNUEABIHF: + return "arm1176jzf-s"; + default: + return "arm7tdmi"; + } + } +}