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