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