blob: 9910e28fcda9e65d340cda94329c9a09c8672fbe [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
Chris Lattnerab81f162009-03-20 15:55:34 +000073static void getFreeBSDDefines(const LangOptions &Opts, bool is64Bit,
74 const char *Triple, std::vector<char> &Defs) {
Chris Lattner98cb2a22008-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 Lattnerc345a802009-03-20 16:06:38 +000087 DefineStd(Defs, "unix", Opts);
Anton Korobeynikovfb820852009-02-14 16:42:50 +000088 Define(Defs, "__ELF__", "1");
Chris Lattner98cb2a22008-10-16 17:04:31 +000089 if (is64Bit) {
90 Define(Defs, "__LP64__");
91 }
92}
93
Chris Lattnerab81f162009-03-20 15:55:34 +000094static void getDragonFlyDefines(const LangOptions &Opts,
95 std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-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 Lattnerc345a802009-03-20 16:06:38 +0000102 DefineStd(Defs, "unix", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000103}
104
Chris Lattnerab81f162009-03-20 15:55:34 +0000105static void getLinuxDefines(const LangOptions &Opts, std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000106 // Linux defines; list based off of gcc output
Chris Lattnerc345a802009-03-20 16:06:38 +0000107 DefineStd(Defs, "unix", Opts);
108 DefineStd(Defs, "linux", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000109 Define(Defs, "__gnu_linux__");
Argiris Kirtzidis99de9532009-02-14 15:02:45 +0000110 Define(Defs, "__ELF__", "1");
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000111}
112
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000113/// getDarwinNumber - Parse the 'darwin number' out of the specific targe
Daniel Dunbar93f64532009-04-10 19:52:24 +0000114/// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
Chris Lattnerd7bc88b2008-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 Dunbar93f64532009-04-10 19:52:24 +0000117static bool getDarwinNumber(const char *Triple, unsigned &Maj, unsigned &Min, unsigned &Revision) {
118 Maj = Min = Revision = 0;
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000119 const char *Darwin = strstr(Triple, "-darwin");
120 if (Darwin == 0) return false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000121
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000122 Darwin += strlen("-darwin");
123 if (Darwin[0] < '0' || Darwin[0] > '9')
124 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000125
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000126 Maj = Darwin[0]-'0';
127 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000128
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000129 // Handle "darwin11".
130 if (Maj == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
Daniel Dunbar93f64532009-04-10 19:52:24 +0000131 Maj = Maj*10 + (Darwin[0] - '0');
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000132 ++Darwin;
133 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000134
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000135 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
Daniel Dunbar93f64532009-04-10 19:52:24 +0000136 if (Darwin[0] != '.')
137 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000138
Daniel Dunbar93f64532009-04-10 19:52:24 +0000139 ++Darwin;
140 if (Darwin[0] < '0' || Darwin[0] > '9')
141 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000142
Daniel Dunbar93f64532009-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 Korobeynikove7772382009-05-03 13:42:53 +0000151
Daniel Dunbar93f64532009-04-10 19:52:24 +0000152 // Handle revision darwin8.9.1
153 if (Darwin[0] != '.')
154 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000155
Daniel Dunbar93f64532009-04-10 19:52:24 +0000156 ++Darwin;
157 if (Darwin[0] < '0' || Darwin[0] > '9')
158 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000159
Daniel Dunbar93f64532009-04-10 19:52:24 +0000160 Revision = Darwin[0]-'0';
161 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000162
Daniel Dunbar93f64532009-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 Korobeynikove7772382009-05-03 13:42:53 +0000167
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000168 return true;
169}
170
Daniel Dunbar93f64532009-04-10 19:52:24 +0000171static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
Chris Lattner59122202009-06-23 00:43:21 +0000172 Define(Defs, "__APPLE_CC__", "5621");
Eli Friedman872996c2008-08-20 02:34:37 +0000173 Define(Defs, "__APPLE__");
174 Define(Defs, "__MACH__");
Chris Lattner8405e092009-02-05 07:19:24 +0000175 Define(Defs, "OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000176
Chris Lattner8181e622009-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 Korobeynikove7772382009-05-03 13:42:53 +0000179
Chris Lattner8181e622009-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 Lattner33854aa2009-04-07 04:48:21 +0000182 Define(Defs, "__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +0000183 else
Chris Lattner33854aa2009-04-07 04:48:21 +0000184 Define(Defs, "__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +0000185
186 if (Opts.Static)
187 Define(Defs, "__STATIC__");
188 else
189 Define(Defs, "__DYNAMIC__");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000190}
191
192static void getDarwinOSXDefines(std::vector<char> &Defs, const char *Triple) {
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000193 // Figure out which "darwin number" the target triple is. "darwin9" -> 10.5.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000194 unsigned Maj, Min, Rev;
195 if (getDarwinNumber(Triple, Maj, Min, Rev)) {
196 char MacOSXStr[] = "1000";
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000197 if (Maj >= 4 && Maj <= 13) { // 10.0-10.9
198 // darwin7 -> 1030, darwin8 -> 1040, darwin9 -> 1050, etc.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000199 MacOSXStr[2] = '0' + Maj-4;
200 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000201
Daniel Dunbar93f64532009-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 Korobeynikove7772382009-05-03 13:42:53 +0000209static void getDarwinIPhoneOSDefines(std::vector<char> &Defs,
Daniel Dunbar93f64532009-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 Lattnerc5dc8eb2008-09-30 01:00:25 +0000220 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000221
Daniel Dunbar93f64532009-04-10 19:52:24 +0000222 // Handle minor version: 2.2 -> darwin9.2.2 -> 20200
223 iPhoneOSStr[2] = std::min(Rev, 9U)+'0';
Anton Korobeynikove7772382009-05-03 13:42:53 +0000224 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
Daniel Dunbar93f64532009-04-10 19:52:24 +0000225 iPhoneOSStr);
Chris Lattnerc5dc8eb2008-09-30 01:00:25 +0000226 }
Eli Friedman872996c2008-08-20 02:34:37 +0000227}
Chris Lattner4b009652007-07-25 00:24:17 +0000228
Chris Lattnerd7bc88b2008-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 Korobeynikove7772382009-05-03 13:42:53 +0000233
Daniel Dunbar93f64532009-04-10 19:52:24 +0000234 unsigned Maj, Min, Rev;
235 if (!getDarwinNumber(Triple, Maj, Min, Rev))
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000236 return;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000237
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000238 // Blocks default to on for 10.6 (darwin10) and beyond.
Fariborz Jahaniand09b9f72009-02-12 17:54:33 +0000239 // As does nonfragile-abi for 64bit mode
Anton Korobeynikove7772382009-05-03 13:42:53 +0000240 if (Maj > 9)
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000241 Opts.Blocks = 1;
Fariborz Jahanian27f58962009-02-24 23:34:44 +0000242
Fariborz Jahanian72efecb2009-02-24 23:38:42 +0000243 if (Maj >= 9 && Opts.ObjC1 && !strncmp(Triple, "x86_64", 6))
244 Opts.ObjCNonFragileABI = 1;
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000245}
246
Eli Friedman6b6ca942009-06-08 06:11:14 +0000247/// GetWindowsLanguageOptions - Set the default language options for Windows.
248static void GetWindowsLanguageOptions(LangOptions &Opts,
249 const char *Triple) {
250 Opts.Microsoft = true;
251}
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000252
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000253//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000254// Specific target implementations.
255//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000256
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000257namespace {
258// PPC abstract base class
259class PPCTargetInfo : public TargetInfo {
260 static const Builtin::Info BuiltinInfo[];
261 static const char * const GCCRegNames[];
262 static const TargetInfo::GCCRegAlias GCCRegAliases[];
263
264public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000265 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
266
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000267 virtual void getTargetBuiltins(const Builtin::Info *&Records,
268 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000269 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000270 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000271 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000272
Chris Lattner79682402009-03-20 15:52:06 +0000273 virtual void getTargetDefines(const LangOptions &Opts,
274 std::vector<char> &Defines) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000275
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000276 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000277 return "typedef char* __builtin_va_list;";
278 // This is the right definition for ABI/V4: System V.4/eabi.
279 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000280 " unsigned char gpr;"
281 " unsigned char fpr;"
282 " unsigned short reserved;"
283 " void* overflow_arg_area;"
284 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000285 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000286 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000287 virtual const char *getTargetPrefix() const {
288 return "ppc";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000289 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000290 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000291 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000292 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000293 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000294 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000295 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000296 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000297 default: return false;
298 case 'O': // Zero
299 return true;
300 case 'b': // Base register
301 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000302 Info.setAllowsRegister();
Anders Carlsson4ce42302007-11-27 04:11:28 +0000303 return true;
304 }
305 }
Eli Friedmand9389be2009-06-05 07:05:05 +0000306 virtual void getDefaultLangOptions(LangOptions &Opts) {
307 TargetInfo::getDefaultLangOptions(Opts);
308 Opts.CharIsSigned = false;
309 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000310 virtual const char *getClobbers() const {
311 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000312 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000313};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000314
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000315const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000316#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
317#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000318#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000319};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000320
321
Chris Lattnerbef1d722009-03-02 22:27:17 +0000322/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
323/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000324void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
325 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000326 // Target identification.
327 Define(Defs, "__ppc__");
328 Define(Defs, "_ARCH_PPC");
329 Define(Defs, "__POWERPC__");
330 if (PointerWidth == 64) {
331 Define(Defs, "_ARCH_PPC64");
332 Define(Defs, "_LP64");
333 Define(Defs, "__LP64__");
334 Define(Defs, "__ppc64__");
335 } else {
336 Define(Defs, "__ppc__");
337 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000338
Chris Lattnerbef1d722009-03-02 22:27:17 +0000339 // Target properties.
340 Define(Defs, "_BIG_ENDIAN");
341 Define(Defs, "__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000342
Chris Lattnerbef1d722009-03-02 22:27:17 +0000343 // Subtarget options.
344 Define(Defs, "__NATURAL_ALIGNMENT__");
345 Define(Defs, "__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000346
Chris Lattnerbef1d722009-03-02 22:27:17 +0000347 // FIXME: Should be controlled by command line option.
348 Define(Defs, "__LONG_DOUBLE_128__");
349}
350
Chris Lattner9fd73612008-04-21 18:56:49 +0000351
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000352const char * const PPCTargetInfo::GCCRegNames[] = {
353 "0", "1", "2", "3", "4", "5", "6", "7",
354 "8", "9", "10", "11", "12", "13", "14", "15",
355 "16", "17", "18", "19", "20", "21", "22", "23",
356 "24", "25", "26", "27", "28", "29", "30", "31",
357 "0", "1", "2", "3", "4", "5", "6", "7",
358 "8", "9", "10", "11", "12", "13", "14", "15",
359 "16", "17", "18", "19", "20", "21", "22", "23",
360 "24", "25", "26", "27", "28", "29", "30", "31",
361 "mq", "lr", "ctr", "ap",
362 "0", "1", "2", "3", "4", "5", "6", "7",
363 "xer",
364 "0", "1", "2", "3", "4", "5", "6", "7",
365 "8", "9", "10", "11", "12", "13", "14", "15",
366 "16", "17", "18", "19", "20", "21", "22", "23",
367 "24", "25", "26", "27", "28", "29", "30", "31",
368 "vrsave", "vscr",
369 "spe_acc", "spefscr",
370 "sfp"
371};
Chris Lattner4b009652007-07-25 00:24:17 +0000372
Anton Korobeynikove7772382009-05-03 13:42:53 +0000373void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000374 unsigned &NumNames) const {
375 Names = GCCRegNames;
376 NumNames = llvm::array_lengthof(GCCRegNames);
377}
Chris Lattner4b009652007-07-25 00:24:17 +0000378
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000379const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
380 // While some of these aliases do map to different registers
381 // they still share the same register name.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000382 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
383 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
384 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
385 { { "cr3", "fr3", "r3", "v3"}, "3" },
386 { { "cr4", "fr4", "r4", "v4"}, "4" },
387 { { "cr5", "fr5", "r5", "v5"}, "5" },
388 { { "cr6", "fr6", "r6", "v6"}, "6" },
389 { { "cr7", "fr7", "r7", "v7"}, "7" },
390 { { "fr8", "r8", "v8"}, "8" },
391 { { "fr9", "r9", "v9"}, "9" },
392 { { "fr10", "r10", "v10"}, "10" },
393 { { "fr11", "r11", "v11"}, "11" },
394 { { "fr12", "r12", "v12"}, "12" },
395 { { "fr13", "r13", "v13"}, "13" },
396 { { "fr14", "r14", "v14"}, "14" },
397 { { "fr15", "r15", "v15"}, "15" },
398 { { "fr16", "r16", "v16"}, "16" },
399 { { "fr17", "r17", "v17"}, "17" },
400 { { "fr18", "r18", "v18"}, "18" },
401 { { "fr19", "r19", "v19"}, "19" },
402 { { "fr20", "r20", "v20"}, "20" },
403 { { "fr21", "r21", "v21"}, "21" },
404 { { "fr22", "r22", "v22"}, "22" },
405 { { "fr23", "r23", "v23"}, "23" },
406 { { "fr24", "r24", "v24"}, "24" },
407 { { "fr25", "r25", "v25"}, "25" },
408 { { "fr26", "r26", "v26"}, "26" },
409 { { "fr27", "r27", "v27"}, "27" },
410 { { "fr28", "r28", "v28"}, "28" },
411 { { "fr29", "r29", "v29"}, "29" },
412 { { "fr30", "r30", "v30"}, "30" },
413 { { "fr31", "r31", "v31"}, "31" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000414};
415
Anton Korobeynikove7772382009-05-03 13:42:53 +0000416void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000417 unsigned &NumAliases) const {
418 Aliases = GCCRegAliases;
419 NumAliases = llvm::array_lengthof(GCCRegAliases);
420}
421} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000422
423namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000424class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000425public:
Eli Friedman2b161652008-08-21 00:13:15 +0000426 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
427 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
428 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
429 }
Chris Lattner4b009652007-07-25 00:24:17 +0000430};
431} // end anonymous namespace.
432
433namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000434class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000435public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000436 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000437 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2b161652008-08-21 00:13:15 +0000438 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
439 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
Chris Lattnere5fde952008-05-09 06:17:04 +0000440 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000441};
442} // end anonymous namespace.
443
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000444
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000445namespace {
446class DarwinPPCTargetInfo : public PPC32TargetInfo {
447public:
448 DarwinPPCTargetInfo(const std::string& triple) : PPC32TargetInfo(triple) {}
Chris Lattner79682402009-03-20 15:52:06 +0000449 virtual void getTargetDefines(const LangOptions &Opts,
450 std::vector<char> &Defines) const {
451 PPC32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000452 getDarwinDefines(Defines, Opts);
453 getDarwinOSXDefines(Defines, getTargetTriple());
Chris Lattner4b009652007-07-25 00:24:17 +0000454 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000455
Chris Lattnerddae7102008-12-04 22:54:33 +0000456 /// getDefaultLangOptions - Allow the target to specify default settings for
457 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000458 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000459 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000460 PPC32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000461 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000462 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000463};
464} // end anonymous namespace.
465
466namespace {
467class DarwinPPC64TargetInfo : public PPC64TargetInfo {
468public:
469 DarwinPPC64TargetInfo(const std::string& triple) : PPC64TargetInfo(triple) {}
Chris Lattner79682402009-03-20 15:52:06 +0000470 virtual void getTargetDefines(const LangOptions &Opts,
471 std::vector<char> &Defines) const {
472 PPC64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000473 getDarwinDefines(Defines, Opts);
474 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000475 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000476
Chris Lattnerddae7102008-12-04 22:54:33 +0000477 /// getDefaultLangOptions - Allow the target to specify default settings for
478 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000479 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000480 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000481 PPC64TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000482 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000483 }
Chris Lattner4b009652007-07-25 00:24:17 +0000484};
485} // end anonymous namespace.
486
487namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000488// Namespace for x86 abstract base class
489const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000490#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
491#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000492#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000493};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000494
Eli Friedman872996c2008-08-20 02:34:37 +0000495const char *GCCRegNames[] = {
496 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
497 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
498 "argp", "flags", "fspr", "dirflag", "frame",
499 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
500 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
501 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
502 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
503};
504
505const TargetInfo::GCCRegAlias GCCRegAliases[] = {
506 { { "al", "ah", "eax", "rax" }, "ax" },
507 { { "bl", "bh", "ebx", "rbx" }, "bx" },
508 { { "cl", "ch", "ecx", "rcx" }, "cx" },
509 { { "dl", "dh", "edx", "rdx" }, "dx" },
510 { { "esi", "rsi" }, "si" },
511 { { "edi", "rdi" }, "di" },
512 { { "esp", "rsp" }, "sp" },
513 { { "ebp", "rbp" }, "bp" },
514};
515
516// X86 target abstract base class; x86-32 and x86-64 are very close, so
517// most of the implementation can be shared.
518class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000519 enum X86SSEEnum {
520 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
521 } SSELevel;
Eli Friedman872996c2008-08-20 02:34:37 +0000522public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000523 X86TargetInfo(const std::string& triple)
Daniel Dunbar07181d72009-05-06 03:16:41 +0000524 : TargetInfo(triple), SSELevel(NoMMXSSE) {
Eli Friedman872996c2008-08-20 02:34:37 +0000525 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000526 }
527 virtual void getTargetBuiltins(const Builtin::Info *&Records,
528 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000529 Records = BuiltinInfo;
530 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000531 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000532 virtual const char *getTargetPrefix() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000533 return "x86";
Anton Korobeynikove7772382009-05-03 13:42:53 +0000534 }
535 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000536 unsigned &NumNames) const {
537 Names = GCCRegNames;
538 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000539 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000540 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000541 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000542 Aliases = GCCRegAliases;
543 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000544 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000545 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000546 TargetInfo::ConstraintInfo &info) const;
547 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000548 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000549 return "~{dirflag},~{fpsr},~{flags}";
550 }
Chris Lattner79682402009-03-20 15:52:06 +0000551 virtual void getTargetDefines(const LangOptions &Opts,
552 std::vector<char> &Defines) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000553 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
554 const std::string &Name,
555 bool Enabled) const;
Daniel Dunbar07181d72009-05-06 03:16:41 +0000556 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000557 llvm::StringMap<bool> &Features) const;
Daniel Dunbar07181d72009-05-06 03:16:41 +0000558 virtual void HandleTargetFeatures(const llvm::StringMap<bool> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +0000559};
Chris Lattner7d6220c2009-03-02 22:20:04 +0000560
Daniel Dunbar07181d72009-05-06 03:16:41 +0000561void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000562 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +0000563 // FIXME: This should not be here.
564 Features["3dnow"] = false;
565 Features["3dnowa"] = false;
566 Features["mmx"] = false;
567 Features["sse"] = false;
568 Features["sse2"] = false;
569 Features["sse3"] = false;
570 Features["ssse3"] = false;
571 Features["sse41"] = false;
572 Features["sse42"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000573
Daniel Dunbar07181d72009-05-06 03:16:41 +0000574 // LLVM does not currently recognize this.
575 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000576
Daniel Dunbar07181d72009-05-06 03:16:41 +0000577 // FIXME: This *really* should not be here.
578
579 // X86_64 always has SSE2.
580 if (PointerWidth == 64)
581 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
582
Daniel Dunbarc2e55de2009-05-06 21:56:32 +0000583 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
584 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
585 ;
586 else if (CPU == "pentium-mmx" || CPU == "pentium2")
587 setFeatureEnabled(Features, "mmx", true);
588 else if (CPU == "pentium3")
589 setFeatureEnabled(Features, "sse", true);
590 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
591 setFeatureEnabled(Features, "sse2", true);
592 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
593 setFeatureEnabled(Features, "sse3", true);
594 else if (CPU == "core2")
595 setFeatureEnabled(Features, "ssse3", true);
596 else if (CPU == "penryn") {
597 setFeatureEnabled(Features, "sse4", true);
598 Features["sse42"] = false;
599 } else if (CPU == "atom")
600 setFeatureEnabled(Features, "sse3", true);
601 else if (CPU == "corei7")
602 setFeatureEnabled(Features, "sse4", true);
603 else if (CPU == "k6" || CPU == "winchip-c6")
604 setFeatureEnabled(Features, "mmx", true);
605 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
606 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
607 setFeatureEnabled(Features, "mmx", true);
608 setFeatureEnabled(Features, "3dnow", true);
609 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
610 setFeatureEnabled(Features, "sse", true);
611 setFeatureEnabled(Features, "3dnowa", true);
612 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
613 CPU == "athlon-fx") {
614 setFeatureEnabled(Features, "sse2", true);
615 setFeatureEnabled(Features, "3dnowa", true);
616 } else if (CPU == "c3-2")
617 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +0000618}
619
Daniel Dunbar0838f962009-05-06 21:07:50 +0000620bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
621 const std::string &Name,
622 bool Enabled) const {
623 // FIXME: This *really* should not be here.
624 if (!Features.count(Name) && Name != "sse4")
625 return false;
626
627 if (Enabled) {
628 if (Name == "mmx")
629 Features["mmx"] = true;
630 else if (Name == "sse")
631 Features["mmx"] = Features["sse"] = true;
632 else if (Name == "sse2")
633 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
634 else if (Name == "sse3")
635 Features["mmx"] = Features["sse"] = Features["sse2"] =
636 Features["sse3"] = true;
637 else if (Name == "ssse3")
638 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
639 Features["ssse3"] = true;
640 else if (Name == "sse4")
641 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
642 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
643 else if (Name == "3dnow")
644 Features["3dnowa"] = true;
645 else if (Name == "3dnowa")
646 Features["3dnow"] = Features["3dnowa"] = true;
647 } else {
648 if (Name == "mmx")
649 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
650 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
651 else if (Name == "sse")
652 Features["sse"] = Features["sse2"] = Features["sse3"] =
653 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
654 else if (Name == "sse2")
655 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
656 Features["sse41"] = Features["sse42"] = false;
657 else if (Name == "sse3")
658 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
659 Features["sse42"] = false;
660 else if (Name == "ssse3")
661 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
662 else if (Name == "sse4")
663 Features["sse41"] = Features["sse42"] = false;
664 else if (Name == "3dnow")
665 Features["3dnow"] = Features["3dnowa"] = false;
666 else if (Name == "3dnowa")
667 Features["3dnowa"] = false;
668 }
669
670 return true;
671}
672
Daniel Dunbar07181d72009-05-06 03:16:41 +0000673/// HandleTargetOptions - Perform initialization based on the user
674/// configured set of features.
675void X86TargetInfo::HandleTargetFeatures(const llvm::StringMap<bool>&Features) {
676 if (Features.lookup("sse42"))
677 SSELevel = SSE42;
678 else if (Features.lookup("sse41"))
679 SSELevel = SSE41;
680 else if (Features.lookup("ssse3"))
681 SSELevel = SSSE3;
682 else if (Features.lookup("sse3"))
683 SSELevel = SSE3;
684 else if (Features.lookup("sse2"))
685 SSELevel = SSE2;
686 else if (Features.lookup("sse"))
687 SSELevel = SSE1;
688 else if (Features.lookup("mmx"))
689 SSELevel = MMX;
Chris Lattner7d6220c2009-03-02 22:20:04 +0000690}
Chris Lattnerbef1d722009-03-02 22:27:17 +0000691
692/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
693/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000694void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
695 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000696 // Target identification.
697 if (PointerWidth == 64) {
698 Define(Defs, "_LP64");
699 Define(Defs, "__LP64__");
700 Define(Defs, "__amd64__");
701 Define(Defs, "__amd64");
702 Define(Defs, "__x86_64");
703 Define(Defs, "__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000704 } else {
Chris Lattnerc345a802009-03-20 16:06:38 +0000705 DefineStd(Defs, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +0000706 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000707
Chris Lattnerbef1d722009-03-02 22:27:17 +0000708 // Target properties.
709 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000710
Chris Lattnerbef1d722009-03-02 22:27:17 +0000711 // Subtarget options.
712 Define(Defs, "__nocona");
713 Define(Defs, "__nocona__");
714 Define(Defs, "__tune_nocona__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000715 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +0000716
Chris Lattner25ac1c12009-04-19 17:32:33 +0000717 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
718 // functions in glibc header files that use FP Stack inline asm which the
719 // backend can't deal with (PR879).
720 Define(Defs, "__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000721
Chris Lattner715fe4c2009-03-02 22:40:39 +0000722 // Each case falls through to the previous one here.
723 switch (SSELevel) {
724 case SSE42:
725 Define(Defs, "__SSE4_2__");
726 case SSE41:
727 Define(Defs, "__SSE4_1__");
728 case SSSE3:
729 Define(Defs, "__SSSE3__");
730 case SSE3:
731 Define(Defs, "__SSE3__");
732 case SSE2:
733 Define(Defs, "__SSE2__");
734 Define(Defs, "__SSE2_MATH__"); // -mfp-math=sse always implied.
735 case SSE1:
736 Define(Defs, "__SSE__");
737 Define(Defs, "__SSE_MATH__"); // -mfp-math=sse always implied.
738 case MMX:
739 Define(Defs, "__MMX__");
740 case NoMMXSSE:
741 break;
742 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000743}
Anton Korobeynikove7772382009-05-03 13:42:53 +0000744
745
Eli Friedman872996c2008-08-20 02:34:37 +0000746bool
Anders Carlsson36834a72009-02-28 17:11:49 +0000747X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000748 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000749 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +0000750 default: return false;
751 case 'a': // eax.
752 case 'b': // ebx.
753 case 'c': // ecx.
754 case 'd': // edx.
755 case 'S': // esi.
756 case 'D': // edi.
757 case 'A': // edx:eax.
758 case 't': // top of floating point stack.
759 case 'u': // second from top of floating point stack.
760 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +0000761 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +0000762 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +0000763 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000764 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000765 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +0000766 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +0000767 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +0000768 case 'N': // unsigned 8-bit integer constant for use with in and out
769 // instructions.
Eli Friedman7e17aed2009-06-08 20:45:44 +0000770 case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000771 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +0000772 return true;
773 }
774}
775
776std::string
777X86TargetInfo::convertConstraint(const char Constraint) const {
778 switch (Constraint) {
779 case 'a': return std::string("{ax}");
780 case 'b': return std::string("{bx}");
781 case 'c': return std::string("{cx}");
782 case 'd': return std::string("{dx}");
783 case 'S': return std::string("{si}");
784 case 'D': return std::string("{di}");
785 case 't': // top of floating point stack.
786 return std::string("{st}");
787 case 'u': // second from top of floating point stack.
788 return std::string("{st(1)}"); // second from top of floating point stack.
789 default:
790 return std::string(1, Constraint);
791 }
792}
Eli Friedman872996c2008-08-20 02:34:37 +0000793} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000794
795namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000796// X86-32 generic target
797class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000798public:
Eli Friedman872996c2008-08-20 02:34:37 +0000799 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
800 DoubleAlign = LongLongAlign = 32;
801 LongDoubleWidth = 96;
802 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000803 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
804 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
805 "a0:0:64-f80:32:32";
Eli Friedman04ede302009-03-29 20:31:09 +0000806 SizeType = UnsignedInt;
807 PtrDiffType = SignedInt;
808 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000809 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +0000810 }
811 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000812 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000813 }
Eli Friedman872996c2008-08-20 02:34:37 +0000814};
815} // end anonymous namespace
816
817namespace {
818// x86-32 Darwin (OS X) target
819class DarwinI386TargetInfo : public X86_32TargetInfo {
820public:
821 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
822 LongDoubleWidth = 128;
823 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +0000824 SizeType = UnsignedLong;
825 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000826 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
827 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
828 "a0:0:64-f80:128:128";
Eli Friedman8f575172009-04-19 21:38:35 +0000829 TLSSupported = false;
Eli Friedman872996c2008-08-20 02:34:37 +0000830 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000831
Anton Korobeynikove7772382009-05-03 13:42:53 +0000832 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000833 return IsConstant ? "\01LC" : "\01lC";
834 }
835
Anton Korobeynikove7772382009-05-03 13:42:53 +0000836 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000837 return "__utf16_string_";
838 }
839
Anton Korobeynikove7772382009-05-03 13:42:53 +0000840 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000841 return "__TEXT,__ustring";
842 }
843
Anton Korobeynikove7772382009-05-03 13:42:53 +0000844 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000845 return "\01LC";
846 }
847
Chris Lattner79682402009-03-20 15:52:06 +0000848 virtual void getTargetDefines(const LangOptions &Opts,
849 std::vector<char> &Defines) const {
850 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000851 getDarwinDefines(Defines, Opts);
852 getDarwinOSXDefines(Defines, getTargetTriple());
Eli Friedman872996c2008-08-20 02:34:37 +0000853 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000854
Chris Lattnerddae7102008-12-04 22:54:33 +0000855 /// getDefaultLangOptions - Allow the target to specify default settings for
856 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000857 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000858 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000859 X86_32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000860 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000861 }
Eli Friedman872996c2008-08-20 02:34:37 +0000862};
863} // end anonymous namespace
864
865namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +0000866// x86-32 FreeBSD target
867class FreeBSDX86_32TargetInfo : public X86_32TargetInfo {
868public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000869 FreeBSDX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000870 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000871 virtual void getTargetDefines(const LangOptions &Opts,
872 std::vector<char> &Defines) const {
873 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000874 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +0000875 }
876};
877} // end anonymous namespace
878
879namespace {
Chris Lattnerd4faca42008-08-23 18:23:14 +0000880// x86-32 DragonFly target
881class DragonFlyX86_32TargetInfo : public X86_32TargetInfo {
882public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000883 DragonFlyX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000884 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000885 virtual void getTargetDefines(const LangOptions &Opts,
886 std::vector<char> &Defines) const {
887 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000888 getDragonFlyDefines(Opts, Defines);
Chris Lattnerd4faca42008-08-23 18:23:14 +0000889 }
890};
891} // end anonymous namespace
892
893namespace {
Eli Friedman5fb0a022008-08-21 00:24:02 +0000894// x86-32 Linux target
895class LinuxX86_32TargetInfo : public X86_32TargetInfo {
896public:
897 LinuxX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +0000898 UserLabelPrefix = "";
Eli Friedman5fb0a022008-08-21 00:24:02 +0000899 }
Chris Lattner79682402009-03-20 15:52:06 +0000900 virtual void getTargetDefines(const LangOptions &Opts,
901 std::vector<char> &Defines) const {
902 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000903 getLinuxDefines(Opts, Defines);
Eli Friedman5fb0a022008-08-21 00:24:02 +0000904 }
905};
906} // end anonymous namespace
907
908namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +0000909// x86-32 Solaris target
910class SolarisX86_32TargetInfo : public X86_32TargetInfo {
911public:
912 SolarisX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
913 UserLabelPrefix = "";
Eli Friedmana456b7f2009-05-22 01:12:57 +0000914 WCharType = SignedLong;
915 // FIXME: WIntType should be SignedLong
Douglas Gregor5415abd2009-05-21 23:51:30 +0000916 }
917 virtual void getTargetDefines(const LangOptions &Opts,
918 std::vector<char> &Defines) const {
919 X86_32TargetInfo::getTargetDefines(Opts, Defines);
920 getSolarisDefines(Opts, Defines);
921 }
922};
923} // end anonymous namespace
924
925
926namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000927// x86-32 Windows target
928class WindowsX86_32TargetInfo : public X86_32TargetInfo {
929public:
930 WindowsX86_32TargetInfo(const std::string& triple)
931 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +0000932 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +0000933 WCharType = UnsignedShort;
Eli Friedman6b6ca942009-06-08 06:11:14 +0000934 WCharWidth = WCharAlign = 16;
Eli Friedmanb28055e2009-06-08 21:16:17 +0000935 DoubleAlign = LongLongAlign = 64;
936 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
937 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
938 "a0:0:64-f80:32:32";
Eli Friedman23cb7912008-08-21 01:40:19 +0000939 }
Chris Lattner79682402009-03-20 15:52:06 +0000940 virtual void getTargetDefines(const LangOptions &Opts,
941 std::vector<char> &Defines) const {
942 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Eli Friedman23cb7912008-08-21 01:40:19 +0000943 // This list is based off of the the list of things MingW defines
Eli Friedman23cb7912008-08-21 01:40:19 +0000944 Define(Defines, "_WIN32");
Chris Lattnerc345a802009-03-20 16:06:38 +0000945 DefineStd(Defines, "WIN32", Opts);
946 DefineStd(Defines, "WINNT", Opts);
Eli Friedman23cb7912008-08-21 01:40:19 +0000947 Define(Defines, "_X86_");
948 Define(Defines, "__MSVCRT__");
949 }
Eli Friedman6b6ca942009-06-08 06:11:14 +0000950
951 virtual void getDefaultLangOptions(LangOptions &Opts) {
952 X86_32TargetInfo::getDefaultLangOptions(Opts);
953 GetWindowsLanguageOptions(Opts, getTargetTriple());
954 }
Eli Friedman23cb7912008-08-21 01:40:19 +0000955};
956} // end anonymous namespace
957
958namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000959// x86-64 generic target
960class X86_64TargetInfo : public X86TargetInfo {
961public:
Chris Lattner79682402009-03-20 15:52:06 +0000962 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000963 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Chris Lattner4dfc45a2009-01-28 06:58:19 +0000964 DoubleAlign = LongLongAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000965 LongDoubleWidth = 128;
966 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +0000967 IntMaxType = SignedLong;
968 UIntMaxType = UnsignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000969 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +0000970
Eli Friedman2b161652008-08-21 00:13:15 +0000971 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
972 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Daniel Dunbarea390922009-06-08 22:39:13 +0000973 "a0:0:64-s0:64:64-f80:128:128";
Chris Lattner4b009652007-07-25 00:24:17 +0000974 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000975 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000976 return "typedef struct __va_list_tag {"
977 " unsigned gp_offset;"
978 " unsigned fp_offset;"
979 " void* overflow_arg_area;"
980 " void* reg_save_area;"
981 "} __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000982 }
Eli Friedman872996c2008-08-20 02:34:37 +0000983};
984} // end anonymous namespace
985
986namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +0000987// x86-64 FreeBSD target
988class FreeBSDX86_64TargetInfo : public X86_64TargetInfo {
989public:
Chris Lattner79682402009-03-20 15:52:06 +0000990 FreeBSDX86_64TargetInfo(const std::string &triple)
991 : X86_64TargetInfo(triple) {}
992 virtual void getTargetDefines(const LangOptions &Opts,
993 std::vector<char> &Defines) const {
994 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000995 getFreeBSDDefines(Opts, 1, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +0000996 }
997};
998} // end anonymous namespace
999
1000namespace {
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001001// x86-64 Linux target
1002class LinuxX86_64TargetInfo : public X86_64TargetInfo {
1003public:
1004 LinuxX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +00001005 UserLabelPrefix = "";
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001006 }
Chris Lattner79682402009-03-20 15:52:06 +00001007 virtual void getTargetDefines(const LangOptions &Opts,
1008 std::vector<char> &Defines) const {
1009 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +00001010 getLinuxDefines(Opts, Defines);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001011 }
1012};
1013} // end anonymous namespace
1014
1015namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +00001016// x86-64 Solaris target
1017class SolarisX86_64TargetInfo : public X86_64TargetInfo {
1018public:
1019 SolarisX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1020 UserLabelPrefix = "";
Douglas Gregor5415abd2009-05-21 23:51:30 +00001021 }
1022 virtual void getTargetDefines(const LangOptions &Opts,
1023 std::vector<char> &Defines) const {
1024 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1025 getSolarisDefines(Opts, Defines);
1026 }
1027};
1028} // end anonymous namespace
1029
1030namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001031// x86-64 Darwin (OS X) target
1032class DarwinX86_64TargetInfo : public X86_64TargetInfo {
1033public:
Eli Friedman8f575172009-04-19 21:38:35 +00001034 DarwinX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1035 TLSSupported = false;
1036 }
Eli Friedman872996c2008-08-20 02:34:37 +00001037
Anton Korobeynikove7772382009-05-03 13:42:53 +00001038 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001039 return IsConstant ? "\01LC" : "\01lC";
1040 }
1041
Anton Korobeynikove7772382009-05-03 13:42:53 +00001042 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001043 return "__utf16_string_";
1044 }
1045
Anton Korobeynikove7772382009-05-03 13:42:53 +00001046 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001047 return "__TEXT,__ustring";
1048 }
1049
Anton Korobeynikove7772382009-05-03 13:42:53 +00001050 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001051 return "\01L_unnamed_cfstring_";
1052 }
1053
Chris Lattner79682402009-03-20 15:52:06 +00001054 virtual void getTargetDefines(const LangOptions &Opts,
1055 std::vector<char> &Defines) const {
1056 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001057 getDarwinDefines(Defines, Opts);
1058 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001059 }
Daniel Dunbar34542952008-08-23 08:43:39 +00001060
Chris Lattnerddae7102008-12-04 22:54:33 +00001061 /// getDefaultLangOptions - Allow the target to specify default settings for
1062 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +00001063 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +00001064 virtual void getDefaultLangOptions(LangOptions &Opts) {
Chris Lattnerd7bc88b2008-12-04 23:20:07 +00001065 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +00001066 }
Chris Lattner4b009652007-07-25 00:24:17 +00001067};
1068} // end anonymous namespace.
1069
Chris Lattner9fd73612008-04-21 18:56:49 +00001070namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001071class ARMTargetInfo : public TargetInfo {
Mike Stumpf90a29f2009-04-08 02:07:04 +00001072 enum {
1073 Armv4t,
1074 Armv5,
1075 Armv6,
1076 XScale
1077 } ArmArch;
Chris Lattner9fd73612008-04-21 18:56:49 +00001078public:
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001079 ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
1080 // FIXME: Are the defaults correct for ARM?
Eli Friedman2b161652008-08-21 00:13:15 +00001081 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1082 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
Chris Lattner433d9722009-04-23 04:22:04 +00001083 if (triple.find("arm-") == 0 || triple.find("armv6-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001084 ArmArch = Armv6;
Chris Lattner433d9722009-04-23 04:22:04 +00001085 else if (triple.find("armv5-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001086 ArmArch = Armv5;
Chris Lattner433d9722009-04-23 04:22:04 +00001087 else if (triple.find("armv4t-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001088 ArmArch = Armv4t;
Chris Lattner433d9722009-04-23 04:22:04 +00001089 else if (triple.find("xscale-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001090 ArmArch = XScale;
Chris Lattner433d9722009-04-23 04:22:04 +00001091 else if (triple.find("armv") == 0) {
1092 // FIXME: fuzzy match for other random weird arm triples. This is useful
1093 // for the static analyzer and other clients, but probably should be
1094 // re-evaluated when codegen is brought up.
1095 ArmArch = Armv6;
1096 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001097 }
Chris Lattner79682402009-03-20 15:52:06 +00001098 virtual void getTargetDefines(const LangOptions &Opts,
1099 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001100 // Target identification.
1101 Define(Defs, "__arm");
1102 Define(Defs, "__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001103
Chris Lattnerbef1d722009-03-02 22:27:17 +00001104 // Target properties.
1105 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001106
Mike Stumpf90a29f2009-04-08 02:07:04 +00001107 // Subtarget options.
1108 if (ArmArch == Armv6) {
1109 Define(Defs, "__ARM_ARCH_6K__");
1110 Define(Defs, "__THUMB_INTERWORK__");
1111 } else if (ArmArch == Armv5) {
1112 Define(Defs, "__ARM_ARCH_5TEJ__");
1113 Define(Defs, "__THUMB_INTERWORK__");
1114 Define(Defs, "__SOFTFP__");
1115 } else if (ArmArch == Armv4t) {
1116 Define(Defs, "__ARM_ARCH_4T__");
1117 Define(Defs, "__SOFTFP__");
1118 } else if (ArmArch == XScale) {
1119 Define(Defs, "__ARM_ARCH_5TE__");
1120 Define(Defs, "__XSCALE__");
1121 Define(Defs, "__SOFTFP__");
1122 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001123 Define(Defs, "__ARMEL__");
Eli Friedman468ca6d2009-05-29 19:00:15 +00001124 Define(Defs, "__APCS_32__");
1125 Define(Defs, "__VFP_FP__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001126 }
1127 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1128 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001129 // FIXME: Implement.
1130 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001131 NumRecords = 0;
1132 }
1133 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001134 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001135 }
1136 virtual const char *getTargetPrefix() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001137 return "arm";
Chris Lattner9fd73612008-04-21 18:56:49 +00001138 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001139 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9fd73612008-04-21 18:56:49 +00001140 unsigned &NumNames) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001141 // FIXME: Implement.
1142 Names = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001143 NumNames = 0;
1144 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001145 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9fd73612008-04-21 18:56:49 +00001146 unsigned &NumAliases) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001147 // FIXME: Implement.
1148 Aliases = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001149 NumAliases = 0;
1150 }
Anders Carlsson36834a72009-02-28 17:11:49 +00001151 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001152 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001153 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001154 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001155 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001156 case 'l': // r0-r7
1157 case 'h': // r8-r15
1158 case 'w': // VFP Floating point register single precision
1159 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001160 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001161 return true;
1162 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001163 return false;
1164 }
1165 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001166 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001167 return "";
1168 }
1169};
1170} // end anonymous namespace.
1171
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001172
1173namespace {
1174class DarwinARMTargetInfo : public ARMTargetInfo {
1175public:
Eli Friedman8f575172009-04-19 21:38:35 +00001176 DarwinARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {
1177 TLSSupported = false;
1178 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001179
Chris Lattner79682402009-03-20 15:52:06 +00001180 virtual void getTargetDefines(const LangOptions &Opts,
1181 std::vector<char> &Defines) const {
1182 ARMTargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001183 getDarwinDefines(Defines, Opts);
1184 getDarwinIPhoneOSDefines(Defines, getTargetTriple());
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001185 }
1186};
1187} // end anonymous namespace.
1188
Chris Lattner4b009652007-07-25 00:24:17 +00001189namespace {
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001190// arm FreeBSD target
1191class FreeBSDARMTargetInfo : public ARMTargetInfo {
1192public:
1193 FreeBSDARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {}
1194 virtual void getTargetDefines(const LangOptions &Opts,
1195 std::vector<char> &Defines) const {
1196 ARMTargetInfo::getTargetDefines(Opts, Defines);
1197 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
1198 }
1199};
1200} // end anonymous namespace
1201
1202namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001203class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001204 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1205 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001206public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001207 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1208 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001209 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1210 "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001211 }
Chris Lattner79682402009-03-20 15:52:06 +00001212 virtual void getTargetDefines(const LangOptions &Opts,
1213 std::vector<char> &Defines) const {
Eli Friedmana456b7f2009-05-22 01:12:57 +00001214 DefineStd(Defines, "sparc", Opts);
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001215 Define(Defines, "__sparcv8");
Eli Friedmana456b7f2009-05-22 01:12:57 +00001216 Define(Defines, "__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001217 }
1218 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1219 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001220 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001221 }
1222 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001223 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001224 }
1225 virtual const char *getTargetPrefix() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001226 return "sparc";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001227 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001228 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001229 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001230 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001231 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001232 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001233 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001234 // FIXME: Implement!
1235 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001236 }
1237 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001238 // FIXME: Implement!
1239 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001240 }
1241};
1242
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001243const char * const SparcV8TargetInfo::GCCRegNames[] = {
1244 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1245 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1246 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1247 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1248};
1249
Anton Korobeynikove7772382009-05-03 13:42:53 +00001250void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001251 unsigned &NumNames) const {
1252 Names = GCCRegNames;
1253 NumNames = llvm::array_lengthof(GCCRegNames);
1254}
1255
1256const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001257 { { "g0" }, "r0" },
1258 { { "g1" }, "r1" },
1259 { { "g2" }, "r2" },
1260 { { "g3" }, "r3" },
1261 { { "g4" }, "r4" },
1262 { { "g5" }, "r5" },
1263 { { "g6" }, "r6" },
1264 { { "g7" }, "r7" },
1265 { { "o0" }, "r8" },
1266 { { "o1" }, "r9" },
1267 { { "o2" }, "r10" },
1268 { { "o3" }, "r11" },
1269 { { "o4" }, "r12" },
1270 { { "o5" }, "r13" },
1271 { { "o6", "sp" }, "r14" },
1272 { { "o7" }, "r15" },
1273 { { "l0" }, "r16" },
1274 { { "l1" }, "r17" },
1275 { { "l2" }, "r18" },
1276 { { "l3" }, "r19" },
1277 { { "l4" }, "r20" },
1278 { { "l5" }, "r21" },
1279 { { "l6" }, "r22" },
1280 { { "l7" }, "r23" },
1281 { { "i0" }, "r24" },
1282 { { "i1" }, "r25" },
1283 { { "i2" }, "r26" },
1284 { { "i3" }, "r27" },
1285 { { "i4" }, "r28" },
1286 { { "i5" }, "r29" },
1287 { { "i6", "fp" }, "r30" },
1288 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001289};
1290
Anton Korobeynikove7772382009-05-03 13:42:53 +00001291void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001292 unsigned &NumAliases) const {
1293 Aliases = GCCRegAliases;
1294 NumAliases = llvm::array_lengthof(GCCRegAliases);
1295}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001296} // end anonymous namespace.
1297
Eli Friedmanff158dd2008-08-20 07:28:14 +00001298namespace {
1299class SolarisSparcV8TargetInfo : public SparcV8TargetInfo {
1300public:
1301 SolarisSparcV8TargetInfo(const std::string& triple) :
Eli Friedman7cca0982008-11-02 02:43:55 +00001302 SparcV8TargetInfo(triple) {
1303 SizeType = UnsignedInt;
1304 PtrDiffType = SignedInt;
Eli Friedmana456b7f2009-05-22 01:12:57 +00001305 WCharType = SignedLong;
1306 // FIXME: WIntType should be SignedLong
1307 UserLabelPrefix = "";
Eli Friedman7cca0982008-11-02 02:43:55 +00001308 }
Eli Friedmanff158dd2008-08-20 07:28:14 +00001309
Chris Lattner79682402009-03-20 15:52:06 +00001310 virtual void getTargetDefines(const LangOptions &Opts,
1311 std::vector<char> &Defines) const {
1312 SparcV8TargetInfo::getTargetDefines(Opts, Defines);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001313 getSolarisDefines(Opts, Defines);
Eli Friedmanff158dd2008-08-20 07:28:14 +00001314 }
1315};
1316} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001317
Chris Lattner85970f32008-05-08 05:58:21 +00001318namespace {
1319 class PIC16TargetInfo : public TargetInfo{
1320 public:
1321 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001322 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001323 IntWidth = 16;
1324 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001325 IntMaxTWidth = 32;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001326 PointerWidth = 16;
1327 IntAlign = 8;
1328 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001329 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001330 SizeType = UnsignedInt;
1331 IntMaxType = SignedLong;
1332 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001333 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001334 PtrDiffType = SignedInt;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001335 FloatWidth = 32;
1336 FloatAlign = 32;
1337 DoubleWidth = 32;
1338 DoubleAlign = 32;
1339 LongDoubleWidth = 32;
1340 LongDoubleAlign = 32;
1341 FloatFormat = &llvm::APFloat::IEEEsingle;
1342 DoubleFormat = &llvm::APFloat::IEEEsingle;
1343 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1344 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32";
1345
Chris Lattner85970f32008-05-08 05:58:21 +00001346 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001347 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1348 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001349 virtual void getTargetDefines(const LangOptions &Opts,
1350 std::vector<char> &Defines) const {
Chris Lattner85970f32008-05-08 05:58:21 +00001351 Define(Defines, "__pic16");
1352 }
1353 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1354 unsigned &NumRecords) const {}
1355 virtual const char *getVAListDeclaration() const { return "";}
1356 virtual const char *getClobbers() const {return "";}
Sanjiv Gupta88b4e512009-04-21 06:01:16 +00001357 virtual const char *getTargetPrefix() const {return "pic16";}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001358 virtual void getGCCRegNames(const char * const *&Names,
1359 unsigned &NumNames) const {}
1360 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001361 TargetInfo::ConstraintInfo &info) const {
1362 return true;
1363 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001364 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001365 unsigned &NumAliases) const {}
1366 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1367 };
1368}
1369
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001370namespace {
1371 class MSP430TargetInfo : public TargetInfo {
1372 static const char * const GCCRegNames[];
1373 public:
1374 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1375 TLSSupported = false;
1376 IntWidth = 16;
1377 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001378 IntMaxTWidth = 32;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001379 PointerWidth = 16;
1380 IntAlign = 8;
1381 LongAlign = LongLongAlign = 8;
1382 PointerAlign = 8;
1383 SizeType = UnsignedInt;
1384 IntMaxType = SignedLong;
1385 UIntMaxType = UnsignedLong;
1386 IntPtrType = SignedShort;
1387 PtrDiffType = SignedInt;
1388 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
1389 }
1390 virtual void getTargetDefines(const LangOptions &Opts,
1391 std::vector<char> &Defines) const {
1392 Define(Defines, "MSP430");
1393 Define(Defines, "__MSP430__");
1394 // FIXME: defines for different 'flavours' of MCU
1395 }
1396 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1397 unsigned &NumRecords) const {
1398 // FIXME: Implement.
1399 Records = 0;
1400 NumRecords = 0;
1401 }
1402 virtual const char *getTargetPrefix() const {
1403 return "msp430";
1404 }
1405 virtual void getGCCRegNames(const char * const *&Names,
1406 unsigned &NumNames) const;
1407 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1408 unsigned &NumAliases) const {
1409 // No aliases.
1410 Aliases = 0;
1411 NumAliases = 0;
1412 }
1413 virtual bool validateAsmConstraint(const char *&Name,
1414 TargetInfo::ConstraintInfo &info) const {
1415 // FIXME: implement
1416 return true;
1417 }
1418 virtual const char *getClobbers() const {
1419 // FIXME: Is this really right?
1420 return "";
1421 }
1422 virtual const char *getVAListDeclaration() const {
1423 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001424 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001425 }
1426 };
1427
1428 const char * const MSP430TargetInfo::GCCRegNames[] = {
1429 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1430 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1431 };
1432
1433 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1434 unsigned &NumNames) const {
1435 Names = GCCRegNames;
1436 NumNames = llvm::array_lengthof(GCCRegNames);
1437 }
1438}
1439
1440
Chris Lattner4b009652007-07-25 00:24:17 +00001441//===----------------------------------------------------------------------===//
1442// Driver code
1443//===----------------------------------------------------------------------===//
1444
Ted Kremenekb97d7672007-12-04 17:07:35 +00001445static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +00001446 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
1447 TT[4] == '-' && TT[1] - '3' < 6);
1448}
1449
Chris Lattnerfc457002008-03-05 01:18:20 +00001450/// CreateTargetInfo - Return the target info object for the specified target
1451/// triple.
1452TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Eli Friedman2b161652008-08-21 00:13:15 +00001453 // OS detection; this isn't really anywhere near complete.
1454 // Additions and corrections are welcome.
1455 bool isDarwin = T.find("-darwin") != std::string::npos;
Chris Lattnerd4faca42008-08-23 18:23:14 +00001456 bool isDragonFly = T.find("-dragonfly") != std::string::npos;
Chris Lattner98cb2a22008-10-16 17:04:31 +00001457 bool isFreeBSD = T.find("-freebsd") != std::string::npos;
Eli Friedman2b161652008-08-21 00:13:15 +00001458 bool isSolaris = T.find("-solaris") != std::string::npos;
1459 bool isLinux = T.find("-linux") != std::string::npos;
1460 bool isWindows = T.find("-windows") != std::string::npos ||
1461 T.find("-win32") != std::string::npos ||
1462 T.find("-mingw") != std::string::npos;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001463
Eli Friedman2b161652008-08-21 00:13:15 +00001464 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0) {
1465 if (isDarwin)
1466 return new DarwinPPCTargetInfo(T);
1467 return new PPC32TargetInfo(T);
1468 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001469
Eli Friedman2b161652008-08-21 00:13:15 +00001470 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0) {
1471 if (isDarwin)
1472 return new DarwinPPC64TargetInfo(T);
1473 return new PPC64TargetInfo(T);
1474 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001475
Chris Lattner433d9722009-04-23 04:22:04 +00001476 if (T.find("armv") == 0 || T.find("arm-") == 0 || T.find("xscale") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001477 if (isDarwin)
1478 return new DarwinARMTargetInfo(T);
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001479 if (isFreeBSD)
1480 return new FreeBSDARMTargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001481 return new ARMTargetInfo(T);
1482 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001483
Eli Friedman2b161652008-08-21 00:13:15 +00001484 if (T.find("sparc-") == 0) {
1485 if (isSolaris)
1486 return new SolarisSparcV8TargetInfo(T);
1487 return new SparcV8TargetInfo(T);
1488 }
1489
Chris Lattner273dce42009-02-20 17:04:14 +00001490 if (T.find("x86_64-") == 0 || T.find("amd64-") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001491 if (isDarwin)
1492 return new DarwinX86_64TargetInfo(T);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001493 if (isLinux)
1494 return new LinuxX86_64TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001495 if (isFreeBSD)
1496 return new FreeBSDX86_64TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001497 if (isSolaris)
1498 return new SolarisX86_64TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001499 return new X86_64TargetInfo(T);
1500 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001501
Chris Lattner85970f32008-05-08 05:58:21 +00001502 if (T.find("pic16-") == 0)
1503 return new PIC16TargetInfo(T);
1504
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001505 if (T.find("msp430-") == 0)
1506 return new MSP430TargetInfo(T);
1507
Eli Friedman2b161652008-08-21 00:13:15 +00001508 if (IsX86(T)) {
1509 if (isDarwin)
1510 return new DarwinI386TargetInfo(T);
Eli Friedman5fb0a022008-08-21 00:24:02 +00001511 if (isLinux)
1512 return new LinuxX86_32TargetInfo(T);
Chris Lattnerd4faca42008-08-23 18:23:14 +00001513 if (isDragonFly)
1514 return new DragonFlyX86_32TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001515 if (isFreeBSD)
1516 return new FreeBSDX86_32TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001517 if (isSolaris)
1518 return new SolarisX86_32TargetInfo(T);
Eli Friedman23cb7912008-08-21 01:40:19 +00001519 if (isWindows)
1520 return new WindowsX86_32TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001521 return new X86_32TargetInfo(T);
1522 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001523
Chris Lattnerfc457002008-03-05 01:18:20 +00001524 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +00001525}