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