Triple.cpp revision cd1267d2d68f03026aed21e22f7e28efd510ec5f 
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>
13using namespace llvm;
14
15//
16
17const 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
31const 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
42const 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
59void 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
102static 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
112static 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
120std::string Triple::getArchName() const {
121  std::string Tmp = Data;
122  return extract(Tmp, 0, Tmp.find('-'));
123}
124
125std::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
131std::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
138std::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
146std::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
153void Triple::setTriple(const std::string &Str) {
154  Data = Str;
155  Arch = InvalidArch;
156}
157
158void Triple::setArch(ArchType Kind) {
159  setArchName(getArchTypeName(Kind));
160}
161
162void Triple::setVendor(VendorType Kind) {
163  setVendorName(getVendorTypeName(Kind));
164}
165
166void Triple::setOS(OSType Kind) {
167  setOSName(getOSTypeName(Kind));
168}
169
170void Triple::setArchName(const std::string &Str) {
171  setTriple(Str + "-" + getVendorName() + "-" + getOSAndEnvironmentName());
172}
173
174void Triple::setVendorName(const std::string &Str) {
175  setTriple(getArchName() + "-" + Str + "-" + getOSAndEnvironmentName());
176}
177
178void 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
186void Triple::setEnvironmentName(const std::string &Str) {
187  setTriple(getArchName() + "-" + getVendorName() + "-" + getOSName() +
188            "-" + Str);
189}
190
191void Triple::setOSAndEnvironmentName(const std::string &Str) {
192  setTriple(getArchName() + "-" + getVendorName() + "-" + Str);
193}
194