1
//===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
3
// The LLVM Compiler Infrastructure
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
8
//===----------------------------------------------------------------------===//
10
#ifndef LLVM_ADT_TRIPLE_H
11
#define LLVM_ADT_TRIPLE_H
13
#include "llvm/ADT/StringRef.h"
16
// Some system headers or GCC predefined macros conflict with identifiers in
17
// this file. Undefine them here.
25
/// Triple - Helper class for working with target triples.
27
/// Target triples are strings in the canonical form:
28
/// ARCHITECTURE-VENDOR-OPERATING_SYSTEM
30
/// ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
32
/// This class is used for clients which want to support arbitrary
33
/// target triples, but also want to implement certain special
34
/// behavior for particular targets. This class isolates the mapping
35
/// from the components of the target triple to well known IDs.
37
/// At its core the Triple class is designed to be a wrapper for a triple
38
/// string; the constructor does not change or normalize the triple string.
39
/// Clients that need to handle the non-canonical triples that users often
40
/// specify should use the normalize method.
42
/// See autoconf/config.guess for a glimpse into what triples look like in
49
alpha, // Alpha: alpha
50
arm, // ARM; arm, armv.*, xscale
51
bfin, // Blackfin: bfin
52
cellspu, // CellSPU: spu, cellspu
53
mips, // MIPS: mips, mipsallegrex
54
mipsel, // MIPSEL: mipsel, mipsallegrexel, psp
55
msp430, // MSP430: msp430
56
pic16, // PIC16: pic16
58
ppc64, // PPC64: powerpc64, ppu
59
sparc, // Sparc: sparc
60
sparcv9, // Sparcv9: Sparcv9
61
systemz, // SystemZ: s390x
62
tce, // TCE (http://tce.cs.tut.fi/): tce
63
thumb, // Thumb: thumb, thumbv.*
65
x86_64, // X86-64: amd64, x86_64
66
xcore, // XCore: xcore
67
mblaze, // MBlaze: mblaze
101
/// The parsed arch type (or InvalidArch if uninitialized).
102
mutable ArchType Arch;
104
/// The parsed vendor type.
105
mutable VendorType Vendor;
107
/// The parsed OS type.
110
bool isInitialized() const { return Arch != InvalidArch; }
111
static ArchType ParseArch(StringRef ArchName);
112
static VendorType ParseVendor(StringRef VendorName);
113
static OSType ParseOS(StringRef OSName);
117
/// @name Constructors
120
Triple() : Data(), Arch(InvalidArch) {}
121
explicit Triple(StringRef Str) : Data(Str), Arch(InvalidArch) {}
122
explicit Triple(StringRef ArchStr, StringRef VendorStr, StringRef OSStr)
123
: Data(ArchStr), Arch(InvalidArch) {
131
/// @name Normalization
134
/// normalize - Turn an arbitrary machine specification into the canonical
135
/// triple form (or something sensible that the Triple class understands if
136
/// nothing better can reasonably be done). In particular, it handles the
137
/// common case in which otherwise valid components are in the wrong order.
138
static std::string normalize(StringRef Str);
141
/// @name Typed Component Access
144
/// getArch - Get the parsed architecture type of this triple.
145
ArchType getArch() const {
146
if (!isInitialized()) Parse();
150
/// getVendor - Get the parsed vendor type of this triple.
151
VendorType getVendor() const {
152
if (!isInitialized()) Parse();
156
/// getOS - Get the parsed operating system type of this triple.
157
OSType getOS() const {
158
if (!isInitialized()) Parse();
162
/// hasEnvironment - Does this triple have the optional environment
163
/// (fourth) component?
164
bool hasEnvironment() const {
165
return getEnvironmentName() != "";
169
/// @name Direct Component Access
172
const std::string &str() const { return Data; }
174
const std::string &getTriple() const { return Data; }
176
/// getArchName - Get the architecture (first) component of the
178
StringRef getArchName() const;
180
/// getVendorName - Get the vendor (second) component of the triple.
181
StringRef getVendorName() const;
183
/// getOSName - Get the operating system (third) component of the
185
StringRef getOSName() const;
187
/// getEnvironmentName - Get the optional environment (fourth)
188
/// component of the triple, or "" if empty.
189
StringRef getEnvironmentName() const;
191
/// getOSAndEnvironmentName - Get the operating system and optional
192
/// environment components as a single string (separated by a '-'
193
/// if the environment component is present).
194
StringRef getOSAndEnvironmentName() const;
197
/// getDarwinNumber - Parse the 'darwin number' out of the specific target
198
/// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
199
/// not defined, return 0's. This requires that the triple have an OSType of
200
/// darwin before it is called.
201
void getDarwinNumber(unsigned &Maj, unsigned &Min, unsigned &Revision) const;
203
/// getDarwinMajorNumber - Return just the major version number, this is
204
/// specialized because it is a common query.
205
unsigned getDarwinMajorNumber() const {
206
unsigned Maj, Min, Rev;
207
getDarwinNumber(Maj, Min, Rev);
215
/// setArch - Set the architecture (first) component of the triple
217
void setArch(ArchType Kind);
219
/// setVendor - Set the vendor (second) component of the triple to a
221
void setVendor(VendorType Kind);
223
/// setOS - Set the operating system (third) component of the triple
225
void setOS(OSType Kind);
227
/// setTriple - Set all components to the new triple \arg Str.
228
void setTriple(const Twine &Str);
230
/// setArchName - Set the architecture (first) component of the
232
void setArchName(StringRef Str);
234
/// setVendorName - Set the vendor (second) component of the triple
236
void setVendorName(StringRef Str);
238
/// setOSName - Set the operating system (third) component of the
240
void setOSName(StringRef Str);
242
/// setEnvironmentName - Set the optional environment (fourth)
243
/// component of the triple by name.
244
void setEnvironmentName(StringRef Str);
246
/// setOSAndEnvironmentName - Set the operating system and optional
247
/// environment components with a single string.
248
void setOSAndEnvironmentName(StringRef Str);
250
/// getArchNameForAssembler - Get an architecture name that is understood by
251
/// the target assembler.
252
const char *getArchNameForAssembler();
255
/// @name Static helpers for IDs.
258
/// getArchTypeName - Get the canonical name for the \arg Kind
260
static const char *getArchTypeName(ArchType Kind);
262
/// getArchTypePrefix - Get the "prefix" canonical name for the \arg Kind
263
/// architecture. This is the prefix used by the architecture specific
264
/// builtins, and is suitable for passing to \see
265
/// Intrinsic::getIntrinsicForGCCBuiltin().
267
/// \return - The architecture prefix, or 0 if none is defined.
268
static const char *getArchTypePrefix(ArchType Kind);
270
/// getVendorTypeName - Get the canonical name for the \arg Kind
272
static const char *getVendorTypeName(VendorType Kind);
274
/// getOSTypeName - Get the canonical name for the \arg Kind vendor.
275
static const char *getOSTypeName(OSType Kind);
278
/// @name Static helpers for converting alternate architecture names.
281
/// getArchTypeForLLVMName - The canonical type for the given LLVM
282
/// architecture name (e.g., "x86").
283
static ArchType getArchTypeForLLVMName(StringRef Str);
285
/// getArchTypeForDarwinArchName - Get the architecture type for a "Darwin"
286
/// architecture name, for example as accepted by "gcc -arch" (see also
288
static ArchType getArchTypeForDarwinArchName(StringRef Str);
293
} // End llvm namespace