Triple.h revision d950941e138455ebcd7a5f55805dcb977892e3e3 
1//===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
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#ifndef LLVM_ADT_TRIPLE_H
11#define LLVM_ADT_TRIPLE_H
12
13#include "llvm/ADT/StringRef.h"
14#include <string>
15
16namespace llvm {
17class StringRef;
18class Twine;
19
20/// Triple - Helper class for working with target triples.
21///
22/// Target triples are strings in the format of:
23///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM
24/// or
25///   ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
26///
27/// This class is used for clients which want to support arbitrary
28/// target triples, but also want to implement certain special
29/// behavior for particular targets. This class isolates the mapping
30/// from the components of the target triple to well known IDs.
31///
32/// See autoconf/config.guess for a glimpse into what they look like
33/// in practice.
34class Triple {
35public:
36  enum ArchType {
37    UnknownArch,
38
39    alpha,   // alpha
40    arm,     // arm, armv.*
41    bfin,    // blackfin
42    cellspu, // spu, cellspu
43    mips,    // mips, mipsallegrex
44    mipsel,  // mipsel, mipsallegrexel, psp
45    msp430,  // msp430
46    ppc,     // powerpc
47    ppc64,   // powerpc64
48    sparc,   // sparc
49    systemz, // s390x
50    thumb,   // thumb, thumbv.*
51    x86,     // i[3-9]86
52    x86_64,  // amd64, x86_64
53    xcore,   // xcore
54
55    InvalidArch
56  };
57  enum VendorType {
58    UnknownVendor,
59
60    Apple,
61    PC
62  };
63  enum OSType {
64    UnknownOS,
65
66    AuroraUX,
67    Cygwin,
68    Darwin,
69    DragonFly,
70    FreeBSD,
71    Linux,
72    MinGW32,
73    NetBSD,
74    OpenBSD,
75    Win32
76  };
77
78private:
79  std::string Data;
80
81  /// The parsed arch type (or InvalidArch if uninitialized).
82  mutable ArchType Arch;
83
84  /// The parsed vendor type.
85  mutable VendorType Vendor;
86
87  /// The parsed OS type.
88  mutable OSType OS;
89
90  bool isInitialized() const { return Arch != InvalidArch; }
91  void Parse() const;
92
93public:
94  /// @name Constructors
95  /// @{
96
97  Triple() : Data(""), Arch(InvalidArch) {}
98  explicit Triple(const char *Str) : Data(Str), Arch(InvalidArch) {}
99  explicit Triple(const char *ArchStr, const char *VendorStr, const char *OSStr)
100    : Data(ArchStr), Arch(InvalidArch) {
101    Data += '-';
102    Data += VendorStr;
103    Data += '-';
104    Data += OSStr;
105  }
106
107  /// @}
108  /// @name Typed Component Access
109  /// @{
110
111  /// getArch - Get the parsed architecture type of this triple.
112  ArchType getArch() const {
113    if (!isInitialized()) Parse();
114    return Arch;
115  }
116
117  /// getVendor - Get the parsed vendor type of this triple.
118  VendorType getVendor() const {
119    if (!isInitialized()) Parse();
120    return Vendor;
121  }
122
123  /// getOS - Get the parsed operating system type of this triple.
124  OSType getOS() const {
125    if (!isInitialized()) Parse();
126    return OS;
127  }
128
129  /// hasEnvironment - Does this triple have the optional environment
130  /// (fourth) component?
131  bool hasEnvironment() const {
132    return getEnvironmentName() != "";
133  }
134
135  /// @}
136  /// @name Direct Component Access
137  /// @{
138
139  const std::string &getTriple() const { return Data; }
140
141  /// getArchName - Get the architecture (first) component of the
142  /// triple.
143  StringRef getArchName() const;
144
145  /// getVendorName - Get the vendor (second) component of the triple.
146  StringRef getVendorName() const;
147
148  /// getOSName - Get the operating system (third) component of the
149  /// triple.
150  StringRef getOSName() const;
151
152  /// getEnvironmentName - Get the optional environment (fourth)
153  /// component of the triple, or "" if empty.
154  StringRef getEnvironmentName() const;
155
156  /// getOSAndEnvironmentName - Get the operating system and optional
157  /// environment components as a single string (separated by a '-'
158  /// if the environment component is present).
159  StringRef getOSAndEnvironmentName() const;
160
161  /// @}
162  /// @name Mutators
163  /// @{
164
165  /// setArch - Set the architecture (first) component of the triple
166  /// to a known type.
167  void setArch(ArchType Kind);
168
169  /// setVendor - Set the vendor (second) component of the triple to a
170  /// known type.
171  void setVendor(VendorType Kind);
172
173  /// setOS - Set the operating system (third) component of the triple
174  /// to a known type.
175  void setOS(OSType Kind);
176
177  /// setTriple - Set all components to the new triple \arg Str.
178  void setTriple(const Twine &Str);
179
180  /// setArchName - Set the architecture (first) component of the
181  /// triple by name.
182  void setArchName(const StringRef &Str);
183
184  /// setVendorName - Set the vendor (second) component of the triple
185  /// by name.
186  void setVendorName(const StringRef &Str);
187
188  /// setOSName - Set the operating system (third) component of the
189  /// triple by name.
190  void setOSName(const StringRef &Str);
191
192  /// setEnvironmentName - Set the optional environment (fourth)
193  /// component of the triple by name.
194  void setEnvironmentName(const StringRef &Str);
195
196  /// setOSAndEnvironmentName - Set the operating system and optional
197  /// environment components with a single string.
198  void setOSAndEnvironmentName(const StringRef &Str);
199
200  /// @}
201  /// @name Static helpers for IDs.
202  /// @{
203
204  /// getArchTypeName - Get the canonical name for the \arg Kind
205  /// architecture.
206  static const char *getArchTypeName(ArchType Kind);
207
208  /// getVendorTypeName - Get the canonical name for the \arg Kind
209  /// vendor.
210  static const char *getVendorTypeName(VendorType Kind);
211
212  /// getOSTypeName - Get the canonical name for the \arg Kind vendor.
213  static const char *getOSTypeName(OSType Kind);
214
215  /// @}
216};
217
218} // End llvm namespace
219
220
221#endif
222