blob: d1158a6c6fc20563deb49320b0e7552cce8db817 [file] [log] [blame]
Chris Lattner5ba61f02006-10-14 07:39:34 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5ba61f02006-10-14 07:39:34 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek6f6ff372007-12-12 18:05:32 +000011// target triple.
Chris Lattner5ba61f02006-10-14 07:39:34 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5abdec72009-06-14 01:05:48 +000015#include "clang/Basic/Builtins.h"
16#include "clang/Basic/TargetBuiltins.h"
Chris Lattner5ba61f02006-10-14 07:39:34 +000017#include "clang/Basic/TargetInfo.h"
Chris Lattnerc7c6dd42008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Anders Carlsson5fa3f342007-11-24 23:38:12 +000019#include "llvm/ADT/STLExtras.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000020#include "llvm/ADT/APFloat.h"
Chris Lattner1e1c0b92009-03-20 16:06:38 +000021#include "llvm/ADT/SmallString.h"
Chris Lattner5ba61f02006-10-14 07:39:34 +000022using namespace clang;
23
Chris Lattner5ba61f02006-10-14 07:39:34 +000024//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000025// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000026//===----------------------------------------------------------------------===//
27
Chris Lattnerb2d486a2007-10-06 06:57:34 +000028static void Define(std::vector<char> &Buf, const char *Macro,
29 const char *Val = "1") {
30 const char *Def = "#define ";
31 Buf.insert(Buf.end(), Def, Def+strlen(Def));
32 Buf.insert(Buf.end(), Macro, Macro+strlen(Macro));
33 Buf.push_back(' ');
34 Buf.insert(Buf.end(), Val, Val+strlen(Val));
35 Buf.push_back('\n');
36}
37
Chris Lattner1e1c0b92009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000041static void DefineStd(std::vector<char> &Buf, const char *MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000044
Chris Lattner1e1c0b92009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
48 Define(Buf, MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000049
Chris Lattner1e1c0b92009-03-20 16:06:38 +000050 // Define __unix.
51 llvm::SmallString<20> TmpStr;
52 TmpStr = "__";
53 TmpStr += MacroName;
54 Define(Buf, TmpStr.c_str());
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000055
Chris Lattner1e1c0b92009-03-20 16:06:38 +000056 // Define __unix__.
57 TmpStr += "__";
58 Define(Buf, TmpStr.c_str());
59}
60
Chris Lattner09d98f52008-10-05 21:50:58 +000061//===----------------------------------------------------------------------===//
62// Defines specific to certain operating systems.
63//===----------------------------------------------------------------------===//
64
Douglas Gregor4871c472009-05-21 23:51:30 +000065static void getSolarisDefines(const LangOptions &Opts, std::vector<char> &Defs) {
66 DefineStd(Defs, "sun", Opts);
67 DefineStd(Defs, "unix", Opts);
Eli Friedman79426742009-05-22 01:12:57 +000068 Define(Defs, "__ELF__");
69 Define(Defs, "__svr4__");
70 Define(Defs, "__SVR4");
Eli Friedmanda8f5a92008-08-20 07:28:14 +000071}
Chris Lattner5ba61f02006-10-14 07:39:34 +000072
Chris Lattnera1321f12009-03-20 15:55:34 +000073static void getFreeBSDDefines(const LangOptions &Opts, bool is64Bit,
74 const char *Triple, std::vector<char> &Defs) {
Chris Lattner3c3e2cc2008-10-16 17:04:31 +000075 // FreeBSD defines; list based off of gcc output
76
77 const char *FreeBSD = strstr(Triple, "-freebsd");
78 FreeBSD += strlen("-freebsd");
79 char release[] = "X";
80 release[0] = FreeBSD[0];
81 char version[] = "X00001";
82 version[0] = FreeBSD[0];
83
84 Define(Defs, "__FreeBSD__", release);
85 Define(Defs, "__FreeBSD_cc_version", version);
86 Define(Defs, "__KPRINTF_ATTRIBUTE__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000087 DefineStd(Defs, "unix", Opts);
Anton Korobeynikov7e965952009-02-14 16:42:50 +000088 Define(Defs, "__ELF__", "1");
Chris Lattner3c3e2cc2008-10-16 17:04:31 +000089 if (is64Bit) {
90 Define(Defs, "__LP64__");
91 }
92}
93
Chris Lattnera1321f12009-03-20 15:55:34 +000094static void getDragonFlyDefines(const LangOptions &Opts,
95 std::vector<char> &Defs) {
Chris Lattner09d98f52008-10-05 21:50:58 +000096 // DragonFly defines; list based off of gcc output
97 Define(Defs, "__DragonFly__");
98 Define(Defs, "__DragonFly_cc_version", "100001");
99 Define(Defs, "__ELF__");
100 Define(Defs, "__KPRINTF_ATTRIBUTE__");
101 Define(Defs, "__tune_i386__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +0000102 DefineStd(Defs, "unix", Opts);
Chris Lattner09d98f52008-10-05 21:50:58 +0000103}
104
Chris Lattnera1321f12009-03-20 15:55:34 +0000105static void getLinuxDefines(const LangOptions &Opts, std::vector<char> &Defs) {
Chris Lattner09d98f52008-10-05 21:50:58 +0000106 // Linux defines; list based off of gcc output
Chris Lattner1e1c0b92009-03-20 16:06:38 +0000107 DefineStd(Defs, "unix", Opts);
108 DefineStd(Defs, "linux", Opts);
Chris Lattner09d98f52008-10-05 21:50:58 +0000109 Define(Defs, "__gnu_linux__");
Argyrios Kyrtzidisd831cac2009-02-14 15:02:45 +0000110 Define(Defs, "__ELF__", "1");
Chris Lattner09d98f52008-10-05 21:50:58 +0000111}
112
Chris Lattner2ca529c2008-12-04 23:20:07 +0000113/// getDarwinNumber - Parse the 'darwin number' out of the specific targe
Daniel Dunbar497ff132009-04-10 19:52:24 +0000114/// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
Chris Lattner2ca529c2008-12-04 23:20:07 +0000115/// not defined, return 0's. Return true if we have -darwin in the string or
116/// false otherwise.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000117static bool getDarwinNumber(const char *Triple, unsigned &Maj, unsigned &Min, unsigned &Revision) {
118 Maj = Min = Revision = 0;
Chris Lattner2ca529c2008-12-04 23:20:07 +0000119 const char *Darwin = strstr(Triple, "-darwin");
120 if (Darwin == 0) return false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000121
Chris Lattner2ca529c2008-12-04 23:20:07 +0000122 Darwin += strlen("-darwin");
123 if (Darwin[0] < '0' || Darwin[0] > '9')
124 return true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000125
Chris Lattner2ca529c2008-12-04 23:20:07 +0000126 Maj = Darwin[0]-'0';
127 ++Darwin;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000128
Chris Lattner2ca529c2008-12-04 23:20:07 +0000129 // Handle "darwin11".
130 if (Maj == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
Daniel Dunbar497ff132009-04-10 19:52:24 +0000131 Maj = Maj*10 + (Darwin[0] - '0');
Chris Lattner2ca529c2008-12-04 23:20:07 +0000132 ++Darwin;
133 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000134
Chris Lattner2ca529c2008-12-04 23:20:07 +0000135 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
Daniel Dunbar497ff132009-04-10 19:52:24 +0000136 if (Darwin[0] != '.')
137 return true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000138
Daniel Dunbar497ff132009-04-10 19:52:24 +0000139 ++Darwin;
140 if (Darwin[0] < '0' || Darwin[0] > '9')
141 return true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000142
Daniel Dunbar497ff132009-04-10 19:52:24 +0000143 Min = Darwin[0]-'0';
144 ++Darwin;
145
146 // Handle 10.4.11 -> darwin8.11
147 if (Min == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
148 Min = Min*10 + (Darwin[0] - '0');
149 ++Darwin;
150 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000151
Daniel Dunbar497ff132009-04-10 19:52:24 +0000152 // Handle revision darwin8.9.1
153 if (Darwin[0] != '.')
154 return true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000155
Daniel Dunbar497ff132009-04-10 19:52:24 +0000156 ++Darwin;
157 if (Darwin[0] < '0' || Darwin[0] > '9')
158 return true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000159
Daniel Dunbar497ff132009-04-10 19:52:24 +0000160 Revision = Darwin[0]-'0';
161 ++Darwin;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000162
Daniel Dunbar497ff132009-04-10 19:52:24 +0000163 if (Revision == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
164 Revision = Revision*10 + (Darwin[0] - '0');
165 ++Darwin;
166 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000167
Chris Lattner2ca529c2008-12-04 23:20:07 +0000168 return true;
169}
170
Daniel Dunbar497ff132009-04-10 19:52:24 +0000171static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
Chris Lattner2fe5b262009-06-23 00:43:21 +0000172 Define(Defs, "__APPLE_CC__", "5621");
Eli Friedman3fd920a2008-08-20 02:34:37 +0000173 Define(Defs, "__APPLE__");
174 Define(Defs, "__MACH__");
Chris Lattner81813122009-02-05 07:19:24 +0000175 Define(Defs, "OBJC_NEW_PROPERTIES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000176
Chris Lattner2a5c0a32009-04-07 16:50:40 +0000177 // __weak is always defined, for use in blocks and with objc pointers.
178 Define(Defs, "__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000179
Chris Lattner2a5c0a32009-04-07 16:50:40 +0000180 // Darwin defines __strong even in C mode (just to nothing).
181 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Chris Lattnerc2d14012009-04-07 04:48:21 +0000182 Define(Defs, "__strong", "");
Chris Lattner2a5c0a32009-04-07 16:50:40 +0000183 else
Chris Lattnerc2d14012009-04-07 04:48:21 +0000184 Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000185
186 if (Opts.Static)
187 Define(Defs, "__STATIC__");
188 else
189 Define(Defs, "__DYNAMIC__");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000190}
191
192static void getDarwinOSXDefines(std::vector<char> &Defs, const char *Triple) {
Chris Lattnerb3793bb2008-09-30 01:00:25 +0000193 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000194 unsigned Maj, Min, Rev;
195 if (getDarwinNumber(Triple, Maj, Min, Rev)) {
196 char MacOSXStr[] = "1000";
Chris Lattner2ca529c2008-12-04 23:20:07 +0000197 if (Maj >= 4 && Maj <= 13) { // 10.0-10.9
198 // darwin7 -> 1030, darwin8 -> 1040, darwin9 -> 1050, etc.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000199 MacOSXStr[2] = '0' + Maj-4;
200 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000201
Daniel Dunbar497ff132009-04-10 19:52:24 +0000202 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
203 // Cap 10.4.11 -> darwin8.11 -> "1049"
204 MacOSXStr[3] = std::min(Min, 9U)+'0';
205 Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);
206 }
207}
208
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000209static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
Daniel Dunbar497ff132009-04-10 19:52:24 +0000210 const char *Triple) {
211 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
212 unsigned Maj, Min, Rev;
213 if (getDarwinNumber(Triple, Maj, Min, Rev)) {
214 // When targetting iPhone OS, interpret the minor version and
215 // revision as the iPhone OS version
216 char iPhoneOSStr[] = "10000";
217 if (Min >= 2 && Min <= 9) { // iPhone OS 2.0-9.0
218 // darwin9.2.0 -> 20000, darwin9.3.0 -> 30000, etc.
219 iPhoneOSStr[0] = '0' + Min;
Chris Lattnerb3793bb2008-09-30 01:00:25 +0000220 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000221
Daniel Dunbar497ff132009-04-10 19:52:24 +0000222 // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
223 iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000224 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
Daniel Dunbar497ff132009-04-10 19:52:24 +0000225 iPhoneOSStr);
Chris Lattnerb3793bb2008-09-30 01:00:25 +0000226 }
Eli Friedman3fd920a2008-08-20 02:34:37 +0000227}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000228
Chris Lattner2ca529c2008-12-04 23:20:07 +0000229/// GetDarwinLanguageOptions - Set the default language options for darwin.
230static void GetDarwinLanguageOptions(LangOptions &Opts,
231 const char *Triple) {
232 Opts.NeXTRuntime = true;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000233
Daniel Dunbar497ff132009-04-10 19:52:24 +0000234 unsigned Maj, Min, Rev;
235 if (!getDarwinNumber(Triple, Maj, Min, Rev))
Chris Lattner2ca529c2008-12-04 23:20:07 +0000236 return;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000237
Bill Wendlingd63bbad2009-06-28 07:36:13 +0000238 // Blocks and stack protectors default to on for 10.6 (darwin10) and beyond.
239 if (Maj > 9) {
Chris Lattner2ca529c2008-12-04 23:20:07 +0000240 Opts.Blocks = 1;
Bill Wendlingd63bbad2009-06-28 07:36:13 +0000241 Opts.StackProtector = 1;
242 }
Fariborz Jahanian240f2b72009-02-24 23:34:44 +0000243
Bill Wendlingd63bbad2009-06-28 07:36:13 +0000244 // Non-fragile ABI (in 64-bit mode) default to on for 10.5 (darwin9) and
245 // beyond.
Fariborz Jahanian30b3ac52009-02-24 23:38:42 +0000246 if (Maj >= 9 && Opts.ObjC1 && !strncmp(Triple, "x86_64", 6))
247 Opts.ObjCNonFragileABI = 1;
Chris Lattner2ca529c2008-12-04 23:20:07 +0000248}
249
Eli Friedmanaa27a872009-06-08 06:11:14 +0000250/// GetWindowsLanguageOptions - Set the default language options for Windows.
251static void GetWindowsLanguageOptions(LangOptions &Opts,
252 const char *Triple) {
253 Opts.Microsoft = true;
254}
Chris Lattner2ca529c2008-12-04 23:20:07 +0000255
Chris Lattner09d98f52008-10-05 21:50:58 +0000256//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000257// Specific target implementations.
258//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000259
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000260namespace {
261// PPC abstract base class
262class PPCTargetInfo : public TargetInfo {
263 static const Builtin::Info BuiltinInfo[];
264 static const char * const GCCRegNames[];
265 static const TargetInfo::GCCRegAlias GCCRegAliases[];
266
267public:
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000268 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
269
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000270 virtual void getTargetBuiltins(const Builtin::Info *&Records,
271 unsigned &NumRecords) const {
Chris Lattner10a5b382007-01-29 05:24:35 +0000272 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000273 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000274 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000275
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000276 virtual void getTargetDefines(const LangOptions &Opts,
277 std::vector<char> &Defines) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000278
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000279 virtual const char *getVAListDeclaration() const {
Chris Lattner69f9bc22008-10-27 01:11:29 +0000280 return "typedef char* __builtin_va_list;";
281 // This is the right definition for ABI/V4: System V.4/eabi.
282 /*return "typedef struct __va_list_tag {"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000283 " unsigned char gpr;"
284 " unsigned char fpr;"
285 " unsigned short reserved;"
286 " void* overflow_arg_area;"
287 " void* reg_save_area;"
Chris Lattner69f9bc22008-10-27 01:11:29 +0000288 "} __builtin_va_list[1];";*/
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000289 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000290 virtual const char *getTargetPrefix() const {
291 return "ppc";
Anders Carlssonf511f642007-11-27 04:11:28 +0000292 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000293 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000294 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000295 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000296 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +0000297 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000298 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000299 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000300 default: return false;
301 case 'O': // Zero
302 return true;
303 case 'b': // Base register
304 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000305 Info.setAllowsRegister();
Anders Carlssonf511f642007-11-27 04:11:28 +0000306 return true;
307 }
308 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000309 virtual void getDefaultLangOptions(LangOptions &Opts) {
310 TargetInfo::getDefaultLangOptions(Opts);
311 Opts.CharIsSigned = false;
312 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000313 virtual const char *getClobbers() const {
314 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000315 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000316};
Anders Carlssonf511f642007-11-27 04:11:28 +0000317
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000318const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor9eebd972009-02-16 21:58:21 +0000319#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
320#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner5abdec72009-06-14 01:05:48 +0000321#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000322};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000323
324
Chris Lattnerecd49032009-03-02 22:27:17 +0000325/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
326/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000327void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
328 std::vector<char> &Defs) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000329 // Target identification.
330 Define(Defs, "__ppc__");
331 Define(Defs, "_ARCH_PPC");
332 Define(Defs, "__POWERPC__");
333 if (PointerWidth == 64) {
334 Define(Defs, "_ARCH_PPC64");
335 Define(Defs, "_LP64");
336 Define(Defs, "__LP64__");
337 Define(Defs, "__ppc64__");
338 } else {
339 Define(Defs, "__ppc__");
340 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000341
Chris Lattnerecd49032009-03-02 22:27:17 +0000342 // Target properties.
343 Define(Defs, "_BIG_ENDIAN");
344 Define(Defs, "__BIG_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000345
Chris Lattnerecd49032009-03-02 22:27:17 +0000346 // Subtarget options.
347 Define(Defs, "__NATURAL_ALIGNMENT__");
348 Define(Defs, "__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000349
Chris Lattnerecd49032009-03-02 22:27:17 +0000350 // FIXME: Should be controlled by command line option.
351 Define(Defs, "__LONG_DOUBLE_128__");
352}
353
Chris Lattner17df24e2008-04-21 18:56:49 +0000354
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000355const char * const PPCTargetInfo::GCCRegNames[] = {
356 "0", "1", "2", "3", "4", "5", "6", "7",
357 "8", "9", "10", "11", "12", "13", "14", "15",
358 "16", "17", "18", "19", "20", "21", "22", "23",
359 "24", "25", "26", "27", "28", "29", "30", "31",
360 "0", "1", "2", "3", "4", "5", "6", "7",
361 "8", "9", "10", "11", "12", "13", "14", "15",
362 "16", "17", "18", "19", "20", "21", "22", "23",
363 "24", "25", "26", "27", "28", "29", "30", "31",
364 "mq", "lr", "ctr", "ap",
365 "0", "1", "2", "3", "4", "5", "6", "7",
366 "xer",
367 "0", "1", "2", "3", "4", "5", "6", "7",
368 "8", "9", "10", "11", "12", "13", "14", "15",
369 "16", "17", "18", "19", "20", "21", "22", "23",
370 "24", "25", "26", "27", "28", "29", "30", "31",
371 "vrsave", "vscr",
372 "spe_acc", "spefscr",
373 "sfp"
374};
Chris Lattner10a5b382007-01-29 05:24:35 +0000375
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000376void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000377 unsigned &NumNames) const {
378 Names = GCCRegNames;
379 NumNames = llvm::array_lengthof(GCCRegNames);
380}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000381
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000382const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
383 // While some of these aliases do map to different registers
384 // they still share the same register name.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000385 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
386 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
387 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
388 { { "cr3", "fr3", "r3", "v3"}, "3" },
389 { { "cr4", "fr4", "r4", "v4"}, "4" },
390 { { "cr5", "fr5", "r5", "v5"}, "5" },
391 { { "cr6", "fr6", "r6", "v6"}, "6" },
392 { { "cr7", "fr7", "r7", "v7"}, "7" },
393 { { "fr8", "r8", "v8"}, "8" },
394 { { "fr9", "r9", "v9"}, "9" },
395 { { "fr10", "r10", "v10"}, "10" },
396 { { "fr11", "r11", "v11"}, "11" },
397 { { "fr12", "r12", "v12"}, "12" },
398 { { "fr13", "r13", "v13"}, "13" },
399 { { "fr14", "r14", "v14"}, "14" },
400 { { "fr15", "r15", "v15"}, "15" },
401 { { "fr16", "r16", "v16"}, "16" },
402 { { "fr17", "r17", "v17"}, "17" },
403 { { "fr18", "r18", "v18"}, "18" },
404 { { "fr19", "r19", "v19"}, "19" },
405 { { "fr20", "r20", "v20"}, "20" },
406 { { "fr21", "r21", "v21"}, "21" },
407 { { "fr22", "r22", "v22"}, "22" },
408 { { "fr23", "r23", "v23"}, "23" },
409 { { "fr24", "r24", "v24"}, "24" },
410 { { "fr25", "r25", "v25"}, "25" },
411 { { "fr26", "r26", "v26"}, "26" },
412 { { "fr27", "r27", "v27"}, "27" },
413 { { "fr28", "r28", "v28"}, "28" },
414 { { "fr29", "r29", "v29"}, "29" },
415 { { "fr30", "r30", "v30"}, "30" },
416 { { "fr31", "r31", "v31"}, "31" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000417};
418
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000419void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000420 unsigned &NumAliases) const {
421 Aliases = GCCRegAliases;
422 NumAliases = llvm::array_lengthof(GCCRegAliases);
423}
424} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +0000425
Chris Lattner5ba61f02006-10-14 07:39:34 +0000426namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000427class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000428public:
Eli Friedman873f65a2008-08-21 00:13:15 +0000429 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
430 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
431 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
432 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000433};
434} // end anonymous namespace.
435
436namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000437class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000438public:
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000439 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000440 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman873f65a2008-08-21 00:13:15 +0000441 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
442 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000443 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000444};
445} // end anonymous namespace.
446
Chris Lattner2ca529c2008-12-04 23:20:07 +0000447
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000448namespace {
449class DarwinPPCTargetInfo : public PPC32TargetInfo {
450public:
451 DarwinPPCTargetInfo(const std::string& triple) : PPC32TargetInfo(triple) {}
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000452 virtual void getTargetDefines(const LangOptions &Opts,
453 std::vector<char> &Defines) const {
454 PPC32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000455 getDarwinDefines(Defines, Opts);
456 getDarwinOSXDefines(Defines, getTargetTriple());
Chris Lattner10a5b382007-01-29 05:24:35 +0000457 }
Daniel Dunbarb8767ac2008-08-23 08:43:39 +0000458
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000459 /// getDefaultLangOptions - Allow the target to specify default settings for
460 /// various language options. These may be overridden by command line
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000461 /// options.
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000462 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000463 PPC32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattner2ca529c2008-12-04 23:20:07 +0000464 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000465 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000466};
467} // end anonymous namespace.
468
469namespace {
470class DarwinPPC64TargetInfo : public PPC64TargetInfo {
471public:
472 DarwinPPC64TargetInfo(const std::string& triple) : PPC64TargetInfo(triple) {}
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000473 virtual void getTargetDefines(const LangOptions &Opts,
474 std::vector<char> &Defines) const {
475 PPC64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000476 getDarwinDefines(Defines, Opts);
477 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000478 }
Daniel Dunbarb8767ac2008-08-23 08:43:39 +0000479
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000480 /// getDefaultLangOptions - Allow the target to specify default settings for
481 /// various language options. These may be overridden by command line
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000482 /// options.
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000483 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000484 PPC64TargetInfo::getDefaultLangOptions(Opts);
Chris Lattner2ca529c2008-12-04 23:20:07 +0000485 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000486 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000487};
488} // end anonymous namespace.
489
490namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000491// Namespace for x86 abstract base class
492const Builtin::Info BuiltinInfo[] = {
Douglas Gregor9eebd972009-02-16 21:58:21 +0000493#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
494#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner5abdec72009-06-14 01:05:48 +0000495#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +0000496};
Eli Friedmanb5366062008-05-20 14:21:01 +0000497
Eli Friedman3fd920a2008-08-20 02:34:37 +0000498const char *GCCRegNames[] = {
499 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
500 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
501 "argp", "flags", "fspr", "dirflag", "frame",
502 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
503 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
504 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
505 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
506};
507
508const TargetInfo::GCCRegAlias GCCRegAliases[] = {
509 { { "al", "ah", "eax", "rax" }, "ax" },
510 { { "bl", "bh", "ebx", "rbx" }, "bx" },
511 { { "cl", "ch", "ecx", "rcx" }, "cx" },
512 { { "dl", "dh", "edx", "rdx" }, "dx" },
513 { { "esi", "rsi" }, "si" },
514 { { "edi", "rdi" }, "di" },
515 { { "esp", "rsp" }, "sp" },
516 { { "ebp", "rbp" }, "bp" },
517};
518
519// X86 target abstract base class; x86-32 and x86-64 are very close, so
520// most of the implementation can be shared.
521class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +0000522 enum X86SSEEnum {
523 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
524 } SSELevel;
Eli Friedman3fd920a2008-08-20 02:34:37 +0000525public:
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000526 X86TargetInfo(const std::string& triple)
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000527 : TargetInfo(triple), SSELevel(NoMMXSSE) {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000528 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +0000529 }
Chris Lattner10a5b382007-01-29 05:24:35 +0000530 virtual void getTargetBuiltins(const Builtin::Info *&Records,
531 unsigned &NumRecords) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000532 Records = BuiltinInfo;
533 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000534 }
Anders Carlsson050f4942007-12-08 19:32:57 +0000535 virtual const char *getTargetPrefix() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000536 return "x86";
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000537 }
538 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman3fd920a2008-08-20 02:34:37 +0000539 unsigned &NumNames) const {
540 Names = GCCRegNames;
541 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000542 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000543 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000544 unsigned &NumAliases) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000545 Aliases = GCCRegAliases;
546 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlssona7408e72007-10-13 00:45:48 +0000547 }
Anders Carlsson58436352009-02-28 17:11:49 +0000548 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman3fd920a2008-08-20 02:34:37 +0000549 TargetInfo::ConstraintInfo &info) const;
550 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlssonf511f642007-11-27 04:11:28 +0000551 virtual const char *getClobbers() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000552 return "~{dirflag},~{fpsr},~{flags}";
553 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000554 virtual void getTargetDefines(const LangOptions &Opts,
555 std::vector<char> &Defines) const;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +0000556 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
557 const std::string &Name,
558 bool Enabled) const;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000559 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +0000560 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000561 virtual void HandleTargetFeatures(const llvm::StringMap<bool> &Features);
Chris Lattner5ba61f02006-10-14 07:39:34 +0000562};
Chris Lattnerc25d8a72009-03-02 22:20:04 +0000563
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000564void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +0000565 llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000566 // FIXME: This should not be here.
567 Features["3dnow"] = false;
568 Features["3dnowa"] = false;
569 Features["mmx"] = false;
570 Features["sse"] = false;
571 Features["sse2"] = false;
572 Features["sse3"] = false;
573 Features["ssse3"] = false;
574 Features["sse41"] = false;
575 Features["sse42"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000576
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000577 // LLVM does not currently recognize this.
578 // Features["sse4a"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000579
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000580 // FIXME: This *really* should not be here.
581
582 // X86_64 always has SSE2.
583 if (PointerWidth == 64)
584 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
585
Daniel Dunbarf9d90272009-05-06 21:56:32 +0000586 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
587 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
588 ;
589 else if (CPU == "pentium-mmx" || CPU == "pentium2")
590 setFeatureEnabled(Features, "mmx", true);
591 else if (CPU == "pentium3")
592 setFeatureEnabled(Features, "sse", true);
593 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
594 setFeatureEnabled(Features, "sse2", true);
595 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
596 setFeatureEnabled(Features, "sse3", true);
597 else if (CPU == "core2")
598 setFeatureEnabled(Features, "ssse3", true);
599 else if (CPU == "penryn") {
600 setFeatureEnabled(Features, "sse4", true);
601 Features["sse42"] = false;
602 } else if (CPU == "atom")
603 setFeatureEnabled(Features, "sse3", true);
604 else if (CPU == "corei7")
605 setFeatureEnabled(Features, "sse4", true);
606 else if (CPU == "k6" || CPU == "winchip-c6")
607 setFeatureEnabled(Features, "mmx", true);
608 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
609 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
610 setFeatureEnabled(Features, "mmx", true);
611 setFeatureEnabled(Features, "3dnow", true);
612 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
613 setFeatureEnabled(Features, "sse", true);
614 setFeatureEnabled(Features, "3dnowa", true);
615 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
616 CPU == "athlon-fx") {
617 setFeatureEnabled(Features, "sse2", true);
618 setFeatureEnabled(Features, "3dnowa", true);
619 } else if (CPU == "c3-2")
620 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000621}
622
Daniel Dunbarbb36aed2009-05-06 21:07:50 +0000623bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
624 const std::string &Name,
625 bool Enabled) const {
626 // FIXME: This *really* should not be here.
627 if (!Features.count(Name) && Name != "sse4")
628 return false;
629
630 if (Enabled) {
631 if (Name == "mmx")
632 Features["mmx"] = true;
633 else if (Name == "sse")
634 Features["mmx"] = Features["sse"] = true;
635 else if (Name == "sse2")
636 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
637 else if (Name == "sse3")
638 Features["mmx"] = Features["sse"] = Features["sse2"] =
639 Features["sse3"] = true;
640 else if (Name == "ssse3")
641 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
642 Features["ssse3"] = true;
643 else if (Name == "sse4")
644 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
645 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
646 else if (Name == "3dnow")
647 Features["3dnowa"] = true;
648 else if (Name == "3dnowa")
649 Features["3dnow"] = Features["3dnowa"] = true;
650 } else {
651 if (Name == "mmx")
652 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
653 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
654 else if (Name == "sse")
655 Features["sse"] = Features["sse2"] = Features["sse3"] =
656 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
657 else if (Name == "sse2")
658 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
659 Features["sse41"] = Features["sse42"] = false;
660 else if (Name == "sse3")
661 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
662 Features["sse42"] = false;
663 else if (Name == "ssse3")
664 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
665 else if (Name == "sse4")
666 Features["sse41"] = Features["sse42"] = false;
667 else if (Name == "3dnow")
668 Features["3dnow"] = Features["3dnowa"] = false;
669 else if (Name == "3dnowa")
670 Features["3dnowa"] = false;
671 }
672
673 return true;
674}
675
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +0000676/// HandleTargetOptions - Perform initialization based on the user
677/// configured set of features.
678void X86TargetInfo::HandleTargetFeatures(const llvm::StringMap<bool>&Features) {
679 if (Features.lookup("sse42"))
680 SSELevel = SSE42;
681 else if (Features.lookup("sse41"))
682 SSELevel = SSE41;
683 else if (Features.lookup("ssse3"))
684 SSELevel = SSSE3;
685 else if (Features.lookup("sse3"))
686 SSELevel = SSE3;
687 else if (Features.lookup("sse2"))
688 SSELevel = SSE2;
689 else if (Features.lookup("sse"))
690 SSELevel = SSE1;
691 else if (Features.lookup("mmx"))
692 SSELevel = MMX;
Chris Lattnerc25d8a72009-03-02 22:20:04 +0000693}
Chris Lattnerecd49032009-03-02 22:27:17 +0000694
695/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
696/// that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000697void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
698 std::vector<char> &Defs) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000699 // Target identification.
700 if (PointerWidth == 64) {
701 Define(Defs, "_LP64");
702 Define(Defs, "__LP64__");
703 Define(Defs, "__amd64__");
704 Define(Defs, "__amd64");
705 Define(Defs, "__x86_64");
706 Define(Defs, "__x86_64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000707 } else {
Chris Lattner1e1c0b92009-03-20 16:06:38 +0000708 DefineStd(Defs, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +0000709 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000710
Chris Lattnerecd49032009-03-02 22:27:17 +0000711 // Target properties.
712 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000713
Chris Lattnerecd49032009-03-02 22:27:17 +0000714 // Subtarget options.
715 Define(Defs, "__nocona");
716 Define(Defs, "__nocona__");
717 Define(Defs, "__tune_nocona__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000718 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner96e43572009-03-02 22:40:39 +0000719
Chris Lattner6df41af2009-04-19 17:32:33 +0000720 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
721 // functions in glibc header files that use FP Stack inline asm which the
722 // backend can't deal with (PR879).
723 Define(Defs, "__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000724
Chris Lattner96e43572009-03-02 22:40:39 +0000725 // Each case falls through to the previous one here.
726 switch (SSELevel) {
727 case SSE42:
728 Define(Defs, "__SSE4_2__");
729 case SSE41:
730 Define(Defs, "__SSE4_1__");
731 case SSSE3:
732 Define(Defs, "__SSSE3__");
733 case SSE3:
734 Define(Defs, "__SSE3__");
735 case SSE2:
736 Define(Defs, "__SSE2__");
737 Define(Defs, "__SSE2_MATH__"); // -mfp-math=sse always implied.
738 case SSE1:
739 Define(Defs, "__SSE__");
740 Define(Defs, "__SSE_MATH__"); // -mfp-math=sse always implied.
741 case MMX:
742 Define(Defs, "__MMX__");
743 case NoMMXSSE:
744 break;
745 }
Chris Lattnerecd49032009-03-02 22:27:17 +0000746}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000747
748
Eli Friedman3fd920a2008-08-20 02:34:37 +0000749bool
Anders Carlsson58436352009-02-28 17:11:49 +0000750X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000751 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000752 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000753 default: return false;
754 case 'a': // eax.
755 case 'b': // ebx.
756 case 'c': // ecx.
757 case 'd': // edx.
758 case 'S': // esi.
759 case 'D': // edi.
760 case 'A': // edx:eax.
761 case 't': // top of floating point stack.
762 case 'u': // second from top of floating point stack.
763 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +0000764 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +0000765 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +0000766 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000767 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +0000768 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000769 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +0000770 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +0000771 case 'N': // unsigned 8-bit integer constant for use with in and out
772 // instructions.
Eli Friedmancf432d32009-06-08 20:45:44 +0000773 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerd9725f72009-04-26 07:16:29 +0000774 Info.setAllowsRegister();
Eli Friedman3fd920a2008-08-20 02:34:37 +0000775 return true;
776 }
777}
778
779std::string
780X86TargetInfo::convertConstraint(const char Constraint) const {
781 switch (Constraint) {
782 case 'a': return std::string("{ax}");
783 case 'b': return std::string("{bx}");
784 case 'c': return std::string("{cx}");
785 case 'd': return std::string("{dx}");
786 case 'S': return std::string("{si}");
787 case 'D': return std::string("{di}");
788 case 't': // top of floating point stack.
789 return std::string("{st}");
790 case 'u': // second from top of floating point stack.
791 return std::string("{st(1)}"); // second from top of floating point stack.
792 default:
793 return std::string(1, Constraint);
794 }
795}
Eli Friedman3fd920a2008-08-20 02:34:37 +0000796} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +0000797
798namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000799// X86-32 generic target
800class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000801public:
Eli Friedman3fd920a2008-08-20 02:34:37 +0000802 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
803 DoubleAlign = LongLongAlign = 32;
804 LongDoubleWidth = 96;
805 LongDoubleAlign = 32;
Eli Friedman873f65a2008-08-21 00:13:15 +0000806 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
807 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
808 "a0:0:64-f80:32:32";
Eli Friedman32ca82a2009-03-29 20:31:09 +0000809 SizeType = UnsignedInt;
810 PtrDiffType = SignedInt;
811 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +0000812 RegParmMax = 3;
Eli Friedman3fd920a2008-08-20 02:34:37 +0000813 }
814 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +0000815 return "typedef char* __builtin_va_list;";
Eli Friedman3fd920a2008-08-20 02:34:37 +0000816 }
Eli Friedman3fd920a2008-08-20 02:34:37 +0000817};
818} // end anonymous namespace
819
820namespace {
821// x86-32 Darwin (OS X) target
822class DarwinI386TargetInfo : public X86_32TargetInfo {
823public:
824 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
825 LongDoubleWidth = 128;
826 LongDoubleAlign = 128;
Eli Friedman32ca82a2009-03-29 20:31:09 +0000827 SizeType = UnsignedLong;
828 IntPtrType = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +0000829 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
830 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
831 "a0:0:64-f80:128:128";
Eli Friedmand88c8a12009-04-19 21:38:35 +0000832 TLSSupported = false;
Eli Friedman3fd920a2008-08-20 02:34:37 +0000833 }
Daniel Dunbar08b216a2009-03-31 23:42:16 +0000834
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000835 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbar08b216a2009-03-31 23:42:16 +0000836 return IsConstant ? "\01LC" : "\01lC";
837 }
838
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000839 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +0000840 return "__utf16_string_";
841 }
842
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000843 virtual const char *getUnicodeStringSection() const {
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +0000844 return "__TEXT,__ustring";
845 }
846
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000847 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbar08b216a2009-03-31 23:42:16 +0000848 return "\01LC";
849 }
850
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000851 virtual void getTargetDefines(const LangOptions &Opts,
852 std::vector<char> &Defines) const {
853 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000854 getDarwinDefines(Defines, Opts);
855 getDarwinOSXDefines(Defines, getTargetTriple());
Eli Friedman3fd920a2008-08-20 02:34:37 +0000856 }
Daniel Dunbar08b216a2009-03-31 23:42:16 +0000857
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000858 /// getDefaultLangOptions - Allow the target to specify default settings for
859 /// various language options. These may be overridden by command line
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000860 /// options.
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000861 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000862 X86_32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattner2ca529c2008-12-04 23:20:07 +0000863 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerc7c6dd42008-12-04 22:54:33 +0000864 }
Eli Friedman3fd920a2008-08-20 02:34:37 +0000865};
866} // end anonymous namespace
867
868namespace {
Chris Lattner3c3e2cc2008-10-16 17:04:31 +0000869// x86-32 FreeBSD target
870class FreeBSDX86_32TargetInfo : public X86_32TargetInfo {
871public:
Eli Friedmand50881c2008-11-02 02:43:55 +0000872 FreeBSDX86_32TargetInfo(const std::string& triple) :
Eli Friedman32ca82a2009-03-29 20:31:09 +0000873 X86_32TargetInfo(triple) { }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000874 virtual void getTargetDefines(const LangOptions &Opts,
875 std::vector<char> &Defines) const {
876 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnera1321f12009-03-20 15:55:34 +0000877 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
Chris Lattner3c3e2cc2008-10-16 17:04:31 +0000878 }
879};
880} // end anonymous namespace
881
882namespace {
Chris Lattner5637ef52008-08-23 18:23:14 +0000883// x86-32 DragonFly target
884class DragonFlyX86_32TargetInfo : public X86_32TargetInfo {
885public:
Eli Friedmand50881c2008-11-02 02:43:55 +0000886 DragonFlyX86_32TargetInfo(const std::string& triple) :
Eli Friedman32ca82a2009-03-29 20:31:09 +0000887 X86_32TargetInfo(triple) { }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000888 virtual void getTargetDefines(const LangOptions &Opts,
889 std::vector<char> &Defines) const {
890 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnera1321f12009-03-20 15:55:34 +0000891 getDragonFlyDefines(Opts, Defines);
Chris Lattner5637ef52008-08-23 18:23:14 +0000892 }
893};
894} // end anonymous namespace
895
896namespace {
Eli Friedmanff594f22008-08-21 00:24:02 +0000897// x86-32 Linux target
898class LinuxX86_32TargetInfo : public X86_32TargetInfo {
899public:
900 LinuxX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
Chris Lattner4ecd7532008-10-05 19:44:25 +0000901 UserLabelPrefix = "";
Eli Friedmanff594f22008-08-21 00:24:02 +0000902 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000903 virtual void getTargetDefines(const LangOptions &Opts,
904 std::vector<char> &Defines) const {
905 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnera1321f12009-03-20 15:55:34 +0000906 getLinuxDefines(Opts, Defines);
Eli Friedmanff594f22008-08-21 00:24:02 +0000907 }
908};
909} // end anonymous namespace
910
911namespace {
Douglas Gregor4871c472009-05-21 23:51:30 +0000912// x86-32 Solaris target
913class SolarisX86_32TargetInfo : public X86_32TargetInfo {
914public:
915 SolarisX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
916 UserLabelPrefix = "";
Eli Friedman79426742009-05-22 01:12:57 +0000917 WCharType = SignedLong;
918 // FIXME: WIntType should be SignedLong
Douglas Gregor4871c472009-05-21 23:51:30 +0000919 }
920 virtual void getTargetDefines(const LangOptions &Opts,
921 std::vector<char> &Defines) const {
922 X86_32TargetInfo::getTargetDefines(Opts, Defines);
923 getSolarisDefines(Opts, Defines);
924 }
925};
926} // end anonymous namespace
927
928
929namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000930// x86-32 Windows target
931class WindowsX86_32TargetInfo : public X86_32TargetInfo {
932public:
933 WindowsX86_32TargetInfo(const std::string& triple)
934 : X86_32TargetInfo(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +0000935 TLSSupported = false;
Chris Lattner46be2e12009-06-24 17:12:15 +0000936 WCharType = UnsignedShort;
Eli Friedmanaa27a872009-06-08 06:11:14 +0000937 WCharWidth = WCharAlign = 16;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +0000938 DoubleAlign = LongLongAlign = 64;
939 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
940 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
941 "a0:0:64-f80:32:32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000942 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000943 virtual void getTargetDefines(const LangOptions &Opts,
944 std::vector<char> &Defines) const {
945 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000946 // This list is based off of the the list of things MingW defines
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000947 Define(Defines, "_WIN32");
Chris Lattner1e1c0b92009-03-20 16:06:38 +0000948 DefineStd(Defines, "WIN32", Opts);
949 DefineStd(Defines, "WINNT", Opts);
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000950 Define(Defines, "_X86_");
951 Define(Defines, "__MSVCRT__");
952 }
Eli Friedmanaa27a872009-06-08 06:11:14 +0000953
954 virtual void getDefaultLangOptions(LangOptions &Opts) {
955 X86_32TargetInfo::getDefaultLangOptions(Opts);
956 GetWindowsLanguageOptions(Opts, getTargetTriple());
957 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +0000958};
959} // end anonymous namespace
960
961namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000962// x86-64 generic target
963class X86_64TargetInfo : public X86TargetInfo {
964public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000965 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000966 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Chris Lattner22ebe7b2009-01-28 06:58:19 +0000967 DoubleAlign = LongLongAlign = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +0000968 LongDoubleWidth = 128;
969 LongDoubleAlign = 128;
Chris Lattnerd0a79b22009-02-05 07:32:46 +0000970 IntMaxType = SignedLong;
971 UIntMaxType = UnsignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +0000972 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +0000973
Eli Friedman873f65a2008-08-21 00:13:15 +0000974 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
975 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Daniel Dunbareed62b72009-06-08 22:39:13 +0000976 "a0:0:64-s0:64:64-f80:128:128";
Chris Lattner10a5b382007-01-29 05:24:35 +0000977 }
Anders Carlssona7408e72007-10-13 00:45:48 +0000978 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +0000979 return "typedef struct __va_list_tag {"
980 " unsigned gp_offset;"
981 " unsigned fp_offset;"
982 " void* overflow_arg_area;"
983 " void* reg_save_area;"
984 "} __builtin_va_list[1];";
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000985 }
Eli Friedman3fd920a2008-08-20 02:34:37 +0000986};
987} // end anonymous namespace
988
989namespace {
Chris Lattner3c3e2cc2008-10-16 17:04:31 +0000990// x86-64 FreeBSD target
991class FreeBSDX86_64TargetInfo : public X86_64TargetInfo {
992public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000993 FreeBSDX86_64TargetInfo(const std::string &triple)
994 : X86_64TargetInfo(triple) {}
995 virtual void getTargetDefines(const LangOptions &Opts,
996 std::vector<char> &Defines) const {
997 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnera1321f12009-03-20 15:55:34 +0000998 getFreeBSDDefines(Opts, 1, getTargetTriple(), Defines);
Chris Lattner3c3e2cc2008-10-16 17:04:31 +0000999 }
1000};
1001} // end anonymous namespace
1002
1003namespace {
Daniel Dunbard0921de2008-09-23 17:37:57 +00001004// x86-64 Linux target
1005class LinuxX86_64TargetInfo : public X86_64TargetInfo {
1006public:
1007 LinuxX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
Chris Lattner4ecd7532008-10-05 19:44:25 +00001008 UserLabelPrefix = "";
Daniel Dunbard0921de2008-09-23 17:37:57 +00001009 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001010 virtual void getTargetDefines(const LangOptions &Opts,
1011 std::vector<char> &Defines) const {
1012 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnera1321f12009-03-20 15:55:34 +00001013 getLinuxDefines(Opts, Defines);
Daniel Dunbard0921de2008-09-23 17:37:57 +00001014 }
1015};
1016} // end anonymous namespace
1017
1018namespace {
Douglas Gregor4871c472009-05-21 23:51:30 +00001019// x86-64 Solaris target
1020class SolarisX86_64TargetInfo : public X86_64TargetInfo {
1021public:
1022 SolarisX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1023 UserLabelPrefix = "";
Douglas Gregor4871c472009-05-21 23:51:30 +00001024 }
1025 virtual void getTargetDefines(const LangOptions &Opts,
1026 std::vector<char> &Defines) const {
1027 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1028 getSolarisDefines(Opts, Defines);
1029 }
1030};
1031} // end anonymous namespace
1032
1033namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001034// x86-64 Darwin (OS X) target
1035class DarwinX86_64TargetInfo : public X86_64TargetInfo {
1036public:
Eli Friedmand88c8a12009-04-19 21:38:35 +00001037 DarwinX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1038 TLSSupported = false;
1039 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001040
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001041 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbar08b216a2009-03-31 23:42:16 +00001042 return IsConstant ? "\01LC" : "\01lC";
1043 }
1044
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001045 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001046 return "__utf16_string_";
1047 }
1048
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001049 virtual const char *getUnicodeStringSection() const {
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001050 return "__TEXT,__ustring";
1051 }
1052
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001053 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbar08b216a2009-03-31 23:42:16 +00001054 return "\01L_unnamed_cfstring_";
1055 }
1056
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001057 virtual void getTargetDefines(const LangOptions &Opts,
1058 std::vector<char> &Defines) const {
1059 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar497ff132009-04-10 19:52:24 +00001060 getDarwinDefines(Defines, Opts);
1061 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001062 }
Daniel Dunbarb8767ac2008-08-23 08:43:39 +00001063
Chris Lattnerc7c6dd42008-12-04 22:54:33 +00001064 /// getDefaultLangOptions - Allow the target to specify default settings for
1065 /// various language options. These may be overridden by command line
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001066 /// options.
Chris Lattnerc7c6dd42008-12-04 22:54:33 +00001067 virtual void getDefaultLangOptions(LangOptions &Opts) {
Chris Lattner2ca529c2008-12-04 23:20:07 +00001068 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerc7c6dd42008-12-04 22:54:33 +00001069 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001070};
1071} // end anonymous namespace.
1072
Chris Lattner17df24e2008-04-21 18:56:49 +00001073namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001074class ARMTargetInfo : public TargetInfo {
Mike Stump9d54bd72009-04-08 02:07:04 +00001075 enum {
1076 Armv4t,
1077 Armv5,
1078 Armv6,
1079 XScale
1080 } ArmArch;
Chris Lattner17df24e2008-04-21 18:56:49 +00001081public:
Eli Friedmanf05b7722008-08-20 07:44:10 +00001082 ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
1083 // FIXME: Are the defaults correct for ARM?
Eli Friedman873f65a2008-08-21 00:13:15 +00001084 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1085 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
Chris Lattner0dc10262009-04-23 04:22:04 +00001086 if (triple.find("arm-") == 0 || triple.find("armv6-") == 0)
Mike Stump9d54bd72009-04-08 02:07:04 +00001087 ArmArch = Armv6;
Chris Lattner0dc10262009-04-23 04:22:04 +00001088 else if (triple.find("armv5-") == 0)
Mike Stump9d54bd72009-04-08 02:07:04 +00001089 ArmArch = Armv5;
Chris Lattner0dc10262009-04-23 04:22:04 +00001090 else if (triple.find("armv4t-") == 0)
Mike Stump9d54bd72009-04-08 02:07:04 +00001091 ArmArch = Armv4t;
Chris Lattner0dc10262009-04-23 04:22:04 +00001092 else if (triple.find("xscale-") == 0)
Mike Stump9d54bd72009-04-08 02:07:04 +00001093 ArmArch = XScale;
Chris Lattner0dc10262009-04-23 04:22:04 +00001094 else if (triple.find("armv") == 0) {
1095 // FIXME: fuzzy match for other random weird arm triples. This is useful
1096 // for the static analyzer and other clients, but probably should be
1097 // re-evaluated when codegen is brought up.
1098 ArmArch = Armv6;
1099 }
Eli Friedmanb5366062008-05-20 14:21:01 +00001100 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001101 virtual void getTargetDefines(const LangOptions &Opts,
1102 std::vector<char> &Defs) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001103 // Target identification.
1104 Define(Defs, "__arm");
1105 Define(Defs, "__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001106
Chris Lattnerecd49032009-03-02 22:27:17 +00001107 // Target properties.
1108 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001109
Mike Stump9d54bd72009-04-08 02:07:04 +00001110 // Subtarget options.
1111 if (ArmArch == Armv6) {
1112 Define(Defs, "__ARM_ARCH_6K__");
1113 Define(Defs, "__THUMB_INTERWORK__");
1114 } else if (ArmArch == Armv5) {
1115 Define(Defs, "__ARM_ARCH_5TEJ__");
1116 Define(Defs, "__THUMB_INTERWORK__");
1117 Define(Defs, "__SOFTFP__");
1118 } else if (ArmArch == Armv4t) {
1119 Define(Defs, "__ARM_ARCH_4T__");
1120 Define(Defs, "__SOFTFP__");
1121 } else if (ArmArch == XScale) {
1122 Define(Defs, "__ARM_ARCH_5TE__");
1123 Define(Defs, "__XSCALE__");
1124 Define(Defs, "__SOFTFP__");
1125 }
Chris Lattnerecd49032009-03-02 22:27:17 +00001126 Define(Defs, "__ARMEL__");
Eli Friedman20da71e2009-05-29 19:00:15 +00001127 Define(Defs, "__APCS_32__");
1128 Define(Defs, "__VFP_FP__");
Chris Lattner17df24e2008-04-21 18:56:49 +00001129 }
1130 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1131 unsigned &NumRecords) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001132 // FIXME: Implement.
1133 Records = 0;
Chris Lattner17df24e2008-04-21 18:56:49 +00001134 NumRecords = 0;
1135 }
1136 virtual const char *getVAListDeclaration() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001137 return "typedef char* __builtin_va_list;";
Chris Lattner17df24e2008-04-21 18:56:49 +00001138 }
1139 virtual const char *getTargetPrefix() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001140 return "arm";
Chris Lattner17df24e2008-04-21 18:56:49 +00001141 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001142 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner17df24e2008-04-21 18:56:49 +00001143 unsigned &NumNames) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001144 // FIXME: Implement.
1145 Names = 0;
Chris Lattner17df24e2008-04-21 18:56:49 +00001146 NumNames = 0;
1147 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001148 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner17df24e2008-04-21 18:56:49 +00001149 unsigned &NumAliases) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001150 // FIXME: Implement.
1151 Aliases = 0;
Chris Lattner17df24e2008-04-21 18:56:49 +00001152 NumAliases = 0;
1153 }
Anders Carlsson58436352009-02-28 17:11:49 +00001154 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00001155 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001156 // FIXME: Check if this is complete
Anders Carlsson58436352009-02-28 17:11:49 +00001157 switch (*Name) {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001158 default:
Nate Begeman2908fa02008-04-22 05:03:19 +00001159 case 'l': // r0-r7
1160 case 'h': // r8-r15
1161 case 'w': // VFP Floating point register single precision
1162 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00001163 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00001164 return true;
1165 }
Chris Lattner17df24e2008-04-21 18:56:49 +00001166 return false;
1167 }
1168 virtual const char *getClobbers() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001169 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00001170 return "";
1171 }
1172};
1173} // end anonymous namespace.
1174
Eli Friedmanf05b7722008-08-20 07:44:10 +00001175
1176namespace {
1177class DarwinARMTargetInfo : public ARMTargetInfo {
1178public:
Eli Friedmand88c8a12009-04-19 21:38:35 +00001179 DarwinARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {
1180 TLSSupported = false;
1181 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00001182
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001183 virtual void getTargetDefines(const LangOptions &Opts,
1184 std::vector<char> &Defines) const {
1185 ARMTargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar497ff132009-04-10 19:52:24 +00001186 getDarwinDefines(Defines, Opts);
1187 getDarwinIPhoneOSDefines(Defines, getTargetTriple());
Eli Friedmanf05b7722008-08-20 07:44:10 +00001188 }
1189};
1190} // end anonymous namespace.
1191
Chris Lattner5ba61f02006-10-14 07:39:34 +00001192namespace {
Daniel Dunbarc53305f2009-03-23 16:09:04 +00001193// arm FreeBSD target
1194class FreeBSDARMTargetInfo : public ARMTargetInfo {
1195public:
1196 FreeBSDARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {}
1197 virtual void getTargetDefines(const LangOptions &Opts,
1198 std::vector<char> &Defines) const {
1199 ARMTargetInfo::getTargetDefines(Opts, Defines);
1200 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
1201 }
1202};
1203} // end anonymous namespace
1204
1205namespace {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001206class SparcV8TargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00001207 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1208 static const char * const GCCRegNames[];
Gabor Greif49991682008-02-21 16:29:08 +00001209public:
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001210 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1211 // FIXME: Support Sparc quad-precision long double?
Eli Friedman873f65a2008-08-21 00:13:15 +00001212 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1213 "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001214 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001215 virtual void getTargetDefines(const LangOptions &Opts,
1216 std::vector<char> &Defines) const {
Eli Friedman79426742009-05-22 01:12:57 +00001217 DefineStd(Defines, "sparc", Opts);
Gabor Greif49991682008-02-21 16:29:08 +00001218 Define(Defines, "__sparcv8");
Eli Friedman79426742009-05-22 01:12:57 +00001219 Define(Defines, "__REGISTER_PREFIX__", "");
Gabor Greif49991682008-02-21 16:29:08 +00001220 }
1221 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1222 unsigned &NumRecords) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001223 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00001224 }
1225 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001226 return "typedef void* __builtin_va_list;";
Gabor Greif49991682008-02-21 16:29:08 +00001227 }
1228 virtual const char *getTargetPrefix() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001229 return "sparc";
Gabor Greif49991682008-02-21 16:29:08 +00001230 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001231 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00001232 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001233 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00001234 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00001235 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif49991682008-02-21 16:29:08 +00001236 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001237 // FIXME: Implement!
1238 return false;
Gabor Greif49991682008-02-21 16:29:08 +00001239 }
1240 virtual const char *getClobbers() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001241 // FIXME: Implement!
1242 return "";
Gabor Greif49991682008-02-21 16:29:08 +00001243 }
1244};
1245
Chris Lattner9b415d62009-01-27 01:58:38 +00001246const char * const SparcV8TargetInfo::GCCRegNames[] = {
1247 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1248 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1249 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1250 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1251};
1252
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001253void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00001254 unsigned &NumNames) const {
1255 Names = GCCRegNames;
1256 NumNames = llvm::array_lengthof(GCCRegNames);
1257}
1258
1259const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001260 { { "g0" }, "r0" },
1261 { { "g1" }, "r1" },
1262 { { "g2" }, "r2" },
1263 { { "g3" }, "r3" },
1264 { { "g4" }, "r4" },
1265 { { "g5" }, "r5" },
1266 { { "g6" }, "r6" },
1267 { { "g7" }, "r7" },
1268 { { "o0" }, "r8" },
1269 { { "o1" }, "r9" },
1270 { { "o2" }, "r10" },
1271 { { "o3" }, "r11" },
1272 { { "o4" }, "r12" },
1273 { { "o5" }, "r13" },
1274 { { "o6", "sp" }, "r14" },
1275 { { "o7" }, "r15" },
1276 { { "l0" }, "r16" },
1277 { { "l1" }, "r17" },
1278 { { "l2" }, "r18" },
1279 { { "l3" }, "r19" },
1280 { { "l4" }, "r20" },
1281 { { "l5" }, "r21" },
1282 { { "l6" }, "r22" },
1283 { { "l7" }, "r23" },
1284 { { "i0" }, "r24" },
1285 { { "i1" }, "r25" },
1286 { { "i2" }, "r26" },
1287 { { "i3" }, "r27" },
1288 { { "i4" }, "r28" },
1289 { { "i5" }, "r29" },
1290 { { "i6", "fp" }, "r30" },
1291 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00001292};
1293
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001294void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00001295 unsigned &NumAliases) const {
1296 Aliases = GCCRegAliases;
1297 NumAliases = llvm::array_lengthof(GCCRegAliases);
1298}
Gabor Greif49991682008-02-21 16:29:08 +00001299} // end anonymous namespace.
1300
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001301namespace {
1302class SolarisSparcV8TargetInfo : public SparcV8TargetInfo {
1303public:
1304 SolarisSparcV8TargetInfo(const std::string& triple) :
Eli Friedmand50881c2008-11-02 02:43:55 +00001305 SparcV8TargetInfo(triple) {
1306 SizeType = UnsignedInt;
1307 PtrDiffType = SignedInt;
Eli Friedman79426742009-05-22 01:12:57 +00001308 WCharType = SignedLong;
1309 // FIXME: WIntType should be SignedLong
1310 UserLabelPrefix = "";
Eli Friedmand50881c2008-11-02 02:43:55 +00001311 }
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001312
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001313 virtual void getTargetDefines(const LangOptions &Opts,
1314 std::vector<char> &Defines) const {
1315 SparcV8TargetInfo::getTargetDefines(Opts, Defines);
Douglas Gregor4871c472009-05-21 23:51:30 +00001316 getSolarisDefines(Opts, Defines);
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001317 }
1318};
1319} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00001320
Chris Lattnerb781dc792008-05-08 05:58:21 +00001321namespace {
1322 class PIC16TargetInfo : public TargetInfo{
1323 public:
1324 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +00001325 TLSSupported = false;
Sanjiv Guptad7959242008-10-31 09:52:39 +00001326 IntWidth = 16;
1327 LongWidth = LongLongWidth = 32;
Eli Friedman678d3ba2009-05-16 23:30:57 +00001328 IntMaxTWidth = 32;
Sanjiv Guptad7959242008-10-31 09:52:39 +00001329 PointerWidth = 16;
1330 IntAlign = 8;
1331 LongAlign = LongLongAlign = 8;
Eli Friedmanb5366062008-05-20 14:21:01 +00001332 PointerAlign = 8;
Sanjiv Guptad7959242008-10-31 09:52:39 +00001333 SizeType = UnsignedInt;
1334 IntMaxType = SignedLong;
1335 UIntMaxType = UnsignedLong;
Chris Lattner7e4c81c2009-02-13 22:28:55 +00001336 IntPtrType = SignedShort;
Eli Friedmand50881c2008-11-02 02:43:55 +00001337 PtrDiffType = SignedInt;
Sanjiv Gupta7c720072009-06-02 04:43:46 +00001338 FloatWidth = 32;
1339 FloatAlign = 32;
1340 DoubleWidth = 32;
1341 DoubleAlign = 32;
1342 LongDoubleWidth = 32;
1343 LongDoubleAlign = 32;
1344 FloatFormat = &llvm::APFloat::IEEEsingle;
1345 DoubleFormat = &llvm::APFloat::IEEEsingle;
1346 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1347 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32";
1348
Chris Lattnerb781dc792008-05-08 05:58:21 +00001349 }
Chris Lattner5e2ef0c2008-05-09 06:08:39 +00001350 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1351 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001352 virtual void getTargetDefines(const LangOptions &Opts,
1353 std::vector<char> &Defines) const {
Chris Lattnerb781dc792008-05-08 05:58:21 +00001354 Define(Defines, "__pic16");
1355 }
1356 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1357 unsigned &NumRecords) const {}
1358 virtual const char *getVAListDeclaration() const { return "";}
1359 virtual const char *getClobbers() const {return "";}
Sanjiv Gupta4c5dfd32009-04-21 06:01:16 +00001360 virtual const char *getTargetPrefix() const {return "pic16";}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001361 virtual void getGCCRegNames(const char * const *&Names,
1362 unsigned &NumNames) const {}
1363 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerb781dc792008-05-08 05:58:21 +00001364 TargetInfo::ConstraintInfo &info) const {
1365 return true;
1366 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001367 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerb781dc792008-05-08 05:58:21 +00001368 unsigned &NumAliases) const {}
1369 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1370 };
1371}
1372
Anton Korobeynikova0f54372009-05-03 13:43:08 +00001373namespace {
1374 class MSP430TargetInfo : public TargetInfo {
1375 static const char * const GCCRegNames[];
1376 public:
1377 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1378 TLSSupported = false;
1379 IntWidth = 16;
1380 LongWidth = LongLongWidth = 32;
Eli Friedman678d3ba2009-05-16 23:30:57 +00001381 IntMaxTWidth = 32;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00001382 PointerWidth = 16;
1383 IntAlign = 8;
1384 LongAlign = LongLongAlign = 8;
1385 PointerAlign = 8;
1386 SizeType = UnsignedInt;
1387 IntMaxType = SignedLong;
1388 UIntMaxType = UnsignedLong;
1389 IntPtrType = SignedShort;
1390 PtrDiffType = SignedInt;
1391 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
1392 }
1393 virtual void getTargetDefines(const LangOptions &Opts,
1394 std::vector<char> &Defines) const {
1395 Define(Defines, "MSP430");
1396 Define(Defines, "__MSP430__");
1397 // FIXME: defines for different 'flavours' of MCU
1398 }
1399 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1400 unsigned &NumRecords) const {
1401 // FIXME: Implement.
1402 Records = 0;
1403 NumRecords = 0;
1404 }
1405 virtual const char *getTargetPrefix() const {
1406 return "msp430";
1407 }
1408 virtual void getGCCRegNames(const char * const *&Names,
1409 unsigned &NumNames) const;
1410 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1411 unsigned &NumAliases) const {
1412 // No aliases.
1413 Aliases = 0;
1414 NumAliases = 0;
1415 }
1416 virtual bool validateAsmConstraint(const char *&Name,
1417 TargetInfo::ConstraintInfo &info) const {
1418 // FIXME: implement
1419 return true;
1420 }
1421 virtual const char *getClobbers() const {
1422 // FIXME: Is this really right?
1423 return "";
1424 }
1425 virtual const char *getVAListDeclaration() const {
1426 // FIXME: implement
Anton Korobeynikov2f910822009-05-08 18:24:57 +00001427 return "typedef char* __builtin_va_list;";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00001428 }
1429 };
1430
1431 const char * const MSP430TargetInfo::GCCRegNames[] = {
1432 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1433 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1434 };
1435
1436 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1437 unsigned &NumNames) const {
1438 Names = GCCRegNames;
1439 NumNames = llvm::array_lengthof(GCCRegNames);
1440 }
1441}
1442
1443
Chris Lattner5ba61f02006-10-14 07:39:34 +00001444//===----------------------------------------------------------------------===//
1445// Driver code
1446//===----------------------------------------------------------------------===//
1447
Ted Kremenek0c2bea22007-12-04 17:07:35 +00001448static inline bool IsX86(const std::string& TT) {
Ted Kremenekb0615542007-12-03 22:06:55 +00001449 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
1450 TT[4] == '-' && TT[1] - '3' < 6);
1451}
1452
Chris Lattner855d0242008-03-05 01:18:20 +00001453/// CreateTargetInfo - Return the target info object for the specified target
1454/// triple.
1455TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Eli Friedman873f65a2008-08-21 00:13:15 +00001456 // OS detection; this isn't really anywhere near complete.
1457 // Additions and corrections are welcome.
1458 bool isDarwin = T.find("-darwin") != std::string::npos;
Chris Lattner5637ef52008-08-23 18:23:14 +00001459 bool isDragonFly = T.find("-dragonfly") != std::string::npos;
Chris Lattner3c3e2cc2008-10-16 17:04:31 +00001460 bool isFreeBSD = T.find("-freebsd") != std::string::npos;
Eli Friedman873f65a2008-08-21 00:13:15 +00001461 bool isSolaris = T.find("-solaris") != std::string::npos;
1462 bool isLinux = T.find("-linux") != std::string::npos;
1463 bool isWindows = T.find("-windows") != std::string::npos ||
1464 T.find("-win32") != std::string::npos ||
1465 T.find("-mingw") != std::string::npos;
Eli Friedmanb5366062008-05-20 14:21:01 +00001466
Eli Friedman873f65a2008-08-21 00:13:15 +00001467 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0) {
1468 if (isDarwin)
1469 return new DarwinPPCTargetInfo(T);
1470 return new PPC32TargetInfo(T);
1471 }
Eli Friedmanb5366062008-05-20 14:21:01 +00001472
Eli Friedman873f65a2008-08-21 00:13:15 +00001473 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0) {
1474 if (isDarwin)
1475 return new DarwinPPC64TargetInfo(T);
1476 return new PPC64TargetInfo(T);
1477 }
Chris Lattner17df24e2008-04-21 18:56:49 +00001478
Chris Lattner0dc10262009-04-23 04:22:04 +00001479 if (T.find("armv") == 0 || T.find("arm-") == 0 || T.find("xscale") == 0) {
Eli Friedman873f65a2008-08-21 00:13:15 +00001480 if (isDarwin)
1481 return new DarwinARMTargetInfo(T);
Daniel Dunbarc53305f2009-03-23 16:09:04 +00001482 if (isFreeBSD)
1483 return new FreeBSDARMTargetInfo(T);
Eli Friedman873f65a2008-08-21 00:13:15 +00001484 return new ARMTargetInfo(T);
1485 }
Eli Friedmanb5366062008-05-20 14:21:01 +00001486
Eli Friedman873f65a2008-08-21 00:13:15 +00001487 if (T.find("sparc-") == 0) {
1488 if (isSolaris)
1489 return new SolarisSparcV8TargetInfo(T);
1490 return new SparcV8TargetInfo(T);
1491 }
1492
Chris Lattnerd0b80c82009-02-20 17:04:14 +00001493 if (T.find("x86_64-") == 0 || T.find("amd64-") == 0) {
Eli Friedman873f65a2008-08-21 00:13:15 +00001494 if (isDarwin)
1495 return new DarwinX86_64TargetInfo(T);
Daniel Dunbard0921de2008-09-23 17:37:57 +00001496 if (isLinux)
1497 return new LinuxX86_64TargetInfo(T);
Chris Lattner3c3e2cc2008-10-16 17:04:31 +00001498 if (isFreeBSD)
1499 return new FreeBSDX86_64TargetInfo(T);
Douglas Gregor4871c472009-05-21 23:51:30 +00001500 if (isSolaris)
1501 return new SolarisX86_64TargetInfo(T);
Eli Friedman873f65a2008-08-21 00:13:15 +00001502 return new X86_64TargetInfo(T);
1503 }
Eli Friedmanb5366062008-05-20 14:21:01 +00001504
Chris Lattnerb781dc792008-05-08 05:58:21 +00001505 if (T.find("pic16-") == 0)
1506 return new PIC16TargetInfo(T);
1507
Anton Korobeynikova0f54372009-05-03 13:43:08 +00001508 if (T.find("msp430-") == 0)
1509 return new MSP430TargetInfo(T);
1510
Eli Friedman873f65a2008-08-21 00:13:15 +00001511 if (IsX86(T)) {
1512 if (isDarwin)
1513 return new DarwinI386TargetInfo(T);
Eli Friedmanff594f22008-08-21 00:24:02 +00001514 if (isLinux)
1515 return new LinuxX86_32TargetInfo(T);
Chris Lattner5637ef52008-08-23 18:23:14 +00001516 if (isDragonFly)
1517 return new DragonFlyX86_32TargetInfo(T);
Chris Lattner3c3e2cc2008-10-16 17:04:31 +00001518 if (isFreeBSD)
1519 return new FreeBSDX86_32TargetInfo(T);
Douglas Gregor4871c472009-05-21 23:51:30 +00001520 if (isSolaris)
1521 return new SolarisX86_32TargetInfo(T);
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001522 if (isWindows)
1523 return new WindowsX86_32TargetInfo(T);
Eli Friedman873f65a2008-08-21 00:13:15 +00001524 return new X86_32TargetInfo(T);
1525 }
Eli Friedmanb5366062008-05-20 14:21:01 +00001526
Chris Lattner855d0242008-03-05 01:18:20 +00001527 return NULL;
Chris Lattner5ba61f02006-10-14 07:39:34 +00001528}