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 }
188