blob: e156e2abd2eba7420168cf4ed1fc2603e29904bb [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-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 Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikove7772382009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek38591a22007-12-12 18:05:32 +000011// target triple.
Chris Lattner4b009652007-07-25 00:24:17 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner99ca9d62009-06-14 01:05:48 +000015#include "clang/Basic/Builtins.h"
16#include "clang/Basic/TargetBuiltins.h"
Chris Lattner4b009652007-07-25 00:24:17 +000017#include "clang/Basic/TargetInfo.h"
Chris Lattnerddae7102008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Anders Carlsson7dd1c952007-11-24 23:38:12 +000019#include "llvm/ADT/STLExtras.h"
Eli Friedmand4011892008-05-20 14:27:34 +000020#include "llvm/ADT/APFloat.h"
Chris Lattnerc345a802009-03-20 16:06:38 +000021#include "llvm/ADT/SmallString.h"
Chris Lattner4b009652007-07-25 00:24:17 +000022using namespace clang;
23
Chris Lattner4b009652007-07-25 00:24:17 +000024//===----------------------------------------------------------------------===//
25// Common code shared among targets.
26//===----------------------------------------------------------------------===//
27
Chris Lattner0db667a2007-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 Lattnerc345a802009-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 Korobeynikove7772382009-05-03 13:42:53 +000041static void DefineStd(std::vector<char> &Buf, const char *MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000044
Chris Lattnerc345a802009-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 Korobeynikove7772382009-05-03 13:42:53 +000049
Chris Lattnerc345a802009-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 Korobeynikove7772382009-05-03 13:42:53 +000055
Chris Lattnerc345a802009-03-20 16:06:38 +000056 // Define __unix__.
57 TmpStr += "__";
58 Define(Buf, TmpStr.c_str());
59}
60
Chris Lattnerbd00eb82008-10-05 21:50:58 +000061//===----------------------------------------------------------------------===//
62// Defines specific to certain operating systems.
63//===----------------------------------------------------------------------===//
64
Douglas Gregor5415abd2009-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 Friedmana456b7f2009-05-22 01:12:57 +000068 Define(Defs, "__ELF__");
69 Define(Defs, "__svr4__");
70 Define(Defs, "__SVR4");
Eli Friedmanff158dd2008-08-20 07:28:14 +000071}
Chris Lattner4b009652007-07-25 00:24:17 +000072
Daniel Dunbar64c77a12009-06-29 20:52:51 +000073static void getOpenBSDDefines(const LangOptions &Opts, bool is64Bit,
74 const char *Triple, std::vector<char> &Defs) {
75 // OpenBSD defines; list based off of gcc output
76
77 Define(Defs, "__OpenBSD__", "1");
78 Define(Defs, "__KPRINTF_ATTRIBUTE__");
79 DefineStd(Defs, "unix", Opts);
80 Define(Defs, "__ELF__", "1");
81 if (is64Bit) {
82 Define(Defs, "__LP64__");
83 }
84}
85
Chris Lattnerab81f162009-03-20 15:55:34 +000086static void getFreeBSDDefines(const LangOptions &Opts, bool is64Bit,
87 const char *Triple, std::vector<char> &Defs) {
Chris Lattner98cb2a22008-10-16 17:04:31 +000088 // FreeBSD defines; list based off of gcc output
89
90 const char *FreeBSD = strstr(Triple, "-freebsd");
91 FreeBSD += strlen("-freebsd");
92 char release[] = "X";
93 release[0] = FreeBSD[0];
94 char version[] = "X00001";
95 version[0] = FreeBSD[0];
96
97 Define(Defs, "__FreeBSD__", release);
98 Define(Defs, "__FreeBSD_cc_version", version);
99 Define(Defs, "__KPRINTF_ATTRIBUTE__");
Chris Lattnerc345a802009-03-20 16:06:38 +0000100 DefineStd(Defs, "unix", Opts);
Anton Korobeynikovfb820852009-02-14 16:42:50 +0000101 Define(Defs, "__ELF__", "1");
Chris Lattner98cb2a22008-10-16 17:04:31 +0000102 if (is64Bit) {
103 Define(Defs, "__LP64__");
104 }
105}
106
Chris Lattnerab81f162009-03-20 15:55:34 +0000107static void getDragonFlyDefines(const LangOptions &Opts,
108 std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000109 // DragonFly defines; list based off of gcc output
110 Define(Defs, "__DragonFly__");
111 Define(Defs, "__DragonFly_cc_version", "100001");
112 Define(Defs, "__ELF__");
113 Define(Defs, "__KPRINTF_ATTRIBUTE__");
114 Define(Defs, "__tune_i386__");
Chris Lattnerc345a802009-03-20 16:06:38 +0000115 DefineStd(Defs, "unix", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000116}
117
Chris Lattnerab81f162009-03-20 15:55:34 +0000118static void getLinuxDefines(const LangOptions &Opts, std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000119 // Linux defines; list based off of gcc output
Chris Lattnerc345a802009-03-20 16:06:38 +0000120 DefineStd(Defs, "unix", Opts);
121 DefineStd(Defs, "linux", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000122 Define(Defs, "__gnu_linux__");
Argiris Kirtzidis99de9532009-02-14 15:02:45 +0000123 Define(Defs, "__ELF__", "1");
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000124}
125
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000126/// getDarwinNumber - Parse the 'darwin number' out of the specific targe
Daniel Dunbar93f64532009-04-10 19:52:24 +0000127/// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000128/// not defined, return 0's. Return true if we have -darwin in the string or
129/// false otherwise.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000130static bool getDarwinNumber(const char *Triple, unsigned &Maj, unsigned &Min, unsigned &Revision) {
131 Maj = Min = Revision = 0;
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000132 const char *Darwin = strstr(Triple, "-darwin");
133 if (Darwin == 0) return false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000134
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000135 Darwin += strlen("-darwin");
136 if (Darwin[0] < '0' || Darwin[0] > '9')
137 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000138
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000139 Maj = Darwin[0]-'0';
140 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000141
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000142 // Handle "darwin11".
143 if (Maj == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
Daniel Dunbar93f64532009-04-10 19:52:24 +0000144 Maj = Maj*10 + (Darwin[0] - '0');
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000145 ++Darwin;
146 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000147
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000148 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
Daniel Dunbar93f64532009-04-10 19:52:24 +0000149 if (Darwin[0] != '.')
150 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000151
Daniel Dunbar93f64532009-04-10 19:52:24 +0000152 ++Darwin;
153 if (Darwin[0] < '0' || Darwin[0] > '9')
154 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000155
Daniel Dunbar93f64532009-04-10 19:52:24 +0000156 Min = Darwin[0]-'0';
157 ++Darwin;
158
159 // Handle 10.4.11 -> darwin8.11
160 if (Min == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
161 Min = Min*10 + (Darwin[0] - '0');
162 ++Darwin;
163 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000164
Daniel Dunbar93f64532009-04-10 19:52:24 +0000165 // Handle revision darwin8.9.1
166 if (Darwin[0] != '.')
167 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000168
Daniel Dunbar93f64532009-04-10 19:52:24 +0000169 ++Darwin;
170 if (Darwin[0] < '0' || Darwin[0] > '9')
171 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000172
Daniel Dunbar93f64532009-04-10 19:52:24 +0000173 Revision = Darwin[0]-'0';
174 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000175
Daniel Dunbar93f64532009-04-10 19:52:24 +0000176 if (Revision == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
177 Revision = Revision*10 + (Darwin[0] - '0');
178 ++Darwin;
179 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000180
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000181 return true;
182}
183
Daniel Dunbar93f64532009-04-10 19:52:24 +0000184static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
Chris Lattner59122202009-06-23 00:43:21 +0000185 Define(Defs, "__APPLE_CC__", "5621");
Eli Friedman872996c2008-08-20 02:34:37 +0000186 Define(Defs, "__APPLE__");
187 Define(Defs, "__MACH__");
Chris Lattner8405e092009-02-05 07:19:24 +0000188 Define(Defs, "OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000189
Chris Lattner8181e622009-04-07 16:50:40 +0000190 // __weak is always defined, for use in blocks and with objc pointers.
191 Define(Defs, "__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000192
Chris Lattner8181e622009-04-07 16:50:40 +0000193 // Darwin defines __strong even in C mode (just to nothing).
194 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Chris Lattner33854aa2009-04-07 04:48:21 +0000195 Define(Defs, "__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +0000196 else
Chris Lattner33854aa2009-04-07 04:48:21 +0000197 Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +0000198
199 if (Opts.Static)
200 Define(Defs, "__STATIC__");
201 else
202 Define(Defs, "__DYNAMIC__");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000203}
204
205static void getDarwinOSXDefines(std::vector<char> &Defs, const char *Triple) {
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000206 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000207 unsigned Maj, Min, Rev;
208 if (getDarwinNumber(Triple, Maj, Min, Rev)) {
209 char MacOSXStr[] = "1000";
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000210 if (Maj >= 4 && Maj <= 13) { // 10.0-10.9
211 // darwin7 -> 1030, darwin8 -> 1040, darwin9 -> 1050, etc.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000212 MacOSXStr[2] = '0' + Maj-4;
213 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000214
Daniel Dunbar93f64532009-04-10 19:52:24 +0000215 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
216 // Cap 10.4.11 -> darwin8.11 -> "1049"
217 MacOSXStr[3] = std::min(Min, 9U)+'0';
218 Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", MacOSXStr);
219 }
220}
221
Anton Korobeynikove7772382009-05-03 13:42:53 +0000222static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
Daniel Dunbar93f64532009-04-10 19:52:24 +0000223 const char *Triple) {
224 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
225 unsigned Maj, Min, Rev;
226 if (getDarwinNumber(Triple, Maj, Min, Rev)) {
227 // When targetting iPhone OS, interpret the minor version and
228 // revision as the iPhone OS version
229 char iPhoneOSStr[] = "10000";
230 if (Min >= 2 && Min <= 9) { // iPhone OS 2.0-9.0
231 // darwin9.2.0 -> 20000, darwin9.3.0 -> 30000, etc.
232 iPhoneOSStr[0] = '0' + Min;
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000233 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000234
Daniel Dunbar93f64532009-04-10 19:52:24 +0000235 // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
236 iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
Anton Korobeynikove7772382009-05-03 13:42:53 +0000237 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
Daniel Dunbar93f64532009-04-10 19:52:24 +0000238 iPhoneOSStr);
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000239 }
Eli Friedman872996c2008-08-20 02:34:37 +0000240}
Chris Lattner4b009652007-07-25 00:24:17 +0000241
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000242/// GetDarwinLanguageOptions - Set the default language options for darwin.
243static void GetDarwinLanguageOptions(LangOptions &Opts,
244 const char *Triple) {
245 Opts.NeXTRuntime = true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000246
Daniel Dunbar93f64532009-04-10 19:52:24 +0000247 unsigned Maj, Min, Rev;
248 if (!getDarwinNumber(Triple, Maj, Min, Rev))
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000249 return;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000250
Bill Wendlinge1d4f5d2009-06-28 07:36:13 +0000251 // Blocks and stack protectors default to on for 10.6 (darwin10) and beyond.
252 if (Maj > 9) {
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000253 Opts.Blocks = 1;
Bill Wendling39e99a42009-06-28 23:01:01 +0000254 Opts.setStackProtectorMode(LangOptions::SSPOn);
Bill Wendlinge1d4f5d2009-06-28 07:36:13 +0000255 }
Fariborz Jahanian27f58962009-02-24 23:34:44 +0000256
Bill Wendlinge1d4f5d2009-06-28 07:36:13 +0000257 // Non-fragile ABI (in 64-bit mode) default to on for 10.5 (darwin9) and
258 // beyond.
Fariborz Jahanian72efecb2009-02-24 23:38:42 +0000259 if (Maj >= 9 && Opts.ObjC1 && !strncmp(Triple, "x86_64", 6))
260 Opts.ObjCNonFragileABI = 1;
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000261}
262
Eli Friedman6b6ca942009-06-08 06:11:14 +0000263/// GetWindowsLanguageOptions - Set the default language options for Windows.
264static void GetWindowsLanguageOptions(LangOptions &Opts,
265 const char *Triple) {
266 Opts.Microsoft = true;
267}
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000268
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000269//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000270// Specific target implementations.
271//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000272
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000273namespace {
274// PPC abstract base class
275class PPCTargetInfo : public TargetInfo {
276 static const Builtin::Info BuiltinInfo[];
277 static const char * const GCCRegNames[];
278 static const TargetInfo::GCCRegAlias GCCRegAliases[];
279
280public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000281 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
282
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000283 virtual void getTargetBuiltins(const Builtin::Info *&Records,
284 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000285 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000286 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000287 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000288
Chris Lattner79682402009-03-20 15:52:06 +0000289 virtual void getTargetDefines(const LangOptions &Opts,
290 std::vector<char> &Defines) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000291
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000292 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000293 return "typedef char* __builtin_va_list;";
294 // This is the right definition for ABI/V4: System V.4/eabi.
295 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000296 " unsigned char gpr;"
297 " unsigned char fpr;"
298 " unsigned short reserved;"
299 " void* overflow_arg_area;"
300 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000301 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000302 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000303 virtual const char *getTargetPrefix() const {
304 return "ppc";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000305 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000306 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000307 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000308 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000309 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000310 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000311 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000312 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000313 default: return false;
314 case 'O': // Zero
315 return true;
316 case 'b': // Base register
317 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000318 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000319 return true;
320 }
321 }
Eli Friedmand9389be2009-06-05 07:05:05 +0000322 virtual void getDefaultLangOptions(LangOptions &Opts) {
323 TargetInfo::getDefaultLangOptions(Opts);
324 Opts.CharIsSigned = false;
325 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000326 virtual const char *getClobbers() const {
327 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000328 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000329};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000330
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000331const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000332#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
333#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000334#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000335};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000336
337
Chris Lattnerbef1d722009-03-02 22:27:17 +0000338/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
339/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000340void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
341 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000342 // Target identification.
343 Define(Defs, "__ppc__");
344 Define(Defs, "_ARCH_PPC");
345 Define(Defs, "__POWERPC__");
346 if (PointerWidth == 64) {
347 Define(Defs, "_ARCH_PPC64");
348 Define(Defs, "_LP64");
349 Define(Defs, "__LP64__");
350 Define(Defs, "__ppc64__");
351 } else {
352 Define(Defs, "__ppc__");
353 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000354
Chris Lattnerbef1d722009-03-02 22:27:17 +0000355 // Target properties.
356 Define(Defs, "_BIG_ENDIAN");
357 Define(Defs, "__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000358
Chris Lattnerbef1d722009-03-02 22:27:17 +0000359 // Subtarget options.
360 Define(Defs, "__NATURAL_ALIGNMENT__");
361 Define(Defs, "__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000362
Chris Lattnerbef1d722009-03-02 22:27:17 +0000363 // FIXME: Should be controlled by command line option.
364 Define(Defs, "__LONG_DOUBLE_128__");
365}
366
Chris Lattner9fd73612008-04-21 18:56:49 +0000367
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000368const char * const PPCTargetInfo::GCCRegNames[] = {
369 "0", "1", "2", "3", "4", "5", "6", "7",
370 "8", "9", "10", "11", "12", "13", "14", "15",
371 "16", "17", "18", "19", "20", "21", "22", "23",
372 "24", "25", "26", "27", "28", "29", "30", "31",
373 "0", "1", "2", "3", "4", "5", "6", "7",
374 "8", "9", "10", "11", "12", "13", "14", "15",
375 "16", "17", "18", "19", "20", "21", "22", "23",
376 "24", "25", "26", "27", "28", "29", "30", "31",
377 "mq", "lr", "ctr", "ap",
378 "0", "1", "2", "3", "4", "5", "6", "7",
379 "xer",
380 "0", "1", "2", "3", "4", "5", "6", "7",
381 "8", "9", "10", "11", "12", "13", "14", "15",
382 "16", "17", "18", "19", "20", "21", "22", "23",
383 "24", "25", "26", "27", "28", "29", "30", "31",
384 "vrsave", "vscr",
385 "spe_acc", "spefscr",
386 "sfp"
387};
Chris Lattner4b009652007-07-25 00:24:17 +0000388
Anton Korobeynikove7772382009-05-03 13:42:53 +0000389void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000390 unsigned &NumNames) const {
391 Names = GCCRegNames;
392 NumNames = llvm::array_lengthof(GCCRegNames);
393}
Chris Lattner4b009652007-07-25 00:24:17 +0000394
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000395const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
396 // While some of these aliases do map to different registers
397 // they still share the same register name.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000398 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
399 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
400 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
401 { { "cr3", "fr3", "r3", "v3"}, "3" },
402 { { "cr4", "fr4", "r4", "v4"}, "4" },
403 { { "cr5", "fr5", "r5", "v5"}, "5" },
404 { { "cr6", "fr6", "r6", "v6"}, "6" },
405 { { "cr7", "fr7", "r7", "v7"}, "7" },
406 { { "fr8", "r8", "v8"}, "8" },
407 { { "fr9", "r9", "v9"}, "9" },
408 { { "fr10", "r10", "v10"}, "10" },
409 { { "fr11", "r11", "v11"}, "11" },
410 { { "fr12", "r12", "v12"}, "12" },
411 { { "fr13", "r13", "v13"}, "13" },
412 { { "fr14", "r14", "v14"}, "14" },
413 { { "fr15", "r15", "v15"}, "15" },
414 { { "fr16", "r16", "v16"}, "16" },
415 { { "fr17", "r17", "v17"}, "17" },
416 { { "fr18", "r18", "v18"}, "18" },
417 { { "fr19", "r19", "v19"}, "19" },
418 { { "fr20", "r20", "v20"}, "20" },
419 { { "fr21", "r21", "v21"}, "21" },
420 { { "fr22", "r22", "v22"}, "22" },
421 { { "fr23", "r23", "v23"}, "23" },
422 { { "fr24", "r24", "v24"}, "24" },
423 { { "fr25", "r25", "v25"}, "25" },
424 { { "fr26", "r26", "v26"}, "26" },
425 { { "fr27", "r27", "v27"}, "27" },
426 { { "fr28", "r28", "v28"}, "28" },
427 { { "fr29", "r29", "v29"}, "29" },
428 { { "fr30", "r30", "v30"}, "30" },
429 { { "fr31", "r31", "v31"}, "31" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000430};
431
Anton Korobeynikove7772382009-05-03 13:42:53 +0000432void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000433 unsigned &NumAliases) const {
434 Aliases = GCCRegAliases;
435 NumAliases = llvm::array_lengthof(GCCRegAliases);
436}
437} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000438
439namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000440class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000441public:
Eli Friedman2b161652008-08-21 00:13:15 +0000442 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
443 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
444 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
445 }
Chris Lattner4b009652007-07-25 00:24:17 +0000446};
447} // end anonymous namespace.
448
449namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000450class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000451public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000452 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000453 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2b161652008-08-21 00:13:15 +0000454 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
455 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
Chris Lattnere5fde952008-05-09 06:17:04 +0000456 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000457};
458} // end anonymous namespace.
459
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000460
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000461namespace {
462class DarwinPPCTargetInfo : public PPC32TargetInfo {
463public:
464 DarwinPPCTargetInfo(const std::string& triple) : PPC32TargetInfo(triple) {}
Chris Lattner79682402009-03-20 15:52:06 +0000465 virtual void getTargetDefines(const LangOptions &Opts,
466 std::vector<char> &Defines) const {
467 PPC32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000468 getDarwinDefines(Defines, Opts);
469 getDarwinOSXDefines(Defines, getTargetTriple());
Chris Lattner4b009652007-07-25 00:24:17 +0000470 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000471
Chris Lattnerddae7102008-12-04 22:54:33 +0000472 /// getDefaultLangOptions - Allow the target to specify default settings for
473 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000474 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000475 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000476 PPC32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000477 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000478 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000479};
480} // end anonymous namespace.
481
482namespace {
483class DarwinPPC64TargetInfo : public PPC64TargetInfo {
484public:
485 DarwinPPC64TargetInfo(const std::string& triple) : PPC64TargetInfo(triple) {}
Chris Lattner79682402009-03-20 15:52:06 +0000486 virtual void getTargetDefines(const LangOptions &Opts,
487 std::vector<char> &Defines) const {
488 PPC64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000489 getDarwinDefines(Defines, Opts);
490 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000491 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000492
Chris Lattnerddae7102008-12-04 22:54:33 +0000493 /// getDefaultLangOptions - Allow the target to specify default settings for
494 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000495 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000496 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000497 PPC64TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000498 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000499 }
Chris Lattner4b009652007-07-25 00:24:17 +0000500};
501} // end anonymous namespace.
502
503namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000504// Namespace for x86 abstract base class
505const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000506#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
507#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000508#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000509};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000510
Eli Friedman872996c2008-08-20 02:34:37 +0000511const char *GCCRegNames[] = {
512 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
513 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
514 "argp", "flags", "fspr", "dirflag", "frame",
515 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
516 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
517 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
518 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
519};
520
521const TargetInfo::GCCRegAlias GCCRegAliases[] = {
522 { { "al", "ah", "eax", "rax" }, "ax" },
523 { { "bl", "bh", "ebx", "rbx" }, "bx" },
524 { { "cl", "ch", "ecx", "rcx" }, "cx" },
525 { { "dl", "dh", "edx", "rdx" }, "dx" },
526 { { "esi", "rsi" }, "si" },
527 { { "edi", "rdi" }, "di" },
528 { { "esp", "rsp" }, "sp" },
529 { { "ebp", "rbp" }, "bp" },
530};
531
532// X86 target abstract base class; x86-32 and x86-64 are very close, so
533// most of the implementation can be shared.
534class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000535 enum X86SSEEnum {
536 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
537 } SSELevel;
Eli Friedman872996c2008-08-20 02:34:37 +0000538public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000539 X86TargetInfo(const std::string& triple)
Daniel Dunbar07181d72009-05-06 03:16:41 +0000540 : TargetInfo(triple), SSELevel(NoMMXSSE) {
Eli Friedman872996c2008-08-20 02:34:37 +0000541 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000542 }
543 virtual void getTargetBuiltins(const Builtin::Info *&Records,
544 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000545 Records = BuiltinInfo;
546 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000547 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000548 virtual const char *getTargetPrefix() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000549 return "x86";
Anton Korobeynikove7772382009-05-03 13:42:53 +0000550 }
551 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000552 unsigned &NumNames) const {
553 Names = GCCRegNames;
554 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000555 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000556 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000557 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000558 Aliases = GCCRegAliases;
559 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000560 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000561 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000562 TargetInfo::ConstraintInfo &info) const;
563 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000564 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000565 return "~{dirflag},~{fpsr},~{flags}";
566 }
Chris Lattner79682402009-03-20 15:52:06 +0000567 virtual void getTargetDefines(const LangOptions &Opts,
568 std::vector<char> &Defines) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000569 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
570 const std::string &Name,
571 bool Enabled) const;
Daniel Dunbar07181d72009-05-06 03:16:41 +0000572 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000573 llvm::StringMap<bool> &Features) const;
Daniel Dunbar07181d72009-05-06 03:16:41 +0000574 virtual void HandleTargetFeatures(const llvm::StringMap<bool> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000575};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000576
Daniel Dunbar07181d72009-05-06 03:16:41 +0000577void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000578 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000579 // FIXME: This should not be here.
580 Features["3dnow"] = false;
581 Features["3dnowa"] = false;
582 Features["mmx"] = false;
583 Features["sse"] = false;
584 Features["sse2"] = false;
585 Features["sse3"] = false;
586 Features["ssse3"] = false;
587 Features["sse41"] = false;
588 Features["sse42"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000589
Daniel Dunbar07181d72009-05-06 03:16:41 +0000590 // LLVM does not currently recognize this.
591 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000592
Daniel Dunbar07181d72009-05-06 03:16:41 +0000593 // FIXME: This *really* should not be here.
594
595 // X86_64 always has SSE2.
596 if (PointerWidth == 64)
597 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
598
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000599 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
600 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
601 ;
602 else if (CPU == "pentium-mmx" || CPU == "pentium2")
603 setFeatureEnabled(Features, "mmx", true);
604 else if (CPU == "pentium3")
605 setFeatureEnabled(Features, "sse", true);
606 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
607 setFeatureEnabled(Features, "sse2", true);
608 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
609 setFeatureEnabled(Features, "sse3", true);
610 else if (CPU == "core2")
611 setFeatureEnabled(Features, "ssse3", true);
612 else if (CPU == "penryn") {
613 setFeatureEnabled(Features, "sse4", true);
614 Features["sse42"] = false;
615 } else if (CPU == "atom")
616 setFeatureEnabled(Features, "sse3", true);
617 else if (CPU == "corei7")
618 setFeatureEnabled(Features, "sse4", true);
619 else if (CPU == "k6" || CPU == "winchip-c6")
620 setFeatureEnabled(Features, "mmx", true);
621 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
622 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
623 setFeatureEnabled(Features, "mmx", true);
624 setFeatureEnabled(Features, "3dnow", true);
625 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
626 setFeatureEnabled(Features, "sse", true);
627 setFeatureEnabled(Features, "3dnowa", true);
628 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
629 CPU == "athlon-fx") {
630 setFeatureEnabled(Features, "sse2", true);
631 setFeatureEnabled(Features, "3dnowa", true);
632 } else if (CPU == "c3-2")
633 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000634}
635
Daniel Dunbar0838f962009-05-06 21:07:50 +0000636bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
637 const std::string &Name,
638 bool Enabled) const {
639 // FIXME: This *really* should not be here.
640 if (!Features.count(Name) && Name != "sse4")
641 return false;
642
643 if (Enabled) {
644 if (Name == "mmx")
645 Features["mmx"] = true;
646 else if (Name == "sse")
647 Features["mmx"] = Features["sse"] = true;
648 else if (Name == "sse2")
649 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
650 else if (Name == "sse3")
651 Features["mmx"] = Features["sse"] = Features["sse2"] =
652 Features["sse3"] = true;
653 else if (Name == "ssse3")
654 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
655 Features["ssse3"] = true;
656 else if (Name == "sse4")
657 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
658 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
659 else if (Name == "3dnow")
660 Features["3dnowa"] = true;
661 else if (Name == "3dnowa")
662 Features["3dnow"] = Features["3dnowa"] = true;
663 } else {
664 if (Name == "mmx")
665 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
666 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
667 else if (Name == "sse")
668 Features["sse"] = Features["sse2"] = Features["sse3"] =
669 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
670 else if (Name == "sse2")
671 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
672 Features["sse41"] = Features["sse42"] = false;
673 else if (Name == "sse3")
674 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
675 Features["sse42"] = false;
676 else if (Name == "ssse3")
677 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
678 else if (Name == "sse4")
679 Features["sse41"] = Features["sse42"] = false;
680 else if (Name == "3dnow")
681 Features["3dnow"] = Features["3dnowa"] = false;
682 else if (Name == "3dnowa")
683 Features["3dnowa"] = false;
684 }
685
686 return true;
687}
688
Daniel Dunbar07181d72009-05-06 03:16:41 +0000689/// HandleTargetOptions - Perform initialization based on the user
690/// configured set of features.
691void X86TargetInfo::HandleTargetFeatures(const llvm::StringMap<bool>&Features) {
692 if (Features.lookup("sse42"))
693 SSELevel = SSE42;
694 else if (Features.lookup("sse41"))
695 SSELevel = SSE41;
696 else if (Features.lookup("ssse3"))
697 SSELevel = SSSE3;
698 else if (Features.lookup("sse3"))
699 SSELevel = SSE3;
700 else if (Features.lookup("sse2"))
701 SSELevel = SSE2;
702 else if (Features.lookup("sse"))
703 SSELevel = SSE1;
704 else if (Features.lookup("mmx"))
705 SSELevel = MMX;
Chris Lattner7d6220c2009-03-02 22:20:04 +0000706}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000707
708/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
709/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000710void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
711 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000712 // Target identification.
713 if (PointerWidth == 64) {
714 Define(Defs, "_LP64");
715 Define(Defs, "__LP64__");
716 Define(Defs, "__amd64__");
717 Define(Defs, "__amd64");
718 Define(Defs, "__x86_64");
719 Define(Defs, "__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000720 } else {
Chris Lattnerc345a802009-03-20 16:06:38 +0000721 DefineStd(Defs, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000722 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000723
Chris Lattnerbef1d722009-03-02 22:27:17 +0000724 // Target properties.
725 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000726
Chris Lattnerbef1d722009-03-02 22:27:17 +0000727 // Subtarget options.
728 Define(Defs, "__nocona");
729 Define(Defs, "__nocona__");
730 Define(Defs, "__tune_nocona__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000731 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000732
Chris Lattner25ac1c12009-04-19 17:32:33 +0000733 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
734 // functions in glibc header files that use FP Stack inline asm which the
735 // backend can't deal with (PR879).
736 Define(Defs, "__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000737
Chris Lattner715fe4c2009-03-02 22:40:39 +0000738 // Each case falls through to the previous one here.
739 switch (SSELevel) {
740 case SSE42:
741 Define(Defs, "__SSE4_2__");
742 case SSE41:
743 Define(Defs, "__SSE4_1__");
744 case SSSE3:
745 Define(Defs, "__SSSE3__");
746 case SSE3:
747 Define(Defs, "__SSE3__");
748 case SSE2:
749 Define(Defs, "__SSE2__");
750 Define(Defs, "__SSE2_MATH__"); // -mfp-math=sse always implied.
751 case SSE1:
752 Define(Defs, "__SSE__");
753 Define(Defs, "__SSE_MATH__"); // -mfp-math=sse always implied.
754 case MMX:
755 Define(Defs, "__MMX__");
756 case NoMMXSSE:
757 break;
758 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000759}
Anton Korobeynikove7772382009-05-03 13:42:53 +0000760
761
Eli Friedman872996c2008-08-20 02:34:37 +0000762bool
Anders Carlsson36834a72009-02-28 17:11:49 +0000763X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000764 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000765 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +0000766 default: return false;
767 case 'a': // eax.
768 case 'b': // ebx.
769 case 'c': // ecx.
770 case 'd': // edx.
771 case 'S': // esi.
772 case 'D': // edi.
773 case 'A': // edx:eax.
774 case 't': // top of floating point stack.
775 case 'u': // second from top of floating point stack.
776 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +0000777 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +0000778 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +0000779 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000780 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000781 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000782 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000783 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +0000784 case 'N': // unsigned 8-bit integer constant for use with in and out
785 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +0000786 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000787 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +0000788 return true;
789 }
790}
791
792std::string
793X86TargetInfo::convertConstraint(const char Constraint) const {
794 switch (Constraint) {
795 case 'a': return std::string("{ax}");
796 case 'b': return std::string("{bx}");
797 case 'c': return std::string("{cx}");
798 case 'd': return std::string("{dx}");
799 case 'S': return std::string("{si}");
800 case 'D': return std::string("{di}");
801 case 't': // top of floating point stack.
802 return std::string("{st}");
803 case 'u': // second from top of floating point stack.
804 return std::string("{st(1)}"); // second from top of floating point stack.
805 default:
806 return std::string(1, Constraint);
807 }
808}
Eli Friedman872996c2008-08-20 02:34:37 +0000809} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000810
811namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000812// X86-32 generic target
813class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000814public:
Eli Friedman872996c2008-08-20 02:34:37 +0000815 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
816 DoubleAlign = LongLongAlign = 32;
817 LongDoubleWidth = 96;
818 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000819 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
820 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
821 "a0:0:64-f80:32:32";
Eli Friedman04ede302009-03-29 20:31:09 +0000822 SizeType = UnsignedInt;
823 PtrDiffType = SignedInt;
824 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000825 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +0000826 }
827 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000828 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000829 }
Eli Friedman872996c2008-08-20 02:34:37 +0000830};
831} // end anonymous namespace
832
833namespace {
834// x86-32 Darwin (OS X) target
835class DarwinI386TargetInfo : public X86_32TargetInfo {
836public:
837 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
838 LongDoubleWidth = 128;
839 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +0000840 SizeType = UnsignedLong;
841 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000842 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
843 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
844 "a0:0:64-f80:128:128";
Eli Friedman8f575172009-04-19 21:38:35 +0000845 TLSSupported = false;
Eli Friedman872996c2008-08-20 02:34:37 +0000846 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000847
Anton Korobeynikove7772382009-05-03 13:42:53 +0000848 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000849 return IsConstant ? "\01LC" : "\01lC";
850 }
851
Anton Korobeynikove7772382009-05-03 13:42:53 +0000852 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000853 return "__utf16_string_";
854 }
855
Anton Korobeynikove7772382009-05-03 13:42:53 +0000856 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000857 return "__TEXT,__ustring";
858 }
859
Anton Korobeynikove7772382009-05-03 13:42:53 +0000860 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000861 return "\01LC";
862 }
863
Chris Lattner79682402009-03-20 15:52:06 +0000864 virtual void getTargetDefines(const LangOptions &Opts,
865 std::vector<char> &Defines) const {
866 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000867 getDarwinDefines(Defines, Opts);
868 getDarwinOSXDefines(Defines, getTargetTriple());
Eli Friedman872996c2008-08-20 02:34:37 +0000869 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000870
Chris Lattnerddae7102008-12-04 22:54:33 +0000871 /// getDefaultLangOptions - Allow the target to specify default settings for
872 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000873 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000874 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000875 X86_32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000876 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000877 }
Eli Friedman872996c2008-08-20 02:34:37 +0000878};
879} // end anonymous namespace
880
881namespace {
Daniel Dunbar64c77a12009-06-29 20:52:51 +0000882// x86-32 OpenBSD target
883class OpenBSDX86_32TargetInfo : public X86_32TargetInfo {
884public:
885 OpenBSDX86_32TargetInfo(const std::string& triple) :
886 X86_32TargetInfo(triple) { }
887 virtual void getTargetDefines(const LangOptions &Opts,
888 std::vector<char> &Defines) const {
889 X86_32TargetInfo::getTargetDefines(Opts, Defines);
890 getOpenBSDDefines(Opts, 0, getTargetTriple(), Defines);
891 }
892};
893} // end anonymous namespace
894
895namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +0000896// x86-32 FreeBSD target
897class FreeBSDX86_32TargetInfo : public X86_32TargetInfo {
898public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000899 FreeBSDX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000900 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000901 virtual void getTargetDefines(const LangOptions &Opts,
902 std::vector<char> &Defines) const {
903 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000904 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +0000905 }
906};
907} // end anonymous namespace
908
909namespace {
Chris Lattnerd4faca42008-08-23 18:23:14 +0000910// x86-32 DragonFly target
911class DragonFlyX86_32TargetInfo : public X86_32TargetInfo {
912public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000913 DragonFlyX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000914 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000915 virtual void getTargetDefines(const LangOptions &Opts,
916 std::vector<char> &Defines) const {
917 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000918 getDragonFlyDefines(Opts, Defines);
Chris Lattnerd4faca42008-08-23 18:23:14 +0000919 }
920};
921} // end anonymous namespace
922
923namespace {
Eli Friedman5fb0a022008-08-21 00:24:02 +0000924// x86-32 Linux target
925class LinuxX86_32TargetInfo : public X86_32TargetInfo {
926public:
927 LinuxX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +0000928 UserLabelPrefix = "";
Eli Friedman5fb0a022008-08-21 00:24:02 +0000929 }
Chris Lattner79682402009-03-20 15:52:06 +0000930 virtual void getTargetDefines(const LangOptions &Opts,
931 std::vector<char> &Defines) const {
932 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000933 getLinuxDefines(Opts, Defines);
Eli Friedman5fb0a022008-08-21 00:24:02 +0000934 }
935};
936} // end anonymous namespace
937
938namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +0000939// x86-32 Solaris target
940class SolarisX86_32TargetInfo : public X86_32TargetInfo {
941public:
942 SolarisX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
943 UserLabelPrefix = "";
Eli Friedmana456b7f2009-05-22 01:12:57 +0000944 WCharType = SignedLong;
945 // FIXME: WIntType should be SignedLong
Douglas Gregor5415abd2009-05-21 23:51:30 +0000946 }
947 virtual void getTargetDefines(const LangOptions &Opts,
948 std::vector<char> &Defines) const {
949 X86_32TargetInfo::getTargetDefines(Opts, Defines);
950 getSolarisDefines(Opts, Defines);
951 }
952};
953} // end anonymous namespace
954
955
956namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000957// x86-32 Windows target
958class WindowsX86_32TargetInfo : public X86_32TargetInfo {
959public:
960 WindowsX86_32TargetInfo(const std::string& triple)
961 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +0000962 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +0000963 WCharType = UnsignedShort;
Eli Friedman6b6ca942009-06-08 06:11:14 +0000964 WCharWidth = WCharAlign = 16;
Eli Friedmanb28055e2009-06-08 21:16:17 +0000965 DoubleAlign = LongLongAlign = 64;
966 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
967 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
968 "a0:0:64-f80:32:32";
Eli Friedman23cb7912008-08-21 01:40:19 +0000969 }
Chris Lattner79682402009-03-20 15:52:06 +0000970 virtual void getTargetDefines(const LangOptions &Opts,
971 std::vector<char> &Defines) const {
972 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Eli Friedman23cb7912008-08-21 01:40:19 +0000973 // This list is based off of the the list of things MingW defines
Eli Friedman23cb7912008-08-21 01:40:19 +0000974 Define(Defines, "_WIN32");
Chris Lattnerc345a802009-03-20 16:06:38 +0000975 DefineStd(Defines, "WIN32", Opts);
976 DefineStd(Defines, "WINNT", Opts);
Eli Friedman23cb7912008-08-21 01:40:19 +0000977 Define(Defines, "_X86_");
978 Define(Defines, "__MSVCRT__");
979 }
Eli Friedman6b6ca942009-06-08 06:11:14 +0000980
981 virtual void getDefaultLangOptions(LangOptions &Opts) {
982 X86_32TargetInfo::getDefaultLangOptions(Opts);
983 GetWindowsLanguageOptions(Opts, getTargetTriple());
984 }
Eli Friedman23cb7912008-08-21 01:40:19 +0000985};
986} // end anonymous namespace
987
988namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000989// x86-64 generic target
990class X86_64TargetInfo : public X86TargetInfo {
991public:
Chris Lattner79682402009-03-20 15:52:06 +0000992 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000993 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Chris Lattner4dfc45a2009-01-28 06:58:19 +0000994 DoubleAlign = LongLongAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000995 LongDoubleWidth = 128;
996 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +0000997 IntMaxType = SignedLong;
998 UIntMaxType = UnsignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000999 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001000
Eli Friedman2b161652008-08-21 00:13:15 +00001001 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1002 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Daniel Dunbarea390922009-06-08 22:39:13 +00001003 "a0:0:64-s0:64:64-f80:128:128";
Chris Lattner4b009652007-07-25 00:24:17 +00001004 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001005 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001006 return "typedef struct __va_list_tag {"
1007 " unsigned gp_offset;"
1008 " unsigned fp_offset;"
1009 " void* overflow_arg_area;"
1010 " void* reg_save_area;"
1011 "} __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001012 }
Eli Friedman872996c2008-08-20 02:34:37 +00001013};
1014} // end anonymous namespace
1015
1016namespace {
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001017// x86-64 OpenBSD target
1018class OpenBSDX86_64TargetInfo : public X86_64TargetInfo {
1019public:
1020 OpenBSDX86_64TargetInfo(const std::string &triple)
1021 : X86_64TargetInfo(triple) {}
1022 virtual void getTargetDefines(const LangOptions &Opts,
1023 std::vector<char> &Defines) const {
1024 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1025 getOpenBSDDefines(Opts, 1, getTargetTriple(), Defines);
1026 }
1027};
1028} // end anonymous namespace
1029
1030namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +00001031// x86-64 FreeBSD target
1032class FreeBSDX86_64TargetInfo : public X86_64TargetInfo {
1033public:
Chris Lattner79682402009-03-20 15:52:06 +00001034 FreeBSDX86_64TargetInfo(const std::string &triple)
1035 : X86_64TargetInfo(triple) {}
1036 virtual void getTargetDefines(const LangOptions &Opts,
1037 std::vector<char> &Defines) const {
1038 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +00001039 getFreeBSDDefines(Opts, 1, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001040 }
1041};
1042} // end anonymous namespace
1043
1044namespace {
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001045// x86-64 Linux target
1046class LinuxX86_64TargetInfo : public X86_64TargetInfo {
1047public:
1048 LinuxX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +00001049 UserLabelPrefix = "";
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001050 }
Chris Lattner79682402009-03-20 15:52:06 +00001051 virtual void getTargetDefines(const LangOptions &Opts,
1052 std::vector<char> &Defines) const {
1053 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +00001054 getLinuxDefines(Opts, Defines);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001055 }
1056};
1057} // end anonymous namespace
1058
1059namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +00001060// x86-64 Solaris target
1061class SolarisX86_64TargetInfo : public X86_64TargetInfo {
1062public:
1063 SolarisX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1064 UserLabelPrefix = "";
Douglas Gregor5415abd2009-05-21 23:51:30 +00001065 }
1066 virtual void getTargetDefines(const LangOptions &Opts,
1067 std::vector<char> &Defines) const {
1068 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1069 getSolarisDefines(Opts, Defines);
1070 }
1071};
1072} // end anonymous namespace
1073
1074namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001075// x86-64 Darwin (OS X) target
1076class DarwinX86_64TargetInfo : public X86_64TargetInfo {
1077public:
Eli Friedman8f575172009-04-19 21:38:35 +00001078 DarwinX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1079 TLSSupported = false;
1080 }
Eli Friedman872996c2008-08-20 02:34:37 +00001081
Anton Korobeynikove7772382009-05-03 13:42:53 +00001082 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001083 return IsConstant ? "\01LC" : "\01lC";
1084 }
1085
Anton Korobeynikove7772382009-05-03 13:42:53 +00001086 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001087 return "__utf16_string_";
1088 }
1089
Anton Korobeynikove7772382009-05-03 13:42:53 +00001090 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001091 return "__TEXT,__ustring";
1092 }
1093
Anton Korobeynikove7772382009-05-03 13:42:53 +00001094 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001095 return "\01L_unnamed_cfstring_";
1096 }
1097
Chris Lattner79682402009-03-20 15:52:06 +00001098 virtual void getTargetDefines(const LangOptions &Opts,
1099 std::vector<char> &Defines) const {
1100 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001101 getDarwinDefines(Defines, Opts);
1102 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001103 }
Daniel Dunbar34542952008-08-23 08:43:39 +00001104
Chris Lattnerddae7102008-12-04 22:54:33 +00001105 /// getDefaultLangOptions - Allow the target to specify default settings for
1106 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +00001107 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +00001108 virtual void getDefaultLangOptions(LangOptions &Opts) {
Chris Lattnerd7bc88b2008-12-04 23:20:07 +00001109 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +00001110 }
Chris Lattner4b009652007-07-25 00:24:17 +00001111};
1112} // end anonymous namespace.
1113
Chris Lattner9fd73612008-04-21 18:56:49 +00001114namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001115class ARMTargetInfo : public TargetInfo {
Mike Stumpf90a29f2009-04-08 02:07:04 +00001116 enum {
1117 Armv4t,
1118 Armv5,
1119 Armv6,
1120 XScale
1121 } ArmArch;
Chris Lattner9fd73612008-04-21 18:56:49 +00001122public:
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001123 ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
1124 // FIXME: Are the defaults correct for ARM?
Eli Friedman2b161652008-08-21 00:13:15 +00001125 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1126 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
Chris Lattner433d9722009-04-23 04:22:04 +00001127 if (triple.find("arm-") == 0 || triple.find("armv6-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001128 ArmArch = Armv6;
Chris Lattner433d9722009-04-23 04:22:04 +00001129 else if (triple.find("armv5-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001130 ArmArch = Armv5;
Chris Lattner433d9722009-04-23 04:22:04 +00001131 else if (triple.find("armv4t-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001132 ArmArch = Armv4t;
Chris Lattner433d9722009-04-23 04:22:04 +00001133 else if (triple.find("xscale-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001134 ArmArch = XScale;
Chris Lattner433d9722009-04-23 04:22:04 +00001135 else if (triple.find("armv") == 0) {
1136 // FIXME: fuzzy match for other random weird arm triples. This is useful
1137 // for the static analyzer and other clients, but probably should be
1138 // re-evaluated when codegen is brought up.
1139 ArmArch = Armv6;
1140 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001141 }
Chris Lattner79682402009-03-20 15:52:06 +00001142 virtual void getTargetDefines(const LangOptions &Opts,
1143 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001144 // Target identification.
1145 Define(Defs, "__arm");
1146 Define(Defs, "__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001147
Chris Lattnerbef1d722009-03-02 22:27:17 +00001148 // Target properties.
1149 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001150
Mike Stumpf90a29f2009-04-08 02:07:04 +00001151 // Subtarget options.
1152 if (ArmArch == Armv6) {
1153 Define(Defs, "__ARM_ARCH_6K__");
1154 Define(Defs, "__THUMB_INTERWORK__");
1155 } else if (ArmArch == Armv5) {
1156 Define(Defs, "__ARM_ARCH_5TEJ__");
1157 Define(Defs, "__THUMB_INTERWORK__");
1158 Define(Defs, "__SOFTFP__");
1159 } else if (ArmArch == Armv4t) {
1160 Define(Defs, "__ARM_ARCH_4T__");
1161 Define(Defs, "__SOFTFP__");
1162 } else if (ArmArch == XScale) {
1163 Define(Defs, "__ARM_ARCH_5TE__");
1164 Define(Defs, "__XSCALE__");
1165 Define(Defs, "__SOFTFP__");
1166 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001167 Define(Defs, "__ARMEL__");
Eli Friedman468ca6d2009-05-29 19:00:15 +00001168 Define(Defs, "__APCS_32__");
1169 Define(Defs, "__VFP_FP__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001170 }
1171 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1172 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001173 // FIXME: Implement.
1174 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001175 NumRecords = 0;
1176 }
1177 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001178 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001179 }
1180 virtual const char *getTargetPrefix() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001181 return "arm";
Chris Lattner9fd73612008-04-21 18:56:49 +00001182 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001183 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9fd73612008-04-21 18:56:49 +00001184 unsigned &NumNames) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001185 // FIXME: Implement.
1186 Names = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001187 NumNames = 0;
1188 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001189 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9fd73612008-04-21 18:56:49 +00001190 unsigned &NumAliases) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001191 // FIXME: Implement.
1192 Aliases = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001193 NumAliases = 0;
1194 }
Anders Carlsson36834a72009-02-28 17:11:49 +00001195 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001196 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001197 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001198 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001199 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001200 case 'l': // r0-r7
1201 case 'h': // r8-r15
1202 case 'w': // VFP Floating point register single precision
1203 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001204 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001205 return true;
1206 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001207 return false;
1208 }
1209 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001210 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001211 return "";
1212 }
1213};
1214} // end anonymous namespace.
1215
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001216
1217namespace {
1218class DarwinARMTargetInfo : public ARMTargetInfo {
1219public:
Eli Friedman8f575172009-04-19 21:38:35 +00001220 DarwinARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {
1221 TLSSupported = false;
1222 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001223
Chris Lattner79682402009-03-20 15:52:06 +00001224 virtual void getTargetDefines(const LangOptions &Opts,
1225 std::vector<char> &Defines) const {
1226 ARMTargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001227 getDarwinDefines(Defines, Opts);
1228 getDarwinIPhoneOSDefines(Defines, getTargetTriple());
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001229 }
1230};
1231} // end anonymous namespace.
1232
Chris Lattner4b009652007-07-25 00:24:17 +00001233namespace {
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001234// arm FreeBSD target
1235class FreeBSDARMTargetInfo : public ARMTargetInfo {
1236public:
1237 FreeBSDARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {}
1238 virtual void getTargetDefines(const LangOptions &Opts,
1239 std::vector<char> &Defines) const {
1240 ARMTargetInfo::getTargetDefines(Opts, Defines);
1241 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
1242 }
1243};
1244} // end anonymous namespace
1245
1246namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001247class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001248 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1249 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001250public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001251 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1252 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001253 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1254 "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001255 }
Chris Lattner79682402009-03-20 15:52:06 +00001256 virtual void getTargetDefines(const LangOptions &Opts,
1257 std::vector<char> &Defines) const {
Eli Friedmana456b7f2009-05-22 01:12:57 +00001258 DefineStd(Defines, "sparc", Opts);
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001259 Define(Defines, "__sparcv8");
Eli Friedmana456b7f2009-05-22 01:12:57 +00001260 Define(Defines, "__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001261 }
1262 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1263 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001264 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001265 }
1266 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001267 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001268 }
1269 virtual const char *getTargetPrefix() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001270 return "sparc";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001271 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001272 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001273 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001274 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001275 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001276 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001277 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001278 // FIXME: Implement!
1279 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001280 }
1281 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001282 // FIXME: Implement!
1283 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001284 }
1285};
1286
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001287const char * const SparcV8TargetInfo::GCCRegNames[] = {
1288 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1289 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1290 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1291 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1292};
1293
Anton Korobeynikove7772382009-05-03 13:42:53 +00001294void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001295 unsigned &NumNames) const {
1296 Names = GCCRegNames;
1297 NumNames = llvm::array_lengthof(GCCRegNames);
1298}
1299
1300const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001301 { { "g0" }, "r0" },
1302 { { "g1" }, "r1" },
1303 { { "g2" }, "r2" },
1304 { { "g3" }, "r3" },
1305 { { "g4" }, "r4" },
1306 { { "g5" }, "r5" },
1307 { { "g6" }, "r6" },
1308 { { "g7" }, "r7" },
1309 { { "o0" }, "r8" },
1310 { { "o1" }, "r9" },
1311 { { "o2" }, "r10" },
1312 { { "o3" }, "r11" },
1313 { { "o4" }, "r12" },
1314 { { "o5" }, "r13" },
1315 { { "o6", "sp" }, "r14" },
1316 { { "o7" }, "r15" },
1317 { { "l0" }, "r16" },
1318 { { "l1" }, "r17" },
1319 { { "l2" }, "r18" },
1320 { { "l3" }, "r19" },
1321 { { "l4" }, "r20" },
1322 { { "l5" }, "r21" },
1323 { { "l6" }, "r22" },
1324 { { "l7" }, "r23" },
1325 { { "i0" }, "r24" },
1326 { { "i1" }, "r25" },
1327 { { "i2" }, "r26" },
1328 { { "i3" }, "r27" },
1329 { { "i4" }, "r28" },
1330 { { "i5" }, "r29" },
1331 { { "i6", "fp" }, "r30" },
1332 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001333};
1334
Anton Korobeynikove7772382009-05-03 13:42:53 +00001335void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001336 unsigned &NumAliases) const {
1337 Aliases = GCCRegAliases;
1338 NumAliases = llvm::array_lengthof(GCCRegAliases);
1339}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001340} // end anonymous namespace.
1341
Eli Friedmanff158dd2008-08-20 07:28:14 +00001342namespace {
1343class SolarisSparcV8TargetInfo : public SparcV8TargetInfo {
1344public:
1345 SolarisSparcV8TargetInfo(const std::string& triple) :
Eli Friedman7cca0982008-11-02 02:43:55 +00001346 SparcV8TargetInfo(triple) {
1347 SizeType = UnsignedInt;
1348 PtrDiffType = SignedInt;
Eli Friedmana456b7f2009-05-22 01:12:57 +00001349 WCharType = SignedLong;
1350 // FIXME: WIntType should be SignedLong
1351 UserLabelPrefix = "";
Eli Friedman7cca0982008-11-02 02:43:55 +00001352 }
Eli Friedmanff158dd2008-08-20 07:28:14 +00001353
Chris Lattner79682402009-03-20 15:52:06 +00001354 virtual void getTargetDefines(const LangOptions &Opts,
1355 std::vector<char> &Defines) const {
1356 SparcV8TargetInfo::getTargetDefines(Opts, Defines);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001357 getSolarisDefines(Opts, Defines);
Eli Friedmanff158dd2008-08-20 07:28:14 +00001358 }
1359};
1360} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001361
Chris Lattner85970f32008-05-08 05:58:21 +00001362namespace {
1363 class PIC16TargetInfo : public TargetInfo{
1364 public:
1365 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001366 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001367 IntWidth = 16;
1368 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001369 IntMaxTWidth = 32;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001370 PointerWidth = 16;
1371 IntAlign = 8;
1372 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001373 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001374 SizeType = UnsignedInt;
1375 IntMaxType = SignedLong;
1376 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001377 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001378 PtrDiffType = SignedInt;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001379 FloatWidth = 32;
1380 FloatAlign = 32;
1381 DoubleWidth = 32;
1382 DoubleAlign = 32;
1383 LongDoubleWidth = 32;
1384 LongDoubleAlign = 32;
1385 FloatFormat = &llvm::APFloat::IEEEsingle;
1386 DoubleFormat = &llvm::APFloat::IEEEsingle;
1387 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1388 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32";
1389
Chris Lattner85970f32008-05-08 05:58:21 +00001390 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001391 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1392 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001393 virtual void getTargetDefines(const LangOptions &Opts,
1394 std::vector<char> &Defines) const {
Chris Lattner85970f32008-05-08 05:58:21 +00001395 Define(Defines, "__pic16");
1396 }
1397 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1398 unsigned &NumRecords) const {}
1399 virtual const char *getVAListDeclaration() const { return "";}
1400 virtual const char *getClobbers() const {return "";}
Sanjiv Gupta88b4e512009-04-21 06:01:16 +00001401 virtual const char *getTargetPrefix() const {return "pic16";}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001402 virtual void getGCCRegNames(const char * const *&Names,
1403 unsigned &NumNames) const {}
1404 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001405 TargetInfo::ConstraintInfo &info) const {
1406 return true;
1407 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001408 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001409 unsigned &NumAliases) const {}
1410 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1411 };
1412}
1413
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001414namespace {
1415 class MSP430TargetInfo : public TargetInfo {
1416 static const char * const GCCRegNames[];
1417 public:
1418 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1419 TLSSupported = false;
1420 IntWidth = 16;
1421 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001422 IntMaxTWidth = 32;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001423 PointerWidth = 16;
1424 IntAlign = 8;
1425 LongAlign = LongLongAlign = 8;
1426 PointerAlign = 8;
1427 SizeType = UnsignedInt;
1428 IntMaxType = SignedLong;
1429 UIntMaxType = UnsignedLong;
1430 IntPtrType = SignedShort;
1431 PtrDiffType = SignedInt;
1432 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
1433 }
1434 virtual void getTargetDefines(const LangOptions &Opts,
1435 std::vector<char> &Defines) const {
1436 Define(Defines, "MSP430");
1437 Define(Defines, "__MSP430__");
1438 // FIXME: defines for different 'flavours' of MCU
1439 }
1440 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1441 unsigned &NumRecords) const {
1442 // FIXME: Implement.
1443 Records = 0;
1444 NumRecords = 0;
1445 }
1446 virtual const char *getTargetPrefix() const {
1447 return "msp430";
1448 }
1449 virtual void getGCCRegNames(const char * const *&Names,
1450 unsigned &NumNames) const;
1451 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1452 unsigned &NumAliases) const {
1453 // No aliases.
1454 Aliases = 0;
1455 NumAliases = 0;
1456 }
1457 virtual bool validateAsmConstraint(const char *&Name,
1458 TargetInfo::ConstraintInfo &info) const {
1459 // FIXME: implement
1460 return true;
1461 }
1462 virtual const char *getClobbers() const {
1463 // FIXME: Is this really right?
1464 return "";
1465 }
1466 virtual const char *getVAListDeclaration() const {
1467 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001468 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001469 }
1470 };
1471
1472 const char * const MSP430TargetInfo::GCCRegNames[] = {
1473 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1474 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1475 };
1476
1477 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1478 unsigned &NumNames) const {
1479 Names = GCCRegNames;
1480 NumNames = llvm::array_lengthof(GCCRegNames);
1481 }
1482}
1483
1484
Chris Lattner4b009652007-07-25 00:24:17 +00001485//===----------------------------------------------------------------------===//
1486// Driver code
1487//===----------------------------------------------------------------------===//
1488
Ted Kremenekb97d7672007-12-04 17:07:35 +00001489static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +00001490 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
1491 TT[4] == '-' && TT[1] - '3' < 6);
1492}
1493
Chris Lattnerfc457002008-03-05 01:18:20 +00001494/// CreateTargetInfo - Return the target info object for the specified target
1495/// triple.
1496TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Eli Friedman2b161652008-08-21 00:13:15 +00001497 // OS detection; this isn't really anywhere near complete.
1498 // Additions and corrections are welcome.
1499 bool isDarwin = T.find("-darwin") != std::string::npos;
Chris Lattnerd4faca42008-08-23 18:23:14 +00001500 bool isDragonFly = T.find("-dragonfly") != std::string::npos;
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001501 bool isOpenBSD = T.find("-openbsd") != std::string::npos;
Chris Lattner98cb2a22008-10-16 17:04:31 +00001502 bool isFreeBSD = T.find("-freebsd") != std::string::npos;
Eli Friedman2b161652008-08-21 00:13:15 +00001503 bool isSolaris = T.find("-solaris") != std::string::npos;
1504 bool isLinux = T.find("-linux") != std::string::npos;
1505 bool isWindows = T.find("-windows") != std::string::npos ||
1506 T.find("-win32") != std::string::npos ||
1507 T.find("-mingw") != std::string::npos;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001508
Eli Friedman2b161652008-08-21 00:13:15 +00001509 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0) {
1510 if (isDarwin)
1511 return new DarwinPPCTargetInfo(T);
1512 return new PPC32TargetInfo(T);
1513 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001514
Eli Friedman2b161652008-08-21 00:13:15 +00001515 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0) {
1516 if (isDarwin)
1517 return new DarwinPPC64TargetInfo(T);
1518 return new PPC64TargetInfo(T);
1519 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001520
Chris Lattner433d9722009-04-23 04:22:04 +00001521 if (T.find("armv") == 0 || T.find("arm-") == 0 || T.find("xscale") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001522 if (isDarwin)
1523 return new DarwinARMTargetInfo(T);
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001524 if (isFreeBSD)
1525 return new FreeBSDARMTargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001526 return new ARMTargetInfo(T);
1527 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001528
Eli Friedman2b161652008-08-21 00:13:15 +00001529 if (T.find("sparc-") == 0) {
1530 if (isSolaris)
1531 return new SolarisSparcV8TargetInfo(T);
1532 return new SparcV8TargetInfo(T);
1533 }
1534
Chris Lattner273dce42009-02-20 17:04:14 +00001535 if (T.find("x86_64-") == 0 || T.find("amd64-") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001536 if (isDarwin)
1537 return new DarwinX86_64TargetInfo(T);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001538 if (isLinux)
1539 return new LinuxX86_64TargetInfo(T);
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001540 if (isOpenBSD)
1541 return new OpenBSDX86_64TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001542 if (isFreeBSD)
1543 return new FreeBSDX86_64TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001544 if (isSolaris)
1545 return new SolarisX86_64TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001546 return new X86_64TargetInfo(T);
1547 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001548
Chris Lattner85970f32008-05-08 05:58:21 +00001549 if (T.find("pic16-") == 0)
1550 return new PIC16TargetInfo(T);
1551
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001552 if (T.find("msp430-") == 0)
1553 return new MSP430TargetInfo(T);
1554
Eli Friedman2b161652008-08-21 00:13:15 +00001555 if (IsX86(T)) {
1556 if (isDarwin)
1557 return new DarwinI386TargetInfo(T);
Eli Friedman5fb0a022008-08-21 00:24:02 +00001558 if (isLinux)
1559 return new LinuxX86_32TargetInfo(T);
Chris Lattnerd4faca42008-08-23 18:23:14 +00001560 if (isDragonFly)
1561 return new DragonFlyX86_32TargetInfo(T);
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001562 if (isOpenBSD)
1563 return new OpenBSDX86_32TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001564 if (isFreeBSD)
1565 return new FreeBSDX86_32TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001566 if (isSolaris)
1567 return new SolarisX86_32TargetInfo(T);
Eli Friedman23cb7912008-08-21 01:40:19 +00001568 if (isWindows)
1569 return new WindowsX86_32TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001570 return new X86_32TargetInfo(T);
1571 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001572
Chris Lattnerfc457002008-03-05 01:18:20 +00001573 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +00001574}