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