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