X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FTriple.cpp;h=d1dc7c81af06ca6178fa73f1e0cc10e77798ceec;hb=c5252da873d547a19069eaf9030fec203f128f66;hp=b5aa5190692a42c76325b5bda4ac8ddc5acad194;hpb=0523f41841d0860b2e175a4b20d1ecefd7295c4a;p=oota-llvm.git diff --git a/lib/Support/Triple.cpp b/lib/Support/Triple.cpp index b5aa5190692..d1dc7c81af0 100644 --- a/lib/Support/Triple.cpp +++ b/lib/Support/Triple.cpp @@ -29,6 +29,7 @@ const char *Triple::getArchTypeName(ArchType Kind) { case msp430: return "msp430"; case ppc64: return "powerpc64"; case ppc: return "powerpc"; + case r600: return "r600"; case sparc: return "sparc"; case sparcv9: return "sparcv9"; case tce: return "tce"; @@ -37,8 +38,8 @@ const char *Triple::getArchTypeName(ArchType Kind) { case x86_64: return "x86_64"; case xcore: return "xcore"; case mblaze: return "mblaze"; - case ptx32: return "ptx32"; - case ptx64: return "ptx64"; + case nvptx: return "nvptx"; + case nvptx64: return "nvptx64"; case le32: return "le32"; case amdil: return "amdil"; } @@ -61,7 +62,14 @@ const char *Triple::getArchTypePrefix(ArchType Kind) { case mblaze: return "mblaze"; - case hexagon: return "hexagon"; + case mips: + case mipsel: + case mips64: + case mips64el:return "mips"; + + case hexagon: return "hexagon"; + + case r600: return "r600"; case sparcv9: case sparc: return "sparc"; @@ -71,8 +79,8 @@ const char *Triple::getArchTypePrefix(ArchType Kind) { case xcore: return "xcore"; - case ptx32: return "ptx"; - case ptx64: return "ptx"; + case nvptx: return "nvptx"; + case nvptx64: return "nvptx"; case le32: return "le32"; case amdil: return "amdil"; } @@ -85,6 +93,9 @@ const char *Triple::getVendorTypeName(VendorType Kind) { case Apple: return "apple"; case PC: return "pc"; case SCEI: return "scei"; + case BGP: return "bgp"; + case BGQ: return "bgq"; + case Freescale: return "fsl"; } llvm_unreachable("Invalid VendorType!"); @@ -107,13 +118,14 @@ const char *Triple::getOSTypeName(OSType Kind) { case MinGW32: return "mingw32"; case NetBSD: return "netbsd"; case OpenBSD: return "openbsd"; - case Psp: return "psp"; case Solaris: return "solaris"; case Win32: return "win32"; case Haiku: return "haiku"; case Minix: return "minix"; case RTEMS: return "rtems"; case NativeClient: return "nacl"; + case CNK: return "cnk"; + case Bitrig: return "bitrig"; } llvm_unreachable("Invalid OSType"); @@ -127,7 +139,7 @@ const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) { case GNUEABI: return "gnueabi"; case EABI: return "eabi"; case MachO: return "macho"; - case ANDROIDEABI: return "androideabi"; + case Android: return "android"; } llvm_unreachable("Invalid EnvironmentType!"); @@ -146,6 +158,7 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { .Case("ppc32", ppc) .Case("ppc", ppc) .Case("mblaze", mblaze) + .Case("r600", r600) .Case("hexagon", hexagon) .Case("sparc", sparc) .Case("sparcv9", sparcv9) @@ -154,8 +167,8 @@ Triple::ArchType Triple::getArchTypeForLLVMName(StringRef Name) { .Case("x86", x86) .Case("x86-64", x86_64) .Case("xcore", xcore) - .Case("ptx32", ptx32) - .Case("ptx64", ptx64) + .Case("nvptx", nvptx) + .Case("nvptx64", nvptx64) .Case("le32", le32) .Case("amdil", amdil) .Default(UnknownArch); @@ -185,8 +198,9 @@ Triple::ArchType Triple::getArchTypeForDarwinArchName(StringRef Str) { // This is derived from the driver driver. .Cases("arm", "armv4t", "armv5", "armv6", Triple::arm) .Cases("armv7", "armv7f", "armv7k", "armv7s", "xscale", Triple::arm) - .Case("ptx32", Triple::ptx32) - .Case("ptx64", Triple::ptx64) + .Case("r600", Triple::r600) + .Case("nvptx", Triple::nvptx) + .Case("nvptx64", Triple::nvptx64) .Case("amdil", Triple::amdil) .Default(Triple::UnknownArch); } @@ -207,87 +221,94 @@ const char *Triple::getArchNameForAssembler() { .Cases("armv5", "armv5e", "thumbv5", "thumbv5e", "armv5") .Cases("armv6", "thumbv6", "armv6") .Cases("armv7", "thumbv7", "armv7") - .Case("ptx32", "ptx32") - .Case("ptx64", "ptx64") + .Case("r600", "r600") + .Case("nvptx", "nvptx") + .Case("nvptx64", "nvptx64") .Case("le32", "le32") .Case("amdil", "amdil") .Default(NULL); } -Triple::ArchType Triple::ParseArch(StringRef ArchName) { - return StringSwitch(ArchName) - .Cases("i386", "i486", "i586", "i686", x86) - .Cases("i786", "i886", "i986", x86) // FIXME: Do we need to support these? - .Cases("amd64", "x86_64", x86_64) - .Case("powerpc", ppc) - .Cases("powerpc64", "ppu", ppc64) - .Case("mblaze", mblaze) - .Cases("arm", "xscale", arm) +static Triple::ArchType parseArch(StringRef ArchName) { + return StringSwitch(ArchName) + .Cases("i386", "i486", "i586", "i686", Triple::x86) + // FIXME: Do we need to support these? + .Cases("i786", "i886", "i986", Triple::x86) + .Cases("amd64", "x86_64", Triple::x86_64) + .Case("powerpc", Triple::ppc) + .Cases("powerpc64", "ppu", Triple::ppc64) + .Case("mblaze", Triple::mblaze) + .Cases("arm", "xscale", Triple::arm) // FIXME: It would be good to replace these with explicit names for all the // various suffixes supported. - .StartsWith("armv", arm) - .Case("thumb", thumb) - .StartsWith("thumbv", thumb) - .Cases("spu", "cellspu", cellspu) - .Case("msp430", msp430) - .Cases("mips", "mipseb", "mipsallegrex", mips) - .Cases("mipsel", "mipsallegrexel", "psp", mipsel) - .Cases("mips64", "mips64eb", mips64) - .Case("mips64el", mips64el) - .Case("hexagon", hexagon) - .Case("sparc", sparc) - .Case("sparcv9", sparcv9) - .Case("tce", tce) - .Case("xcore", xcore) - .Case("ptx32", ptx32) - .Case("ptx64", ptx64) - .Case("le32", le32) - .Case("amdil", amdil) - .Default(UnknownArch); + .StartsWith("armv", Triple::arm) + .Case("thumb", Triple::thumb) + .StartsWith("thumbv", Triple::thumb) + .Cases("spu", "cellspu", Triple::cellspu) + .Case("msp430", Triple::msp430) + .Cases("mips", "mipseb", "mipsallegrex", Triple::mips) + .Cases("mipsel", "mipsallegrexel", Triple::mipsel) + .Cases("mips64", "mips64eb", Triple::mips64) + .Case("mips64el", Triple::mips64el) + .Case("r600", Triple::r600) + .Case("hexagon", Triple::hexagon) + .Case("sparc", Triple::sparc) + .Case("sparcv9", Triple::sparcv9) + .Case("tce", Triple::tce) + .Case("xcore", Triple::xcore) + .Case("nvptx", Triple::nvptx) + .Case("nvptx64", Triple::nvptx64) + .Case("le32", Triple::le32) + .Case("amdil", Triple::amdil) + .Default(Triple::UnknownArch); } -Triple::VendorType Triple::ParseVendor(StringRef VendorName) { - return StringSwitch(VendorName) - .Case("apple", Apple) - .Case("pc", PC) - .Case("scei", SCEI) - .Default(UnknownVendor); -} - -Triple::OSType Triple::ParseOS(StringRef OSName) { - return StringSwitch(OSName) - .StartsWith("auroraux", AuroraUX) - .StartsWith("cygwin", Cygwin) - .StartsWith("darwin", Darwin) - .StartsWith("dragonfly", DragonFly) - .StartsWith("freebsd", FreeBSD) - .StartsWith("ios", IOS) - .StartsWith("kfreebsd", KFreeBSD) - .StartsWith("linux", Linux) - .StartsWith("lv2", Lv2) - .StartsWith("macosx", MacOSX) - .StartsWith("mingw32", MinGW32) - .StartsWith("netbsd", NetBSD) - .StartsWith("openbsd", OpenBSD) - .StartsWith("psp", Psp) - .StartsWith("solaris", Solaris) - .StartsWith("win32", Win32) - .StartsWith("haiku", Haiku) - .StartsWith("minix", Minix) - .StartsWith("rtems", RTEMS) - .StartsWith("nacl", NativeClient) - .Default(UnknownOS); -} - -Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) { - return StringSwitch(EnvironmentName) - .StartsWith("eabi", EABI) - .StartsWith("gnueabihf", GNUEABIHF) - .StartsWith("gnueabi", GNUEABI) - .StartsWith("gnu", GNU) - .StartsWith("macho", MachO) - .StartsWith("androideabi", ANDROIDEABI) - .Default(UnknownEnvironment); +static Triple::VendorType parseVendor(StringRef VendorName) { + return StringSwitch(VendorName) + .Case("apple", Triple::Apple) + .Case("pc", Triple::PC) + .Case("scei", Triple::SCEI) + .Case("bgp", Triple::BGP) + .Case("bgq", Triple::BGQ) + .Case("fsl", Triple::Freescale) + .Default(Triple::UnknownVendor); +} + +static Triple::OSType parseOS(StringRef OSName) { + return StringSwitch(OSName) + .StartsWith("auroraux", Triple::AuroraUX) + .StartsWith("cygwin", Triple::Cygwin) + .StartsWith("darwin", Triple::Darwin) + .StartsWith("dragonfly", Triple::DragonFly) + .StartsWith("freebsd", Triple::FreeBSD) + .StartsWith("ios", Triple::IOS) + .StartsWith("kfreebsd", Triple::KFreeBSD) + .StartsWith("linux", Triple::Linux) + .StartsWith("lv2", Triple::Lv2) + .StartsWith("macosx", Triple::MacOSX) + .StartsWith("mingw32", Triple::MinGW32) + .StartsWith("netbsd", Triple::NetBSD) + .StartsWith("openbsd", Triple::OpenBSD) + .StartsWith("solaris", Triple::Solaris) + .StartsWith("win32", Triple::Win32) + .StartsWith("haiku", Triple::Haiku) + .StartsWith("minix", Triple::Minix) + .StartsWith("rtems", Triple::RTEMS) + .StartsWith("nacl", Triple::NativeClient) + .StartsWith("cnk", Triple::CNK) + .StartsWith("bitrig", Triple::Bitrig) + .Default(Triple::UnknownOS); +} + +static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) { + return StringSwitch(EnvironmentName) + .StartsWith("eabi", Triple::EABI) + .StartsWith("gnueabihf", Triple::GNUEABIHF) + .StartsWith("gnueabi", Triple::GNUEABI) + .StartsWith("gnu", Triple::GNU) + .StartsWith("macho", Triple::MachO) + .StartsWith("android", Triple::Android) + .Default(Triple::UnknownEnvironment); } /// \brief Construct a triple from the string representation provided. @@ -296,10 +317,10 @@ Triple::EnvironmentType Triple::ParseEnvironment(StringRef EnvironmentName) { /// enum members. Triple::Triple(const Twine &Str) : Data(Str.str()), - Arch(ParseArch(getArchName())), - Vendor(ParseVendor(getVendorName())), - OS(ParseOS(getOSName())), - Environment(ParseEnvironment(getEnvironmentName())) { + Arch(parseArch(getArchName())), + Vendor(parseVendor(getVendorName())), + OS(parseOS(getOSName())), + Environment(parseEnvironment(getEnvironmentName())) { } /// \brief Construct a triple from string representations of the architecture, @@ -310,9 +331,9 @@ Triple::Triple(const Twine &Str) /// the string representation. Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr) : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr).str()), - Arch(ParseArch(ArchStr.str())), - Vendor(ParseVendor(VendorStr.str())), - OS(ParseOS(OSStr.str())), + Arch(parseArch(ArchStr.str())), + Vendor(parseVendor(VendorStr.str())), + OS(parseOS(OSStr.str())), Environment() { } @@ -325,19 +346,16 @@ Triple::Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr, const Twine &EnvironmentStr) : Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') + EnvironmentStr).str()), - Arch(ParseArch(ArchStr.str())), - Vendor(ParseVendor(VendorStr.str())), - OS(ParseOS(OSStr.str())), - Environment(ParseEnvironment(EnvironmentStr.str())) { + Arch(parseArch(ArchStr.str())), + Vendor(parseVendor(VendorStr.str())), + OS(parseOS(OSStr.str())), + Environment(parseEnvironment(EnvironmentStr.str())) { } std::string Triple::normalize(StringRef Str) { // Parse into components. SmallVector Components; - for (size_t First = 0, Last = 0; Last != StringRef::npos; First = Last + 1) { - Last = Str.find('-', First); - Components.push_back(Str.slice(First, Last)); - } + Str.split(Components, "-"); // If the first component corresponds to a known architecture, preferentially // use it for the architecture. If the second component corresponds to a @@ -346,16 +364,16 @@ std::string Triple::normalize(StringRef Str) { // valid os. ArchType Arch = UnknownArch; if (Components.size() > 0) - Arch = ParseArch(Components[0]); + Arch = parseArch(Components[0]); VendorType Vendor = UnknownVendor; if (Components.size() > 1) - Vendor = ParseVendor(Components[1]); + Vendor = parseVendor(Components[1]); OSType OS = UnknownOS; if (Components.size() > 2) - OS = ParseOS(Components[2]); + OS = parseOS(Components[2]); EnvironmentType Environment = UnknownEnvironment; if (Components.size() > 3) - Environment = ParseEnvironment(Components[3]); + Environment = parseEnvironment(Components[3]); // Note which components are already in their final position. These will not // be moved. @@ -383,19 +401,19 @@ std::string Triple::normalize(StringRef Str) { switch (Pos) { default: llvm_unreachable("unexpected component type!"); case 0: - Arch = ParseArch(Comp); + Arch = parseArch(Comp); Valid = Arch != UnknownArch; break; case 1: - Vendor = ParseVendor(Comp); + Vendor = parseVendor(Comp); Valid = Vendor != UnknownVendor; break; case 2: - OS = ParseOS(Comp); + OS = parseOS(Comp); Valid = OS != UnknownOS; break; case 3: - Environment = ParseEnvironment(Comp); + Environment = parseEnvironment(Comp); Valid = Environment != UnknownEnvironment; break; } @@ -416,7 +434,8 @@ std::string Triple::normalize(StringRef Str) { // components to the right. for (unsigned i = Pos; !CurrentComponent.empty(); ++i) { // Skip over any fixed components. - while (i < array_lengthof(Found) && Found[i]) ++i; + while (i < array_lengthof(Found) && Found[i]) + ++i; // Place the component at the new position, getting the component // that was at this position - it will be moved right. std::swap(CurrentComponent, Components[i]); @@ -444,7 +463,8 @@ std::string Triple::normalize(StringRef Str) { Components.push_back(CurrentComponent); // Advance Idx to the component's new position. - while (++Idx < array_lengthof(Found) && Found[Idx]) {} + while (++Idx < array_lengthof(Found) && Found[Idx]) + ; } while (Idx < Pos); // Add more until the final position is reached. } assert(Pos < Components.size() && Components[Pos] == Comp && @@ -573,6 +593,29 @@ bool Triple::getMacOSXVersion(unsigned &Major, unsigned &Minor, return true; } +void Triple::getiOSVersion(unsigned &Major, unsigned &Minor, + unsigned &Micro) const { + switch (getOS()) { + default: llvm_unreachable("unexpected OS for Darwin triple"); + case Darwin: + case MacOSX: + // Ignore the version from the triple. This is only handled because the + // the clang driver combines OS X and IOS support into a common Darwin + // toolchain that wants to know the iOS version number even when targeting + // OS X. + Major = 3; + Minor = 0; + Micro = 0; + break; + case IOS: + getOSVersion(Major, Minor, Micro); + // Default to 3.0. + if (Major == 0) + Major = 3; + break; + } +} + void Triple::setTriple(const Twine &Str) { *this = Triple(Str); } @@ -641,8 +684,9 @@ static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { case llvm::Triple::mblaze: case llvm::Triple::mips: case llvm::Triple::mipsel: + case llvm::Triple::nvptx: case llvm::Triple::ppc: - case llvm::Triple::ptx32: + case llvm::Triple::r600: case llvm::Triple::sparc: case llvm::Triple::tce: case llvm::Triple::thumb: @@ -652,8 +696,8 @@ static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) { case llvm::Triple::mips64: case llvm::Triple::mips64el: + case llvm::Triple::nvptx64: case llvm::Triple::ppc64: - case llvm::Triple::ptx64: case llvm::Triple::sparcv9: case llvm::Triple::x86_64: return 64; @@ -689,8 +733,9 @@ Triple Triple::get32BitArchVariant() const { case Triple::mblaze: case Triple::mips: case Triple::mipsel: + case Triple::nvptx: case Triple::ppc: - case Triple::ptx32: + case Triple::r600: case Triple::sparc: case Triple::tce: case Triple::thumb: @@ -701,8 +746,8 @@ Triple Triple::get32BitArchVariant() const { case Triple::mips64: T.setArch(Triple::mips); break; case Triple::mips64el: T.setArch(Triple::mipsel); break; + case Triple::nvptx64: T.setArch(Triple::nvptx); break; case Triple::ppc64: T.setArch(Triple::ppc); break; - case Triple::ptx64: T.setArch(Triple::ptx32); break; case Triple::sparcv9: T.setArch(Triple::sparc); break; case Triple::x86_64: T.setArch(Triple::x86); break; } @@ -720,6 +765,7 @@ Triple Triple::get64BitArchVariant() const { case Triple::le32: case Triple::mblaze: case Triple::msp430: + case Triple::r600: case Triple::tce: case Triple::thumb: case Triple::xcore: @@ -728,8 +774,8 @@ Triple Triple::get64BitArchVariant() const { case Triple::mips64: case Triple::mips64el: + case Triple::nvptx64: case Triple::ppc64: - case Triple::ptx64: case Triple::sparcv9: case Triple::x86_64: // Already 64-bit. @@ -737,8 +783,8 @@ Triple Triple::get64BitArchVariant() const { case Triple::mips: T.setArch(Triple::mips64); break; case Triple::mipsel: T.setArch(Triple::mips64el); break; + case Triple::nvptx: T.setArch(Triple::nvptx64); break; case Triple::ppc: T.setArch(Triple::ppc64); break; - case Triple::ptx32: T.setArch(Triple::ptx64); break; case Triple::sparc: T.setArch(Triple::sparcv9); break; case Triple::x86: T.setArch(Triple::x86_64); break; }