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 <cassert>
  12 #include <cstring>
  13 using namespace llvm;
  14
  15 //
  16
  17 const char *Triple::getArchTypeName(ArchType Kind) {
  18   switch (Kind) {
  19   case InvalidArch: return "<invalid>";
  20   case UnknownArch: return "unknown";
  21
  22   case x86: return "i386";
  23   case x86_64: return "x86_64";
  24   case ppc: return "powerpc";
  25   case ppc64: return "powerpc64";
  26   }
  27
  28   return "<invalid>";
  29 }
  30
  31 const char *Triple::getVendorTypeName(VendorType Kind) {
  32   switch (Kind) {
  33   case UnknownVendor: return "unknown";
  34
  35   case Apple: return "apple";
  36   case PC: return "PC";
  37   }
  38
  39   return "<invalid>";
  40 }
  41
  42 const char *Triple::getOSTypeName(OSType Kind) {
  43   switch (Kind) {
  44   case UnknownOS: return "unknown";
  45
  46   case AuroraUX: return "auroraux";
  47   case Darwin: return "darwin";
  48   case DragonFly: return "dragonfly";
  49   case FreeBSD: return "freebsd";
  50   case Linux: return "linux";
  51   case NetBSD: return "netbsd";
  52   case OpenBSD: return "openbsd";
  53   }
  54
  55   return "<invalid>";
  56 }
  57
  58 //
  59
  60 void Triple::Parse() const {
  61   assert(!isInitialized() && "Invalid parse call.");
  62
  63   std::string ArchName = getArchName();
  64   if (ArchName.size() == 4 && ArchName[0] == 'i' &&
  65       ArchName[2] == '8' && ArchName[3] == '6')
  66     Arch = x86;
  67   else if (ArchName == "amd64" || ArchName == "x86_64")
  68     Arch = x86_64;
  69   else if (ArchName == "powerpc")
  70     Arch = ppc;
  71   else if (ArchName == "powerpc64")
  72     Arch = ppc64;
  73   else
  74     Arch = UnknownArch;
  75
  76   std::string VendorName = getVendorName();
  77   if (VendorName == "apple")
  78     Vendor = Apple;
  79   else if (VendorName == "pc")
  80     Vendor = PC;
  81   else
  82     Vendor = UnknownVendor;
  83
  84   std::string OSName = getOSName();
  85   if (memcmp(&OSName[0], "auroraux", 8) == 0)
  86     OS = AuroraUX;
  87   else if (memcmp(&OSName[0], "darwin", 6) == 0)
  88     OS = Darwin;
  89   else if (memcmp(&OSName[0], "dragonfly", 9) == 0)
  90     OS = DragonFly;
  91   else if (memcmp(&OSName[0], "freebsd", 7) == 0)
  92     OS = FreeBSD;
  93   else if (memcmp(&OSName[0], "linux", 5) == 0)
  94     OS = Linux;
  95   else if (memcmp(&OSName[0], "netbsd", 6) == 0)
  96     OS = NetBSD;
  97   else if (memcmp(&OSName[0], "openbsd", 7) == 0)
  98     OS = OpenBSD;
  99   else
 100     OS = UnknownOS;
 101
 102   assert(isInitialized() && "Failed to initialize!");
 103 }
 104
 105 static std::string extract(const std::string &A,
 106                            std::string::size_type begin,
 107                            std::string::size_type end) {
 108   if (begin == std::string::npos)
 109     return "";
 110   if (end == std::string::npos)
 111     return A.substr(begin);
 112   return A.substr(begin, end - begin);
 113 }
 114
 115 static std::string extract1(const std::string &A,
 116                            std::string::size_type begin,
 117                            std::string::size_type end) {
 118   if (begin == std::string::npos || begin == end)
 119     return "";
 120   return extract(A, begin + 1, end);
 121 }
 122
 123 std::string Triple::getArchName() const {
 124   std::string Tmp = Data;
 125   return extract(Tmp, 0, Tmp.find('-'));
 126 }
 127
 128 std::string Triple::getVendorName() const {
 129   std::string Tmp = Data;
 130   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 131   return extract(Tmp, 0, Tmp.find('-'));
 132 }
 133
 134 std::string Triple::getOSName() const {
 135   std::string Tmp = Data;
 136   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 137   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 138   return extract(Tmp, 0, Tmp.find('-'));
 139 }
 140
 141 std::string Triple::getEnvironmentName() const {
 142   std::string Tmp = Data;
 143   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 144   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 145   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 146   return extract(Tmp, 0, std::string::npos);
 147 }
 148
 149 std::string Triple::getOSAndEnvironmentName() const {
 150   std::string Tmp = Data;
 151   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 152   Tmp = extract1(Tmp, Tmp.find('-'), std::string::npos);
 153   return extract(Tmp, 0, std::string::npos);
 154 }
 155
 156 void Triple::setTriple(const std::string &Str) {
 157   Data = Str;
 158   Arch = InvalidArch;
 159 }
 160
 161 void Triple::setArch(ArchType Kind) {
 162   setArchName(getArchTypeName(Kind));
 163 }
 164
 165 void Triple::setVendor(VendorType Kind) {
 166   setVendorName(getVendorTypeName(Kind));
 167 }
 168
 169 void Triple::setOS(OSType Kind) {
 170   setOSName(getOSTypeName(Kind));
 171 }
 172
 173 void Triple::setArchName(const std::string &Str) {
 174   setTriple(Str + "-" + getVendorName() + "-" + getOSAndEnvironmentName());
 175 }
 176
 177 void Triple::setVendorName(const std::string &Str) {
 178   setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
 179 }
 180
 181 void Triple::setOSName(const std::string &Str) {
 182   if (hasEnvironment())
 183     setTriple(getArchName() + "-" + getVendorName() + "-" + Str +
 184               "-" + getEnvironmentName());
 185   else
 186     setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 187 }
 188
 189 void Triple::setEnvironmentName(const std::string &Str) {
 190   setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
 191             "-" + Str);
 192 }
 193
 194 void Triple::setOSAndEnvironmentName(const std::string &Str) {
 195   setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
 196 }