blob: b4e32e9d9f371f66dc8459cc8f2ea5693ae936ad [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
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +000015// FIXME: Layering violation
Chris Lattner4b009652007-07-25 00:24:17 +000016#include "clang/AST/Builtins.h"
Anders Carlssone1449c12007-12-09 23:17:02 +000017#include "clang/AST/TargetBuiltins.h"
Chris Lattner4b009652007-07-25 00:24:17 +000018#include "clang/Basic/TargetInfo.h"
Chris Lattnerddae7102008-12-04 22:54:33 +000019#include "clang/Basic/LangOptions.h"
Anders Carlsson7dd1c952007-11-24 23:38:12 +000020#include "llvm/ADT/STLExtras.h"
Eli Friedmand4011892008-05-20 14:27:34 +000021#include "llvm/ADT/APFloat.h"
Chris Lattnerc345a802009-03-20 16:06:38 +000022#include "llvm/ADT/SmallString.h"
Chris Lattner4b009652007-07-25 00:24:17 +000023using namespace clang;
24
Chris Lattner4b009652007-07-25 00:24:17 +000025//===----------------------------------------------------------------------===//
26// Common code shared among targets.
27//===----------------------------------------------------------------------===//
28
Chris Lattner0db667a2007-10-06 06:57:34 +000029static void Define(std::vector<char> &Buf, const char *Macro,
30 const char *Val = "1") {
31 const char *Def = "#define ";
32 Buf.insert(Buf.end(), Def, Def+strlen(Def));
33 Buf.insert(Buf.end(), Macro, Macro+strlen(Macro));
34 Buf.push_back(' ');
35 Buf.insert(Buf.end(), Val, Val+strlen(Val));
36 Buf.push_back('\n');
37}
38
Chris Lattnerc345a802009-03-20 16:06:38 +000039/// DefineStd - Define a macro name and standard variants. For example if
40/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
41/// when in GNU mode.
Anton Korobeynikove7772382009-05-03 13:42:53 +000042static void DefineStd(std::vector<char> &Buf, const char *MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000043 const LangOptions &Opts) {
44 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000045
Chris Lattnerc345a802009-03-20 16:06:38 +000046 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
47 // in the user's namespace.
48 if (Opts.GNUMode)
49 Define(Buf, MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000050
Chris Lattnerc345a802009-03-20 16:06:38 +000051 // Define __unix.
52 llvm::SmallString<20> TmpStr;
53 TmpStr = "__";
54 TmpStr += MacroName;
55 Define(Buf, TmpStr.c_str());
Anton Korobeynikove7772382009-05-03 13:42:53 +000056
Chris Lattnerc345a802009-03-20 16:06:38 +000057 // Define __unix__.
58 TmpStr += "__";
59 Define(Buf, TmpStr.c_str());
60}
61
Chris Lattnerbd00eb82008-10-05 21:50:58 +000062//===----------------------------------------------------------------------===//
63// Defines specific to certain operating systems.
64//===----------------------------------------------------------------------===//
65
Douglas Gregor5415abd2009-05-21 23:51:30 +000066static void getSolarisDefines(const LangOptions &Opts, std::vector<char> &Defs) {
67 DefineStd(Defs, "sun", Opts);
68 DefineStd(Defs, "unix", Opts);
Eli Friedmana456b7f2009-05-22 01:12:57 +000069 Define(Defs, "__ELF__");
70 Define(Defs, "__svr4__");
71 Define(Defs, "__SVR4");
Eli Friedmanff158dd2008-08-20 07:28:14 +000072}
Chris Lattner4b009652007-07-25 00:24:17 +000073
Chris Lattnerab81f162009-03-20 15:55:34 +000074static void getFreeBSDDefines(const LangOptions &Opts, bool is64Bit,
75 const char *Triple, std::vector<char> &Defs) {
Chris Lattner98cb2a22008-10-16 17:04:31 +000076 // FreeBSD defines; list based off of gcc output
77
78 const char *FreeBSD = strstr(Triple, "-freebsd");
79 FreeBSD += strlen("-freebsd");
80 char release[] = "X";
81 release[0] = FreeBSD[0];
82 char version[] = "X00001";
83 version[0] = FreeBSD[0];
84
85 Define(Defs, "__FreeBSD__", release);
86 Define(Defs, "__FreeBSD_cc_version", version);
87 Define(Defs, "__KPRINTF_ATTRIBUTE__");
Chris Lattnerc345a802009-03-20 16:06:38 +000088 DefineStd(Defs, "unix", Opts);
Anton Korobeynikovfb820852009-02-14 16:42:50 +000089 Define(Defs, "__ELF__", "1");
Chris Lattner98cb2a22008-10-16 17:04:31 +000090 if (is64Bit) {
91 Define(Defs, "__LP64__");
92 }
93}
94
Chris Lattnerab81f162009-03-20 15:55:34 +000095static void getDragonFlyDefines(const LangOptions &Opts,
96 std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-10-05 21:50:58 +000097 // DragonFly defines; list based off of gcc output
98 Define(Defs, "__DragonFly__");
99 Define(Defs, "__DragonFly_cc_version", "100001");
100 Define(Defs, "__ELF__");
101 Define(Defs, "__KPRINTF_ATTRIBUTE__");
102 Define(Defs, "__tune_i386__");
Chris Lattnerc345a802009-03-20 16:06:38 +0000103 DefineStd(Defs, "unix", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000104}
105
Chris Lattnerab81f162009-03-20 15:55:34 +0000106static void getLinuxDefines(const LangOptions &Opts, std::vector<char> &Defs) {
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000107 // Linux defines; list based off of gcc output
Chris Lattnerc345a802009-03-20 16:06:38 +0000108 DefineStd(Defs, "unix", Opts);
109 DefineStd(Defs, "linux", Opts);
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000110 Define(Defs, "__gnu_linux__");
Argiris Kirtzidis99de9532009-02-14 15:02:45 +0000111 Define(Defs, "__ELF__", "1");
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000112}
113
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000114/// getDarwinNumber - Parse the 'darwin number' out of the specific targe
Daniel Dunbar93f64532009-04-10 19:52:24 +0000115/// triple. For example, if we have darwin8.5 return 8,5,0. If any entry is
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000116/// not defined, return 0's. Return true if we have -darwin in the string or
117/// false otherwise.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000118static bool getDarwinNumber(const char *Triple, unsigned &Maj, unsigned &Min, unsigned &Revision) {
119 Maj = Min = Revision = 0;
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000120 const char *Darwin = strstr(Triple, "-darwin");
121 if (Darwin == 0) return false;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000122
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000123 Darwin += strlen("-darwin");
124 if (Darwin[0] < '0' || Darwin[0] > '9')
125 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000126
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000127 Maj = Darwin[0]-'0';
128 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000129
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000130 // Handle "darwin11".
131 if (Maj == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
Daniel Dunbar93f64532009-04-10 19:52:24 +0000132 Maj = Maj*10 + (Darwin[0] - '0');
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000133 ++Darwin;
134 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000135
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000136 // Handle minor version: 10.4.9 -> darwin8.9 -> "1049"
Daniel Dunbar93f64532009-04-10 19:52:24 +0000137 if (Darwin[0] != '.')
138 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000139
Daniel Dunbar93f64532009-04-10 19:52:24 +0000140 ++Darwin;
141 if (Darwin[0] < '0' || Darwin[0] > '9')
142 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000143
Daniel Dunbar93f64532009-04-10 19:52:24 +0000144 Min = Darwin[0]-'0';
145 ++Darwin;
146
147 // Handle 10.4.11 -> darwin8.11
148 if (Min == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
149 Min = Min*10 + (Darwin[0] - '0');
150 ++Darwin;
151 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000152
Daniel Dunbar93f64532009-04-10 19:52:24 +0000153 // Handle revision darwin8.9.1
154 if (Darwin[0] != '.')
155 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000156
Daniel Dunbar93f64532009-04-10 19:52:24 +0000157 ++Darwin;
158 if (Darwin[0] < '0' || Darwin[0] > '9')
159 return true;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000160
Daniel Dunbar93f64532009-04-10 19:52:24 +0000161 Revision = Darwin[0]-'0';
162 ++Darwin;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000163
Daniel Dunbar93f64532009-04-10 19:52:24 +0000164 if (Revision == 1 && Darwin[0] >= '0' && Darwin[0] <= '9') {
165 Revision = Revision*10 + (Darwin[0] - '0');
166 ++Darwin;
167 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000168
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000169 return true;
170}
171
Daniel Dunbar93f64532009-04-10 19:52:24 +0000172static void getDarwinDefines(std::vector<char> &Defs, const LangOptions &Opts) {
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 },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000318#include "clang/AST/PPCBuiltins.def"
319};
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 },
Eli Friedman872996c2008-08-20 02:34:37 +0000492#include "clang/AST/X86Builtins.def"
493};
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.
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000770 Info.setAllowsRegister();
Eli Friedman872996c2008-08-20 02:34:37 +0000771 return true;
772 }
773}
774
775std::string
776X86TargetInfo::convertConstraint(const char Constraint) const {
777 switch (Constraint) {
778 case 'a': return std::string("{ax}");
779 case 'b': return std::string("{bx}");
780 case 'c': return std::string("{cx}");
781 case 'd': return std::string("{dx}");
782 case 'S': return std::string("{si}");
783 case 'D': return std::string("{di}");
784 case 't': // top of floating point stack.
785 return std::string("{st}");
786 case 'u': // second from top of floating point stack.
787 return std::string("{st(1)}"); // second from top of floating point stack.
788 default:
789 return std::string(1, Constraint);
790 }
791}
Eli Friedman872996c2008-08-20 02:34:37 +0000792} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000793
794namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000795// X86-32 generic target
796class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000797public:
Eli Friedman872996c2008-08-20 02:34:37 +0000798 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
799 DoubleAlign = LongLongAlign = 32;
800 LongDoubleWidth = 96;
801 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000802 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
803 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
804 "a0:0:64-f80:32:32";
Eli Friedman04ede302009-03-29 20:31:09 +0000805 SizeType = UnsignedInt;
806 PtrDiffType = SignedInt;
807 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000808 RegParmMax = 3;
Eli Friedman872996c2008-08-20 02:34:37 +0000809 }
810 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000811 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000812 }
Eli Friedman872996c2008-08-20 02:34:37 +0000813};
814} // end anonymous namespace
815
816namespace {
817// x86-32 Darwin (OS X) target
818class DarwinI386TargetInfo : public X86_32TargetInfo {
819public:
820 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
821 LongDoubleWidth = 128;
822 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +0000823 SizeType = UnsignedLong;
824 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000825 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
826 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
827 "a0:0:64-f80:128:128";
Eli Friedman8f575172009-04-19 21:38:35 +0000828 TLSSupported = false;
Eli Friedman872996c2008-08-20 02:34:37 +0000829 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000830
Anton Korobeynikove7772382009-05-03 13:42:53 +0000831 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000832 return IsConstant ? "\01LC" : "\01lC";
833 }
834
Anton Korobeynikove7772382009-05-03 13:42:53 +0000835 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000836 return "__utf16_string_";
837 }
838
Anton Korobeynikove7772382009-05-03 13:42:53 +0000839 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +0000840 return "__TEXT,__ustring";
841 }
842
Anton Korobeynikove7772382009-05-03 13:42:53 +0000843 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000844 return "\01LC";
845 }
846
Chris Lattner79682402009-03-20 15:52:06 +0000847 virtual void getTargetDefines(const LangOptions &Opts,
848 std::vector<char> &Defines) const {
849 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000850 getDarwinDefines(Defines, Opts);
851 getDarwinOSXDefines(Defines, getTargetTriple());
Eli Friedman872996c2008-08-20 02:34:37 +0000852 }
Daniel Dunbarc3a48932009-03-31 23:42:16 +0000853
Chris Lattnerddae7102008-12-04 22:54:33 +0000854 /// getDefaultLangOptions - Allow the target to specify default settings for
855 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +0000856 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +0000857 virtual void getDefaultLangOptions(LangOptions &Opts) {
Eli Friedmand9389be2009-06-05 07:05:05 +0000858 X86_32TargetInfo::getDefaultLangOptions(Opts);
Chris Lattnerd7bc88b2008-12-04 23:20:07 +0000859 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +0000860 }
Eli Friedman872996c2008-08-20 02:34:37 +0000861};
862} // end anonymous namespace
863
864namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +0000865// x86-32 FreeBSD target
866class FreeBSDX86_32TargetInfo : public X86_32TargetInfo {
867public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000868 FreeBSDX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000869 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000870 virtual void getTargetDefines(const LangOptions &Opts,
871 std::vector<char> &Defines) const {
872 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000873 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +0000874 }
875};
876} // end anonymous namespace
877
878namespace {
Chris Lattnerd4faca42008-08-23 18:23:14 +0000879// x86-32 DragonFly target
880class DragonFlyX86_32TargetInfo : public X86_32TargetInfo {
881public:
Eli Friedman7cca0982008-11-02 02:43:55 +0000882 DragonFlyX86_32TargetInfo(const std::string& triple) :
Eli Friedman04ede302009-03-29 20:31:09 +0000883 X86_32TargetInfo(triple) { }
Chris Lattner79682402009-03-20 15:52:06 +0000884 virtual void getTargetDefines(const LangOptions &Opts,
885 std::vector<char> &Defines) const {
886 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000887 getDragonFlyDefines(Opts, Defines);
Chris Lattnerd4faca42008-08-23 18:23:14 +0000888 }
889};
890} // end anonymous namespace
891
892namespace {
Eli Friedman5fb0a022008-08-21 00:24:02 +0000893// x86-32 Linux target
894class LinuxX86_32TargetInfo : public X86_32TargetInfo {
895public:
896 LinuxX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +0000897 UserLabelPrefix = "";
Eli Friedman5fb0a022008-08-21 00:24:02 +0000898 }
Chris Lattner79682402009-03-20 15:52:06 +0000899 virtual void getTargetDefines(const LangOptions &Opts,
900 std::vector<char> &Defines) const {
901 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000902 getLinuxDefines(Opts, Defines);
Eli Friedman5fb0a022008-08-21 00:24:02 +0000903 }
904};
905} // end anonymous namespace
906
907namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +0000908// x86-32 Solaris target
909class SolarisX86_32TargetInfo : public X86_32TargetInfo {
910public:
911 SolarisX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
912 UserLabelPrefix = "";
Eli Friedmana456b7f2009-05-22 01:12:57 +0000913 WCharType = SignedLong;
914 // FIXME: WIntType should be SignedLong
Douglas Gregor5415abd2009-05-21 23:51:30 +0000915 }
916 virtual void getTargetDefines(const LangOptions &Opts,
917 std::vector<char> &Defines) const {
918 X86_32TargetInfo::getTargetDefines(Opts, Defines);
919 getSolarisDefines(Opts, Defines);
920 }
921};
922} // end anonymous namespace
923
924
925namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000926// x86-32 Windows target
927class WindowsX86_32TargetInfo : public X86_32TargetInfo {
928public:
929 WindowsX86_32TargetInfo(const std::string& triple)
930 : X86_32TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +0000931 TLSSupported = false;
Eli Friedman6b6ca942009-06-08 06:11:14 +0000932 WCharType = SignedShort;
933 WCharWidth = WCharAlign = 16;
Eli Friedman23cb7912008-08-21 01:40:19 +0000934 }
Chris Lattner79682402009-03-20 15:52:06 +0000935 virtual void getTargetDefines(const LangOptions &Opts,
936 std::vector<char> &Defines) const {
937 X86_32TargetInfo::getTargetDefines(Opts, Defines);
Eli Friedman23cb7912008-08-21 01:40:19 +0000938 // This list is based off of the the list of things MingW defines
Eli Friedman23cb7912008-08-21 01:40:19 +0000939 Define(Defines, "_WIN32");
Chris Lattnerc345a802009-03-20 16:06:38 +0000940 DefineStd(Defines, "WIN32", Opts);
941 DefineStd(Defines, "WINNT", Opts);
Eli Friedman23cb7912008-08-21 01:40:19 +0000942 Define(Defines, "_X86_");
943 Define(Defines, "__MSVCRT__");
944 }
Eli Friedman6b6ca942009-06-08 06:11:14 +0000945
946 virtual void getDefaultLangOptions(LangOptions &Opts) {
947 X86_32TargetInfo::getDefaultLangOptions(Opts);
948 GetWindowsLanguageOptions(Opts, getTargetTriple());
949 }
Eli Friedman23cb7912008-08-21 01:40:19 +0000950};
951} // end anonymous namespace
952
953namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000954// x86-64 generic target
955class X86_64TargetInfo : public X86TargetInfo {
956public:
Chris Lattner79682402009-03-20 15:52:06 +0000957 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000958 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Chris Lattner4dfc45a2009-01-28 06:58:19 +0000959 DoubleAlign = LongLongAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000960 LongDoubleWidth = 128;
961 LongDoubleAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +0000962 IntMaxType = SignedLong;
963 UIntMaxType = UnsignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +0000964 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +0000965
Eli Friedman2b161652008-08-21 00:13:15 +0000966 DescriptionString = "e-p:64:64:64-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:128:128";
Chris Lattner4b009652007-07-25 00:24:17 +0000969 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000970 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000971 return "typedef struct __va_list_tag {"
972 " unsigned gp_offset;"
973 " unsigned fp_offset;"
974 " void* overflow_arg_area;"
975 " void* reg_save_area;"
976 "} __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000977 }
Eli Friedman872996c2008-08-20 02:34:37 +0000978};
979} // end anonymous namespace
980
981namespace {
Chris Lattner98cb2a22008-10-16 17:04:31 +0000982// x86-64 FreeBSD target
983class FreeBSDX86_64TargetInfo : public X86_64TargetInfo {
984public:
Chris Lattner79682402009-03-20 15:52:06 +0000985 FreeBSDX86_64TargetInfo(const std::string &triple)
986 : X86_64TargetInfo(triple) {}
987 virtual void getTargetDefines(const LangOptions &Opts,
988 std::vector<char> &Defines) const {
989 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +0000990 getFreeBSDDefines(Opts, 1, getTargetTriple(), Defines);
Chris Lattner98cb2a22008-10-16 17:04:31 +0000991 }
992};
993} // end anonymous namespace
994
995namespace {
Daniel Dunbare5a80f22008-09-23 17:37:57 +0000996// x86-64 Linux target
997class LinuxX86_64TargetInfo : public X86_64TargetInfo {
998public:
999 LinuxX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
Chris Lattner5edfe012008-10-05 19:44:25 +00001000 UserLabelPrefix = "";
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001001 }
Chris Lattner79682402009-03-20 15:52:06 +00001002 virtual void getTargetDefines(const LangOptions &Opts,
1003 std::vector<char> &Defines) const {
1004 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Chris Lattnerab81f162009-03-20 15:55:34 +00001005 getLinuxDefines(Opts, Defines);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001006 }
1007};
1008} // end anonymous namespace
1009
1010namespace {
Douglas Gregor5415abd2009-05-21 23:51:30 +00001011// x86-64 Solaris target
1012class SolarisX86_64TargetInfo : public X86_64TargetInfo {
1013public:
1014 SolarisX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1015 UserLabelPrefix = "";
Douglas Gregor5415abd2009-05-21 23:51:30 +00001016 }
1017 virtual void getTargetDefines(const LangOptions &Opts,
1018 std::vector<char> &Defines) const {
1019 X86_64TargetInfo::getTargetDefines(Opts, Defines);
1020 getSolarisDefines(Opts, Defines);
1021 }
1022};
1023} // end anonymous namespace
1024
1025namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001026// x86-64 Darwin (OS X) target
1027class DarwinX86_64TargetInfo : public X86_64TargetInfo {
1028public:
Eli Friedman8f575172009-04-19 21:38:35 +00001029 DarwinX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
1030 TLSSupported = false;
1031 }
Eli Friedman872996c2008-08-20 02:34:37 +00001032
Anton Korobeynikove7772382009-05-03 13:42:53 +00001033 virtual const char *getStringSymbolPrefix(bool IsConstant) const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001034 return IsConstant ? "\01LC" : "\01lC";
1035 }
1036
Anton Korobeynikove7772382009-05-03 13:42:53 +00001037 virtual const char *getUnicodeStringSymbolPrefix() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001038 return "__utf16_string_";
1039 }
1040
Anton Korobeynikove7772382009-05-03 13:42:53 +00001041 virtual const char *getUnicodeStringSection() const {
Daniel Dunbar6a916482009-04-03 00:57:44 +00001042 return "__TEXT,__ustring";
1043 }
1044
Anton Korobeynikove7772382009-05-03 13:42:53 +00001045 virtual const char *getCFStringSymbolPrefix() const {
Daniel Dunbarc3a48932009-03-31 23:42:16 +00001046 return "\01L_unnamed_cfstring_";
1047 }
1048
Chris Lattner79682402009-03-20 15:52:06 +00001049 virtual void getTargetDefines(const LangOptions &Opts,
1050 std::vector<char> &Defines) const {
1051 X86_64TargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001052 getDarwinDefines(Defines, Opts);
1053 getDarwinOSXDefines(Defines, getTargetTriple());
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001054 }
Daniel Dunbar34542952008-08-23 08:43:39 +00001055
Chris Lattnerddae7102008-12-04 22:54:33 +00001056 /// getDefaultLangOptions - Allow the target to specify default settings for
1057 /// various language options. These may be overridden by command line
Anton Korobeynikove7772382009-05-03 13:42:53 +00001058 /// options.
Chris Lattnerddae7102008-12-04 22:54:33 +00001059 virtual void getDefaultLangOptions(LangOptions &Opts) {
Chris Lattnerd7bc88b2008-12-04 23:20:07 +00001060 GetDarwinLanguageOptions(Opts, getTargetTriple());
Chris Lattnerddae7102008-12-04 22:54:33 +00001061 }
Chris Lattner4b009652007-07-25 00:24:17 +00001062};
1063} // end anonymous namespace.
1064
Chris Lattner9fd73612008-04-21 18:56:49 +00001065namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001066class ARMTargetInfo : public TargetInfo {
Mike Stumpf90a29f2009-04-08 02:07:04 +00001067 enum {
1068 Armv4t,
1069 Armv5,
1070 Armv6,
1071 XScale
1072 } ArmArch;
Chris Lattner9fd73612008-04-21 18:56:49 +00001073public:
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001074 ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
1075 // FIXME: Are the defaults correct for ARM?
Eli Friedman2b161652008-08-21 00:13:15 +00001076 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1077 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
Chris Lattner433d9722009-04-23 04:22:04 +00001078 if (triple.find("arm-") == 0 || triple.find("armv6-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001079 ArmArch = Armv6;
Chris Lattner433d9722009-04-23 04:22:04 +00001080 else if (triple.find("armv5-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001081 ArmArch = Armv5;
Chris Lattner433d9722009-04-23 04:22:04 +00001082 else if (triple.find("armv4t-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001083 ArmArch = Armv4t;
Chris Lattner433d9722009-04-23 04:22:04 +00001084 else if (triple.find("xscale-") == 0)
Mike Stumpf90a29f2009-04-08 02:07:04 +00001085 ArmArch = XScale;
Chris Lattner433d9722009-04-23 04:22:04 +00001086 else if (triple.find("armv") == 0) {
1087 // FIXME: fuzzy match for other random weird arm triples. This is useful
1088 // for the static analyzer and other clients, but probably should be
1089 // re-evaluated when codegen is brought up.
1090 ArmArch = Armv6;
1091 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001092 }
Chris Lattner79682402009-03-20 15:52:06 +00001093 virtual void getTargetDefines(const LangOptions &Opts,
1094 std::vector<char> &Defs) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001095 // Target identification.
1096 Define(Defs, "__arm");
1097 Define(Defs, "__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001098
Chris Lattnerbef1d722009-03-02 22:27:17 +00001099 // Target properties.
1100 Define(Defs, "__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001101
Mike Stumpf90a29f2009-04-08 02:07:04 +00001102 // Subtarget options.
1103 if (ArmArch == Armv6) {
1104 Define(Defs, "__ARM_ARCH_6K__");
1105 Define(Defs, "__THUMB_INTERWORK__");
1106 } else if (ArmArch == Armv5) {
1107 Define(Defs, "__ARM_ARCH_5TEJ__");
1108 Define(Defs, "__THUMB_INTERWORK__");
1109 Define(Defs, "__SOFTFP__");
1110 } else if (ArmArch == Armv4t) {
1111 Define(Defs, "__ARM_ARCH_4T__");
1112 Define(Defs, "__SOFTFP__");
1113 } else if (ArmArch == XScale) {
1114 Define(Defs, "__ARM_ARCH_5TE__");
1115 Define(Defs, "__XSCALE__");
1116 Define(Defs, "__SOFTFP__");
1117 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001118 Define(Defs, "__ARMEL__");
Eli Friedman468ca6d2009-05-29 19:00:15 +00001119 Define(Defs, "__APCS_32__");
1120 Define(Defs, "__VFP_FP__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001121 }
1122 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1123 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001124 // FIXME: Implement.
1125 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001126 NumRecords = 0;
1127 }
1128 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001129 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001130 }
1131 virtual const char *getTargetPrefix() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001132 return "arm";
Chris Lattner9fd73612008-04-21 18:56:49 +00001133 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001134 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9fd73612008-04-21 18:56:49 +00001135 unsigned &NumNames) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001136 // FIXME: Implement.
1137 Names = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001138 NumNames = 0;
1139 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001140 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9fd73612008-04-21 18:56:49 +00001141 unsigned &NumAliases) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001142 // FIXME: Implement.
1143 Aliases = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +00001144 NumAliases = 0;
1145 }
Anders Carlsson36834a72009-02-28 17:11:49 +00001146 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001147 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001148 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001149 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001150 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001151 case 'l': // r0-r7
1152 case 'h': // r8-r15
1153 case 'w': // VFP Floating point register single precision
1154 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001155 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001156 return true;
1157 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001158 return false;
1159 }
1160 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001161 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001162 return "";
1163 }
1164};
1165} // end anonymous namespace.
1166
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001167
1168namespace {
1169class DarwinARMTargetInfo : public ARMTargetInfo {
1170public:
Eli Friedman8f575172009-04-19 21:38:35 +00001171 DarwinARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {
1172 TLSSupported = false;
1173 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001174
Chris Lattner79682402009-03-20 15:52:06 +00001175 virtual void getTargetDefines(const LangOptions &Opts,
1176 std::vector<char> &Defines) const {
1177 ARMTargetInfo::getTargetDefines(Opts, Defines);
Daniel Dunbar93f64532009-04-10 19:52:24 +00001178 getDarwinDefines(Defines, Opts);
1179 getDarwinIPhoneOSDefines(Defines, getTargetTriple());
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001180 }
1181};
1182} // end anonymous namespace.
1183
Chris Lattner4b009652007-07-25 00:24:17 +00001184namespace {
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001185// arm FreeBSD target
1186class FreeBSDARMTargetInfo : public ARMTargetInfo {
1187public:
1188 FreeBSDARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {}
1189 virtual void getTargetDefines(const LangOptions &Opts,
1190 std::vector<char> &Defines) const {
1191 ARMTargetInfo::getTargetDefines(Opts, Defines);
1192 getFreeBSDDefines(Opts, 0, getTargetTriple(), Defines);
1193 }
1194};
1195} // end anonymous namespace
1196
1197namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001198class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001199 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1200 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001201public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001202 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1203 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001204 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1205 "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001206 }
Chris Lattner79682402009-03-20 15:52:06 +00001207 virtual void getTargetDefines(const LangOptions &Opts,
1208 std::vector<char> &Defines) const {
Eli Friedmana456b7f2009-05-22 01:12:57 +00001209 DefineStd(Defines, "sparc", Opts);
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001210 Define(Defines, "__sparcv8");
Eli Friedmana456b7f2009-05-22 01:12:57 +00001211 Define(Defines, "__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001212 }
1213 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1214 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001215 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001216 }
1217 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001218 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001219 }
1220 virtual const char *getTargetPrefix() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001221 return "sparc";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001222 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001223 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001224 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001225 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001226 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001227 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001228 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001229 // FIXME: Implement!
1230 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001231 }
1232 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001233 // FIXME: Implement!
1234 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001235 }
1236};
1237
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001238const char * const SparcV8TargetInfo::GCCRegNames[] = {
1239 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1240 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1241 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1242 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1243};
1244
Anton Korobeynikove7772382009-05-03 13:42:53 +00001245void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001246 unsigned &NumNames) const {
1247 Names = GCCRegNames;
1248 NumNames = llvm::array_lengthof(GCCRegNames);
1249}
1250
1251const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00001252 { { "g0" }, "r0" },
1253 { { "g1" }, "r1" },
1254 { { "g2" }, "r2" },
1255 { { "g3" }, "r3" },
1256 { { "g4" }, "r4" },
1257 { { "g5" }, "r5" },
1258 { { "g6" }, "r6" },
1259 { { "g7" }, "r7" },
1260 { { "o0" }, "r8" },
1261 { { "o1" }, "r9" },
1262 { { "o2" }, "r10" },
1263 { { "o3" }, "r11" },
1264 { { "o4" }, "r12" },
1265 { { "o5" }, "r13" },
1266 { { "o6", "sp" }, "r14" },
1267 { { "o7" }, "r15" },
1268 { { "l0" }, "r16" },
1269 { { "l1" }, "r17" },
1270 { { "l2" }, "r18" },
1271 { { "l3" }, "r19" },
1272 { { "l4" }, "r20" },
1273 { { "l5" }, "r21" },
1274 { { "l6" }, "r22" },
1275 { { "l7" }, "r23" },
1276 { { "i0" }, "r24" },
1277 { { "i1" }, "r25" },
1278 { { "i2" }, "r26" },
1279 { { "i3" }, "r27" },
1280 { { "i4" }, "r28" },
1281 { { "i5" }, "r29" },
1282 { { "i6", "fp" }, "r30" },
1283 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001284};
1285
Anton Korobeynikove7772382009-05-03 13:42:53 +00001286void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001287 unsigned &NumAliases) const {
1288 Aliases = GCCRegAliases;
1289 NumAliases = llvm::array_lengthof(GCCRegAliases);
1290}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001291} // end anonymous namespace.
1292
Eli Friedmanff158dd2008-08-20 07:28:14 +00001293namespace {
1294class SolarisSparcV8TargetInfo : public SparcV8TargetInfo {
1295public:
1296 SolarisSparcV8TargetInfo(const std::string& triple) :
Eli Friedman7cca0982008-11-02 02:43:55 +00001297 SparcV8TargetInfo(triple) {
1298 SizeType = UnsignedInt;
1299 PtrDiffType = SignedInt;
Eli Friedmana456b7f2009-05-22 01:12:57 +00001300 WCharType = SignedLong;
1301 // FIXME: WIntType should be SignedLong
1302 UserLabelPrefix = "";
Eli Friedman7cca0982008-11-02 02:43:55 +00001303 }
Eli Friedmanff158dd2008-08-20 07:28:14 +00001304
Chris Lattner79682402009-03-20 15:52:06 +00001305 virtual void getTargetDefines(const LangOptions &Opts,
1306 std::vector<char> &Defines) const {
1307 SparcV8TargetInfo::getTargetDefines(Opts, Defines);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001308 getSolarisDefines(Opts, Defines);
Eli Friedmanff158dd2008-08-20 07:28:14 +00001309 }
1310};
1311} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00001312
Chris Lattner85970f32008-05-08 05:58:21 +00001313namespace {
1314 class PIC16TargetInfo : public TargetInfo{
1315 public:
1316 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001317 TLSSupported = false;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001318 IntWidth = 16;
1319 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001320 IntMaxTWidth = 32;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001321 PointerWidth = 16;
1322 IntAlign = 8;
1323 LongAlign = LongLongAlign = 8;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001324 PointerAlign = 8;
Sanjiv Guptafa451432008-10-31 09:52:39 +00001325 SizeType = UnsignedInt;
1326 IntMaxType = SignedLong;
1327 UIntMaxType = UnsignedLong;
Chris Lattnerd9ef7242009-02-13 22:28:55 +00001328 IntPtrType = SignedShort;
Eli Friedman7cca0982008-11-02 02:43:55 +00001329 PtrDiffType = SignedInt;
Sanjiv Guptaae8f1e82009-06-02 04:43:46 +00001330 FloatWidth = 32;
1331 FloatAlign = 32;
1332 DoubleWidth = 32;
1333 DoubleAlign = 32;
1334 LongDoubleWidth = 32;
1335 LongDoubleAlign = 32;
1336 FloatFormat = &llvm::APFloat::IEEEsingle;
1337 DoubleFormat = &llvm::APFloat::IEEEsingle;
1338 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1339 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32";
1340
Chris Lattner85970f32008-05-08 05:58:21 +00001341 }
Chris Lattner727b3c42008-05-09 06:08:39 +00001342 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1343 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner79682402009-03-20 15:52:06 +00001344 virtual void getTargetDefines(const LangOptions &Opts,
1345 std::vector<char> &Defines) const {
Chris Lattner85970f32008-05-08 05:58:21 +00001346 Define(Defines, "__pic16");
1347 }
1348 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1349 unsigned &NumRecords) const {}
1350 virtual const char *getVAListDeclaration() const { return "";}
1351 virtual const char *getClobbers() const {return "";}
Sanjiv Gupta88b4e512009-04-21 06:01:16 +00001352 virtual const char *getTargetPrefix() const {return "pic16";}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001353 virtual void getGCCRegNames(const char * const *&Names,
1354 unsigned &NumNames) const {}
1355 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner85970f32008-05-08 05:58:21 +00001356 TargetInfo::ConstraintInfo &info) const {
1357 return true;
1358 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001359 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner85970f32008-05-08 05:58:21 +00001360 unsigned &NumAliases) const {}
1361 virtual bool useGlobalsForAutomaticVariables() const {return true;}
1362 };
1363}
1364
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001365namespace {
1366 class MSP430TargetInfo : public TargetInfo {
1367 static const char * const GCCRegNames[];
1368 public:
1369 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1370 TLSSupported = false;
1371 IntWidth = 16;
1372 LongWidth = LongLongWidth = 32;
Eli Friedman78a2f412009-05-16 23:30:57 +00001373 IntMaxTWidth = 32;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001374 PointerWidth = 16;
1375 IntAlign = 8;
1376 LongAlign = LongLongAlign = 8;
1377 PointerAlign = 8;
1378 SizeType = UnsignedInt;
1379 IntMaxType = SignedLong;
1380 UIntMaxType = UnsignedLong;
1381 IntPtrType = SignedShort;
1382 PtrDiffType = SignedInt;
1383 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
1384 }
1385 virtual void getTargetDefines(const LangOptions &Opts,
1386 std::vector<char> &Defines) const {
1387 Define(Defines, "MSP430");
1388 Define(Defines, "__MSP430__");
1389 // FIXME: defines for different 'flavours' of MCU
1390 }
1391 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1392 unsigned &NumRecords) const {
1393 // FIXME: Implement.
1394 Records = 0;
1395 NumRecords = 0;
1396 }
1397 virtual const char *getTargetPrefix() const {
1398 return "msp430";
1399 }
1400 virtual void getGCCRegNames(const char * const *&Names,
1401 unsigned &NumNames) const;
1402 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1403 unsigned &NumAliases) const {
1404 // No aliases.
1405 Aliases = 0;
1406 NumAliases = 0;
1407 }
1408 virtual bool validateAsmConstraint(const char *&Name,
1409 TargetInfo::ConstraintInfo &info) const {
1410 // FIXME: implement
1411 return true;
1412 }
1413 virtual const char *getClobbers() const {
1414 // FIXME: Is this really right?
1415 return "";
1416 }
1417 virtual const char *getVAListDeclaration() const {
1418 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00001419 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001420 }
1421 };
1422
1423 const char * const MSP430TargetInfo::GCCRegNames[] = {
1424 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1425 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1426 };
1427
1428 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1429 unsigned &NumNames) const {
1430 Names = GCCRegNames;
1431 NumNames = llvm::array_lengthof(GCCRegNames);
1432 }
1433}
1434
1435
Chris Lattner4b009652007-07-25 00:24:17 +00001436//===----------------------------------------------------------------------===//
1437// Driver code
1438//===----------------------------------------------------------------------===//
1439
Ted Kremenekb97d7672007-12-04 17:07:35 +00001440static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +00001441 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
1442 TT[4] == '-' && TT[1] - '3' < 6);
1443}
1444
Chris Lattnerfc457002008-03-05 01:18:20 +00001445/// CreateTargetInfo - Return the target info object for the specified target
1446/// triple.
1447TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Eli Friedman2b161652008-08-21 00:13:15 +00001448 // OS detection; this isn't really anywhere near complete.
1449 // Additions and corrections are welcome.
1450 bool isDarwin = T.find("-darwin") != std::string::npos;
Chris Lattnerd4faca42008-08-23 18:23:14 +00001451 bool isDragonFly = T.find("-dragonfly") != std::string::npos;
Chris Lattner98cb2a22008-10-16 17:04:31 +00001452 bool isFreeBSD = T.find("-freebsd") != std::string::npos;
Eli Friedman2b161652008-08-21 00:13:15 +00001453 bool isSolaris = T.find("-solaris") != std::string::npos;
1454 bool isLinux = T.find("-linux") != std::string::npos;
1455 bool isWindows = T.find("-windows") != std::string::npos ||
1456 T.find("-win32") != std::string::npos ||
1457 T.find("-mingw") != std::string::npos;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001458
Eli Friedman2b161652008-08-21 00:13:15 +00001459 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0) {
1460 if (isDarwin)
1461 return new DarwinPPCTargetInfo(T);
1462 return new PPC32TargetInfo(T);
1463 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001464
Eli Friedman2b161652008-08-21 00:13:15 +00001465 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0) {
1466 if (isDarwin)
1467 return new DarwinPPC64TargetInfo(T);
1468 return new PPC64TargetInfo(T);
1469 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001470
Chris Lattner433d9722009-04-23 04:22:04 +00001471 if (T.find("armv") == 0 || T.find("arm-") == 0 || T.find("xscale") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001472 if (isDarwin)
1473 return new DarwinARMTargetInfo(T);
Daniel Dunbar88fd9942009-03-23 16:09:04 +00001474 if (isFreeBSD)
1475 return new FreeBSDARMTargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001476 return new ARMTargetInfo(T);
1477 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001478
Eli Friedman2b161652008-08-21 00:13:15 +00001479 if (T.find("sparc-") == 0) {
1480 if (isSolaris)
1481 return new SolarisSparcV8TargetInfo(T);
1482 return new SparcV8TargetInfo(T);
1483 }
1484
Chris Lattner273dce42009-02-20 17:04:14 +00001485 if (T.find("x86_64-") == 0 || T.find("amd64-") == 0) {
Eli Friedman2b161652008-08-21 00:13:15 +00001486 if (isDarwin)
1487 return new DarwinX86_64TargetInfo(T);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001488 if (isLinux)
1489 return new LinuxX86_64TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001490 if (isFreeBSD)
1491 return new FreeBSDX86_64TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001492 if (isSolaris)
1493 return new SolarisX86_64TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001494 return new X86_64TargetInfo(T);
1495 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001496
Chris Lattner85970f32008-05-08 05:58:21 +00001497 if (T.find("pic16-") == 0)
1498 return new PIC16TargetInfo(T);
1499
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00001500 if (T.find("msp430-") == 0)
1501 return new MSP430TargetInfo(T);
1502
Eli Friedman2b161652008-08-21 00:13:15 +00001503 if (IsX86(T)) {
1504 if (isDarwin)
1505 return new DarwinI386TargetInfo(T);
Eli Friedman5fb0a022008-08-21 00:24:02 +00001506 if (isLinux)
1507 return new LinuxX86_32TargetInfo(T);
Chris Lattnerd4faca42008-08-23 18:23:14 +00001508 if (isDragonFly)
1509 return new DragonFlyX86_32TargetInfo(T);
Chris Lattner98cb2a22008-10-16 17:04:31 +00001510 if (isFreeBSD)
1511 return new FreeBSDX86_32TargetInfo(T);
Douglas Gregor5415abd2009-05-21 23:51:30 +00001512 if (isSolaris)
1513 return new SolarisX86_32TargetInfo(T);
Eli Friedman23cb7912008-08-21 01:40:19 +00001514 if (isWindows)
1515 return new WindowsX86_32TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001516 return new X86_32TargetInfo(T);
1517 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001518
Chris Lattnerfc457002008-03-05 01:18:20 +00001519 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +00001520}