blob: 2625da2e4da7c0c9deebf080380733feff1eb28f [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//
Ted Kremenek38591a22007-12-12 18:05:32 +000010// This file implements construction of a TargetInfo object from a
11// target triple.
Chris Lattner4b009652007-07-25 00:24:17 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner4b009652007-07-25 00:24:17 +000015#include "clang/AST/Builtins.h"
Anders Carlssone1449c12007-12-09 23:17:02 +000016#include "clang/AST/TargetBuiltins.h"
Chris Lattner4b009652007-07-25 00:24:17 +000017#include "clang/Basic/TargetInfo.h"
Anders Carlsson7dd1c952007-11-24 23:38:12 +000018#include "llvm/ADT/STLExtras.h"
Eli Friedmand4011892008-05-20 14:27:34 +000019#include "llvm/ADT/APFloat.h"
Ted Kremenek40499482007-12-03 22:06:55 +000020
Chris Lattner4b009652007-07-25 00:24:17 +000021using namespace clang;
22
Chris Lattner4b009652007-07-25 00:24:17 +000023//===----------------------------------------------------------------------===//
24// Common code shared among targets.
25//===----------------------------------------------------------------------===//
26
Chris Lattner0db667a2007-10-06 06:57:34 +000027static void Define(std::vector<char> &Buf, const char *Macro,
28 const char *Val = "1") {
29 const char *Def = "#define ";
30 Buf.insert(Buf.end(), Def, Def+strlen(Def));
31 Buf.insert(Buf.end(), Macro, Macro+strlen(Macro));
32 Buf.push_back(' ');
33 Buf.insert(Buf.end(), Val, Val+strlen(Val));
34 Buf.push_back('\n');
35}
36
Eli Friedmanff158dd2008-08-20 07:28:14 +000037static void getSolarisDefines(std::vector<char> &Defs) {
38 Define(Defs, "__SUN__");
39 Define(Defs, "__SOLARIS__");
40}
Chris Lattner4b009652007-07-25 00:24:17 +000041
Eli Friedman872996c2008-08-20 02:34:37 +000042static void getDarwinDefines(std::vector<char> &Defs) {
43 Define(Defs, "__APPLE__");
44 Define(Defs, "__MACH__");
Chris Lattner9b96b152008-09-30 00:48:48 +000045 Define(Defs, "__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", "1050");
Eli Friedman872996c2008-08-20 02:34:37 +000046}
Chris Lattner4b009652007-07-25 00:24:17 +000047
Chris Lattnerd4faca42008-08-23 18:23:14 +000048static void getDragonFlyDefines(std::vector<char> &Defs) {
49 // DragonFly defines; list based off of gcc output
50 Define(Defs, "__DragonFly__");
51 Define(Defs, "__DragonFly_cc_version", "100001");
52 Define(Defs, "__ELF__");
53 Define(Defs, "__KPRINTF_ATTRIBUTE__");
54 Define(Defs, "__tune_i386__");
55 Define(Defs, "unix");
56 Define(Defs, "__unix");
57 Define(Defs, "__unix__");
58}
59
Eli Friedman5fb0a022008-08-21 00:24:02 +000060static void getLinuxDefines(std::vector<char> &Defs) {
61 // Linux defines; list based off of gcc output
62 Define(Defs, "__unix__");
63 Define(Defs, "__unix");
64 Define(Defs, "unix");
65 Define(Defs, "__linux__");
66 Define(Defs, "__linux");
67 Define(Defs, "linux");
68 Define(Defs, "__gnu_linux__");
69}
70
Chris Lattner4b009652007-07-25 00:24:17 +000071/// getPowerPCDefines - Return a set of the PowerPC-specific #defines that are
72/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +000073static void getPowerPCDefines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +000074 // Target identification.
Chris Lattner0db667a2007-10-06 06:57:34 +000075 Define(Defs, "__ppc__");
76 Define(Defs, "_ARCH_PPC");
77 Define(Defs, "__POWERPC__");
Chris Lattner4b009652007-07-25 00:24:17 +000078 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +000079 Define(Defs, "_ARCH_PPC64");
80 Define(Defs, "_LP64");
81 Define(Defs, "__LP64__");
82 Define(Defs, "__ppc64__");
Chris Lattner4b009652007-07-25 00:24:17 +000083 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +000084 Define(Defs, "__ppc__");
Chris Lattner4b009652007-07-25 00:24:17 +000085 }
86
87 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +000088 Define(Defs, "_BIG_ENDIAN");
89 Define(Defs, "__BIG_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +000090
91 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +000092 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
93 Define(Defs, "__INTMAX_TYPE__", "long int");
94 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
95 Define(Defs, "__PTRDIFF_TYPE__", "long int");
96 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +000097 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +000098 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
99 Define(Defs, "__INTMAX_TYPE__", "long long int");
100 Define(Defs, "__LONG_MAX__", "2147483647L");
101 Define(Defs, "__PTRDIFF_TYPE__", "int");
102 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000103 }
Chris Lattner0db667a2007-10-06 06:57:34 +0000104 Define(Defs, "__INT_MAX__", "2147483647");
105 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
106 Define(Defs, "__CHAR_BIT__", "8");
107 Define(Defs, "__SCHAR_MAX__", "127");
108 Define(Defs, "__SHRT_MAX__", "32767");
109 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000110
111 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000112 Define(Defs, "__USER_LABEL_PREFIX__", "_");
113 Define(Defs, "__NATURAL_ALIGNMENT__");
114 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000115
Chris Lattner0db667a2007-10-06 06:57:34 +0000116 Define(Defs, "__WCHAR_MAX__", "2147483647");
117 Define(Defs, "__WCHAR_TYPE__", "int");
118 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000119
120 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000121 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
122 Define(Defs, "__FLT_DIG__", "6");
123 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
124 Define(Defs, "__FLT_EVAL_METHOD__", "0");
125 Define(Defs, "__FLT_HAS_INFINITY__");
126 Define(Defs, "__FLT_HAS_QUIET_NAN__");
127 Define(Defs, "__FLT_MANT_DIG__", "24");
128 Define(Defs, "__FLT_MAX_10_EXP__", "38");
129 Define(Defs, "__FLT_MAX_EXP__", "128");
130 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
131 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
132 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
133 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
134 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000135
136 // double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000137 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
138 Define(Defs, "__DBL_DIG__", "15");
139 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
140 Define(Defs, "__DBL_HAS_INFINITY__");
141 Define(Defs, "__DBL_HAS_QUIET_NAN__");
142 Define(Defs, "__DBL_MANT_DIG__", "53");
143 Define(Defs, "__DBL_MAX_10_EXP__", "308");
144 Define(Defs, "__DBL_MAX_EXP__", "1024");
145 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
146 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
147 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
148 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
149 Define(Defs, "__DECIMAL_DIG__", "33");
Chris Lattner4b009652007-07-25 00:24:17 +0000150
151 // 128-bit long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000152 Define(Defs, "__LDBL_DENORM_MIN__",
153 "4.94065645841246544176568792868221e-324L");
154 Define(Defs, "__LDBL_DIG__", "31");
155 Define(Defs, "__LDBL_EPSILON__",
156 "4.94065645841246544176568792868221e-324L");
157 Define(Defs, "__LDBL_HAS_INFINITY__");
158 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
159 Define(Defs, "__LDBL_MANT_DIG__", "106");
160 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
161 Define(Defs, "__LDBL_MAX_EXP__", "1024");
162 Define(Defs, "__LDBL_MAX__",
163 "1.79769313486231580793728971405301e+308L");
164 Define(Defs, "__LDBL_MIN_10_EXP__", "(-291)");
165 Define(Defs, "__LDBL_MIN_EXP__", "(-968)");
166 Define(Defs, "__LDBL_MIN__",
167 "2.00416836000897277799610805135016e-292L");
168 Define(Defs, "__LONG_DOUBLE_128__");
Chris Lattner4b009652007-07-25 00:24:17 +0000169}
170
171/// getX86Defines - Return a set of the X86-specific #defines that are
172/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +0000173static void getX86Defines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +0000174 // Target identification.
175 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000176 Define(Defs, "_LP64");
177 Define(Defs, "__LP64__");
178 Define(Defs, "__amd64__");
179 Define(Defs, "__amd64");
180 Define(Defs, "__x86_64");
181 Define(Defs, "__x86_64__");
Chris Lattner4b009652007-07-25 00:24:17 +0000182 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000183 Define(Defs, "__i386__");
184 Define(Defs, "__i386");
185 Define(Defs, "i386");
Chris Lattner4b009652007-07-25 00:24:17 +0000186 }
187
188 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +0000189 Define(Defs, "__LITTLE_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +0000190
191 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000192 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
193 Define(Defs, "__INTMAX_TYPE__", "long int");
194 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
195 Define(Defs, "__PTRDIFF_TYPE__", "long int");
196 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000197 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000198 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
199 Define(Defs, "__INTMAX_TYPE__", "long long int");
200 Define(Defs, "__LONG_MAX__", "2147483647L");
201 Define(Defs, "__PTRDIFF_TYPE__", "int");
202 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000203 }
Anders Carlsson82b26282008-07-22 17:16:13 +0000204 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner0db667a2007-10-06 06:57:34 +0000205 Define(Defs, "__CHAR_BIT__", "8");
206 Define(Defs, "__INT_MAX__", "2147483647");
207 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
208 Define(Defs, "__SCHAR_MAX__", "127");
209 Define(Defs, "__SHRT_MAX__", "32767");
Chris Lattner4b009652007-07-25 00:24:17 +0000210
211 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000212 Define(Defs, "__nocona");
213 Define(Defs, "__nocona__");
214 Define(Defs, "__tune_nocona__");
215 Define(Defs, "__SSE2_MATH__");
216 Define(Defs, "__SSE2__");
217 Define(Defs, "__SSE_MATH__");
218 Define(Defs, "__SSE__");
219 Define(Defs, "__MMX__");
220 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000221
Chris Lattner0db667a2007-10-06 06:57:34 +0000222 Define(Defs, "__WCHAR_MAX__", "2147483647");
223 Define(Defs, "__WCHAR_TYPE__", "int");
224 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000225
226 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000227 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
228 Define(Defs, "__FLT_DIG__", "6");
229 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
230 Define(Defs, "__FLT_EVAL_METHOD__", "0");
231 Define(Defs, "__FLT_HAS_INFINITY__");
232 Define(Defs, "__FLT_HAS_QUIET_NAN__");
233 Define(Defs, "__FLT_MANT_DIG__", "24");
234 Define(Defs, "__FLT_MAX_10_EXP__", "38");
235 Define(Defs, "__FLT_MAX_EXP__", "128");
236 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
237 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
238 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
239 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
240 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000241
242 // Double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000243 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
244 Define(Defs, "__DBL_DIG__", "15");
245 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
246 Define(Defs, "__DBL_HAS_INFINITY__");
247 Define(Defs, "__DBL_HAS_QUIET_NAN__");
248 Define(Defs, "__DBL_MANT_DIG__", "53");
249 Define(Defs, "__DBL_MAX_10_EXP__", "308");
250 Define(Defs, "__DBL_MAX_EXP__", "1024");
251 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
252 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
253 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
254 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
255 Define(Defs, "__DECIMAL_DIG__", "21");
Chris Lattner4b009652007-07-25 00:24:17 +0000256
257 // 80-bit Long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000258 Define(Defs, "__LDBL_DENORM_MIN__", "3.64519953188247460253e-4951L");
259 Define(Defs, "__LDBL_DIG__", "18");
260 Define(Defs, "__LDBL_EPSILON__", "1.08420217248550443401e-19L");
261 Define(Defs, "__LDBL_HAS_INFINITY__");
262 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
263 Define(Defs, "__LDBL_MANT_DIG__", "64");
264 Define(Defs, "__LDBL_MAX_10_EXP__", "4932");
265 Define(Defs, "__LDBL_MAX_EXP__", "16384");
266 Define(Defs, "__LDBL_MAX__", "1.18973149535723176502e+4932L");
267 Define(Defs, "__LDBL_MIN_10_EXP__", "(-4931)");
268 Define(Defs, "__LDBL_MIN_EXP__", "(-16381)");
269 Define(Defs, "__LDBL_MIN__", "3.36210314311209350626e-4932L");
Chris Lattner4b009652007-07-25 00:24:17 +0000270}
271
Chris Lattnerb6444052008-04-21 20:19:54 +0000272/// getARMDefines - Return a set of the ARM-specific #defines that are
Chris Lattner9fd73612008-04-21 18:56:49 +0000273/// not tied to a specific subtarget.
274static void getARMDefines(std::vector<char> &Defs) {
275 // Target identification.
276 Define(Defs, "__arm");
277 Define(Defs, "__arm__");
278
279 // Target properties.
280 Define(Defs, "__LITTLE_ENDIAN__");
281
282 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
283 Define(Defs, "__INTMAX_TYPE__", "long long int");
284 Define(Defs, "__LONG_MAX__", "2147483647L");
285 Define(Defs, "__PTRDIFF_TYPE__", "int");
286 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
287 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
288
289 Define(Defs, "__CHAR_BIT__", "8");
290 Define(Defs, "__INT_MAX__", "2147483647");
291 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
292 Define(Defs, "__SCHAR_MAX__", "127");
293 Define(Defs, "__SHRT_MAX__", "32767");
294
295 // Subtarget options. [hard coded to v6 for now]
296 Define(Defs, "__ARM_ARCH_6K__");
297 Define(Defs, "__ARMEL__");
298 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", "20000");
299
300 Define(Defs, "__WCHAR_MAX__", "2147483647");
301 Define(Defs, "__WCHAR_TYPE__", "int");
302 Define(Defs, "__WINT_TYPE__", "int");
303 Define(Defs, "__DECIMAL_DIG__", "17");
304 Define(Defs, "__FLT_RADIX__", "2");
305
306 // Float macros.
307 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
308 Define(Defs, "__FLT_DIG__", "6");
309 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
310 Define(Defs, "__FLT_EVAL_METHOD__", "0");
311 Define(Defs, "__FLT_HAS_INFINITY__");
312 Define(Defs, "__FLT_HAS_QUIET_NAN__");
313 Define(Defs, "__FLT_MANT_DIG__", "24");
314 Define(Defs, "__FLT_MAX_10_EXP__", "38");
315 Define(Defs, "__FLT_MAX_EXP__", "128");
316 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
317 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
318 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
319 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
320
321 // Double macros.
322 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
323 Define(Defs, "__DBL_DIG__", "15");
324 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
325 Define(Defs, "__DBL_HAS_INFINITY__");
326 Define(Defs, "__DBL_HAS_QUIET_NAN__");
327 Define(Defs, "__DBL_MANT_DIG__", "53");
328 Define(Defs, "__DBL_MAX_10_EXP__", "308");
329 Define(Defs, "__DBL_MAX_EXP__", "1024");
330 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
331 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
332 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
333 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
334
335 // 64-bit Long double macros (same as double).
336 Define(Defs, "__LDBL_DENORM_MIN__", "4.9406564584124654e-324");
337 Define(Defs, "__LDBL_DIG__", "15");
338 Define(Defs, "__LDBL_EPSILON__", "2.2204460492503131e-16");
339 Define(Defs, "__LDBL_HAS_INFINITY__");
340 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
341 Define(Defs, "__LDBL_MANT_DIG__", "53");
342 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
343 Define(Defs, "__LDBL_MAX_EXP__", "1024");
344 Define(Defs, "__LDBL_MAX__", "1.7976931348623157e+308");
345 Define(Defs, "__LDBL_MIN_10_EXP__", "(-307)");
346 Define(Defs, "__LDBL_MIN_EXP__", "(-1021)");
347 Define(Defs, "__LDBL_MIN__", "2.2250738585072014e-308");
348}
349
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000350//===----------------------------------------------------------------------===//
351// Specific target implementations.
352//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000353
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000354namespace {
355// PPC abstract base class
356class PPCTargetInfo : public TargetInfo {
357 static const Builtin::Info BuiltinInfo[];
358 static const char * const GCCRegNames[];
359 static const TargetInfo::GCCRegAlias GCCRegAliases[];
360
361public:
362 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
363 CharIsSigned = false;
364 }
365 virtual void getTargetBuiltins(const Builtin::Info *&Records,
366 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000367 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000368 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000369 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000370 virtual const char *getVAListDeclaration() const {
371 return "typedef struct __va_list_tag {"
372 " unsigned char gpr;"
373 " unsigned char fpr;"
374 " unsigned short reserved;"
375 " void* overflow_arg_area;"
376 " void* reg_save_area;"
377 "} __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000378 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000379 virtual const char *getTargetPrefix() const {
380 return "ppc";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000381 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000382 virtual void getGCCRegNames(const char * const *&Names,
383 unsigned &NumNames) const;
384 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
385 unsigned &NumAliases) const;
386 virtual bool validateAsmConstraint(char c,
387 TargetInfo::ConstraintInfo &info) const {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000388 switch (c) {
389 default: return false;
390 case 'O': // Zero
391 return true;
392 case 'b': // Base register
393 case 'f': // Floating point register
394 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
395 return true;
396 }
397 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000398 virtual const char *getClobbers() const {
399 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000400 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000401};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000402
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000403const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
404#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
405#include "clang/AST/PPCBuiltins.def"
406};
Chris Lattner9fd73612008-04-21 18:56:49 +0000407
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000408const char * const PPCTargetInfo::GCCRegNames[] = {
409 "0", "1", "2", "3", "4", "5", "6", "7",
410 "8", "9", "10", "11", "12", "13", "14", "15",
411 "16", "17", "18", "19", "20", "21", "22", "23",
412 "24", "25", "26", "27", "28", "29", "30", "31",
413 "0", "1", "2", "3", "4", "5", "6", "7",
414 "8", "9", "10", "11", "12", "13", "14", "15",
415 "16", "17", "18", "19", "20", "21", "22", "23",
416 "24", "25", "26", "27", "28", "29", "30", "31",
417 "mq", "lr", "ctr", "ap",
418 "0", "1", "2", "3", "4", "5", "6", "7",
419 "xer",
420 "0", "1", "2", "3", "4", "5", "6", "7",
421 "8", "9", "10", "11", "12", "13", "14", "15",
422 "16", "17", "18", "19", "20", "21", "22", "23",
423 "24", "25", "26", "27", "28", "29", "30", "31",
424 "vrsave", "vscr",
425 "spe_acc", "spefscr",
426 "sfp"
427};
Chris Lattner4b009652007-07-25 00:24:17 +0000428
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000429void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
430 unsigned &NumNames) const {
431 Names = GCCRegNames;
432 NumNames = llvm::array_lengthof(GCCRegNames);
433}
Chris Lattner4b009652007-07-25 00:24:17 +0000434
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000435const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
436 // While some of these aliases do map to different registers
437 // they still share the same register name.
438 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
439 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
440 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
441 { { "cr3", "fr3", "r3", "v3"}, "3" },
442 { { "cr4", "fr4", "r4", "v4"}, "4" },
443 { { "cr5", "fr5", "r5", "v5"}, "5" },
444 { { "cr6", "fr6", "r6", "v6"}, "6" },
445 { { "cr7", "fr7", "r7", "v7"}, "7" },
446 { { "fr8", "r8", "v8"}, "8" },
447 { { "fr9", "r9", "v9"}, "9" },
448 { { "fr10", "r10", "v10"}, "10" },
449 { { "fr11", "r11", "v11"}, "11" },
450 { { "fr12", "r12", "v12"}, "12" },
451 { { "fr13", "r13", "v13"}, "13" },
452 { { "fr14", "r14", "v14"}, "14" },
453 { { "fr15", "r15", "v15"}, "15" },
454 { { "fr16", "r16", "v16"}, "16" },
455 { { "fr17", "r17", "v17"}, "17" },
456 { { "fr18", "r18", "v18"}, "18" },
457 { { "fr19", "r19", "v19"}, "19" },
458 { { "fr20", "r20", "v20"}, "20" },
459 { { "fr21", "r21", "v21"}, "21" },
460 { { "fr22", "r22", "v22"}, "22" },
461 { { "fr23", "r23", "v23"}, "23" },
462 { { "fr24", "r24", "v24"}, "24" },
463 { { "fr25", "r25", "v25"}, "25" },
464 { { "fr26", "r26", "v26"}, "26" },
465 { { "fr27", "r27", "v27"}, "27" },
466 { { "fr28", "r28", "v28"}, "28" },
467 { { "fr29", "r29", "v29"}, "29" },
468 { { "fr30", "r30", "v30"}, "30" },
469 { { "fr31", "r31", "v31"}, "31" },
470};
471
472void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
473 unsigned &NumAliases) const {
474 Aliases = GCCRegAliases;
475 NumAliases = llvm::array_lengthof(GCCRegAliases);
476}
477} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000478
479namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000480class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000481public:
Eli Friedman2b161652008-08-21 00:13:15 +0000482 PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
483 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
484 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
485 }
Chris Lattner0db667a2007-10-06 06:57:34 +0000486 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000487 getPowerPCDefines(Defines, false);
488 }
Chris Lattner4b009652007-07-25 00:24:17 +0000489};
490} // end anonymous namespace.
491
492namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000493class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000494public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000495 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000496 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2b161652008-08-21 00:13:15 +0000497 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
498 "i64:64:64-f32:32:32-f64:64:64-v128:128:128";
Chris Lattnere5fde952008-05-09 06:17:04 +0000499 }
Chris Lattner0db667a2007-10-06 06:57:34 +0000500 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000501 getPowerPCDefines(Defines, true);
502 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000503};
504} // end anonymous namespace.
505
506namespace {
507class DarwinPPCTargetInfo : public PPC32TargetInfo {
508public:
509 DarwinPPCTargetInfo(const std::string& triple) : PPC32TargetInfo(triple) {}
510 virtual void getTargetDefines(std::vector<char> &Defines) const {
511 PPC32TargetInfo::getTargetDefines(Defines);
512 getDarwinDefines(Defines);
Chris Lattner4b009652007-07-25 00:24:17 +0000513 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000514
515 virtual bool useNeXTRuntimeAsDefault() const { return true; }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000516};
517} // end anonymous namespace.
518
519namespace {
520class DarwinPPC64TargetInfo : public PPC64TargetInfo {
521public:
522 DarwinPPC64TargetInfo(const std::string& triple) : PPC64TargetInfo(triple) {}
523 virtual void getTargetDefines(std::vector<char> &Defines) const {
524 PPC64TargetInfo::getTargetDefines(Defines);
525 getDarwinDefines(Defines);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000526 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000527
528 virtual bool useNeXTRuntimeAsDefault() const { return true; }
Chris Lattner4b009652007-07-25 00:24:17 +0000529};
530} // end anonymous namespace.
531
532namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000533// Namespace for x86 abstract base class
534const Builtin::Info BuiltinInfo[] = {
535#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
536#include "clang/AST/X86Builtins.def"
537};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000538
Eli Friedman872996c2008-08-20 02:34:37 +0000539const char *GCCRegNames[] = {
540 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
541 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
542 "argp", "flags", "fspr", "dirflag", "frame",
543 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
544 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
545 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
546 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
547};
548
549const TargetInfo::GCCRegAlias GCCRegAliases[] = {
550 { { "al", "ah", "eax", "rax" }, "ax" },
551 { { "bl", "bh", "ebx", "rbx" }, "bx" },
552 { { "cl", "ch", "ecx", "rcx" }, "cx" },
553 { { "dl", "dh", "edx", "rdx" }, "dx" },
554 { { "esi", "rsi" }, "si" },
555 { { "edi", "rdi" }, "di" },
556 { { "esp", "rsp" }, "sp" },
557 { { "ebp", "rbp" }, "bp" },
558};
559
560// X86 target abstract base class; x86-32 and x86-64 are very close, so
561// most of the implementation can be shared.
562class X86TargetInfo : public TargetInfo {
563public:
564 X86TargetInfo(const std::string& triple) : TargetInfo(triple) {
565 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000566 }
567 virtual void getTargetBuiltins(const Builtin::Info *&Records,
568 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000569 Records = BuiltinInfo;
570 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000571 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000572 virtual const char *getTargetPrefix() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000573 return "x86";
Anders Carlsson333052c2007-12-08 19:32:57 +0000574 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000575 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000576 unsigned &NumNames) const {
577 Names = GCCRegNames;
578 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000579 }
580 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
581 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000582 Aliases = GCCRegAliases;
583 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000584 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000585 virtual bool validateAsmConstraint(char c,
Eli Friedman872996c2008-08-20 02:34:37 +0000586 TargetInfo::ConstraintInfo &info) const;
587 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000588 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000589 return "~{dirflag},~{fpsr},~{flags}";
590 }
Chris Lattner4b009652007-07-25 00:24:17 +0000591};
Eli Friedman872996c2008-08-20 02:34:37 +0000592
593bool
594X86TargetInfo::validateAsmConstraint(char c,
595 TargetInfo::ConstraintInfo &info) const {
596 switch (c) {
597 default: return false;
598 case 'a': // eax.
599 case 'b': // ebx.
600 case 'c': // ecx.
601 case 'd': // edx.
602 case 'S': // esi.
603 case 'D': // edi.
604 case 'A': // edx:eax.
605 case 't': // top of floating point stack.
606 case 'u': // second from top of floating point stack.
607 case 'q': // Any register accessible as [r]l: a, b, c, and d.
608 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
609 case 'Z': // 32-bit integer constant for use with zero-extending x86_64
610 // instructions.
611 case 'N': // unsigned 8-bit integer constant for use with in and out
612 // instructions.
613 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
614 return true;
615 }
616}
617
618std::string
619X86TargetInfo::convertConstraint(const char Constraint) const {
620 switch (Constraint) {
621 case 'a': return std::string("{ax}");
622 case 'b': return std::string("{bx}");
623 case 'c': return std::string("{cx}");
624 case 'd': return std::string("{dx}");
625 case 'S': return std::string("{si}");
626 case 'D': return std::string("{di}");
627 case 't': // top of floating point stack.
628 return std::string("{st}");
629 case 'u': // second from top of floating point stack.
630 return std::string("{st(1)}"); // second from top of floating point stack.
631 default:
632 return std::string(1, Constraint);
633 }
634}
Eli Friedman872996c2008-08-20 02:34:37 +0000635} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000636
637namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000638// X86-32 generic target
639class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000640public:
Eli Friedman872996c2008-08-20 02:34:37 +0000641 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
642 DoubleAlign = LongLongAlign = 32;
643 LongDoubleWidth = 96;
644 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +0000645 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
646 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
647 "a0:0:64-f80:32:32";
Eli Friedman872996c2008-08-20 02:34:37 +0000648 }
649 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000650 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +0000651 }
652 virtual void getTargetDefines(std::vector<char> &Defines) const {
653 getX86Defines(Defines, false);
654 }
655};
656} // end anonymous namespace
657
658namespace {
659// x86-32 Darwin (OS X) target
660class DarwinI386TargetInfo : public X86_32TargetInfo {
661public:
662 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
663 LongDoubleWidth = 128;
664 LongDoubleAlign = 128;
Eli Friedman2b161652008-08-21 00:13:15 +0000665 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
666 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
667 "a0:0:64-f80:128:128";
Eli Friedman872996c2008-08-20 02:34:37 +0000668 }
669 virtual void getTargetDefines(std::vector<char> &Defines) const {
670 X86_32TargetInfo::getTargetDefines(Defines);
671 getDarwinDefines(Defines);
672 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000673 virtual bool useNeXTRuntimeAsDefault() const { return true; }
Eli Friedman872996c2008-08-20 02:34:37 +0000674};
675} // end anonymous namespace
676
677namespace {
Chris Lattnerd4faca42008-08-23 18:23:14 +0000678// x86-32 DragonFly target
679class DragonFlyX86_32TargetInfo : public X86_32TargetInfo {
680public:
681 DragonFlyX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
682 }
683 virtual void getTargetDefines(std::vector<char> &Defines) const {
684 X86_32TargetInfo::getTargetDefines(Defines);
685 getDragonFlyDefines(Defines);
686 }
687};
688} // end anonymous namespace
689
690namespace {
Eli Friedman5fb0a022008-08-21 00:24:02 +0000691// x86-32 Linux target
692class LinuxX86_32TargetInfo : public X86_32TargetInfo {
693public:
694 LinuxX86_32TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
695 }
696 virtual void getTargetDefines(std::vector<char> &Defines) const {
697 X86_32TargetInfo::getTargetDefines(Defines);
698 getLinuxDefines(Defines);
Eli Friedman762fecf2008-09-06 01:37:51 +0000699 Define(Defines, "__USER_LABEL_PREFIX__", "");
Eli Friedman5fb0a022008-08-21 00:24:02 +0000700 }
701};
702} // end anonymous namespace
703
704namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +0000705// x86-32 Windows target
706class WindowsX86_32TargetInfo : public X86_32TargetInfo {
707public:
708 WindowsX86_32TargetInfo(const std::string& triple)
709 : X86_32TargetInfo(triple) {
710 // FIXME: Fix wchar_t.
711 // FIXME: We should probably enable -fms-extensions by default for
712 // this target.
713 }
714 virtual void getTargetDefines(std::vector<char> &Defines) const {
715 X86_32TargetInfo::getTargetDefines(Defines);
716 // This list is based off of the the list of things MingW defines
717 Define(Defines, "__WIN32__");
718 Define(Defines, "__WIN32");
719 Define(Defines, "_WIN32");
720 Define(Defines, "WIN32");
721 Define(Defines, "__WINNT__");
722 Define(Defines, "__WINNT");
723 Define(Defines, "WINNT");
Eli Friedman23cb7912008-08-21 01:40:19 +0000724 Define(Defines, "_X86_");
725 Define(Defines, "__MSVCRT__");
Eli Friedman762fecf2008-09-06 01:37:51 +0000726 Define(Defines, "__USER_LABEL_PREFIX__", "_");
Eli Friedman23cb7912008-08-21 01:40:19 +0000727 }
728};
729} // end anonymous namespace
730
731namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000732// x86-64 generic target
733class X86_64TargetInfo : public X86TargetInfo {
734public:
735 X86_64TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000736 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000737 LongDoubleWidth = 128;
738 LongDoubleAlign = 128;
Eli Friedman2b161652008-08-21 00:13:15 +0000739 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
740 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
741 "a0:0:64-f80:128:128";
Chris Lattner4b009652007-07-25 00:24:17 +0000742 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000743 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000744 return "typedef struct __va_list_tag {"
745 " unsigned gp_offset;"
746 " unsigned fp_offset;"
747 " void* overflow_arg_area;"
748 " void* reg_save_area;"
749 "} __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000750 }
Eli Friedman872996c2008-08-20 02:34:37 +0000751 virtual void getTargetDefines(std::vector<char> &Defines) const {
752 getX86Defines(Defines, true);
Anders Carlsson333052c2007-12-08 19:32:57 +0000753 }
Eli Friedman872996c2008-08-20 02:34:37 +0000754};
755} // end anonymous namespace
756
757namespace {
Daniel Dunbare5a80f22008-09-23 17:37:57 +0000758// x86-64 Linux target
759class LinuxX86_64TargetInfo : public X86_64TargetInfo {
760public:
761 LinuxX86_64TargetInfo(const std::string& triple) : X86_64TargetInfo(triple) {
762 }
763 virtual void getTargetDefines(std::vector<char> &Defines) const {
764 X86_64TargetInfo::getTargetDefines(Defines);
765 getLinuxDefines(Defines);
766 Define(Defines, "__USER_LABEL_PREFIX__", "");
767 }
768};
769} // end anonymous namespace
770
771namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000772// x86-64 Darwin (OS X) target
773class DarwinX86_64TargetInfo : public X86_64TargetInfo {
774public:
775 DarwinX86_64TargetInfo(const std::string& triple) :
776 X86_64TargetInfo(triple) {}
777
778 virtual void getTargetDefines(std::vector<char> &Defines) const {
779 X86_64TargetInfo::getTargetDefines(Defines);
780 getDarwinDefines(Defines);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000781 }
Daniel Dunbar34542952008-08-23 08:43:39 +0000782
783 virtual bool useNeXTRuntimeAsDefault() const { return true; }
Chris Lattner4b009652007-07-25 00:24:17 +0000784};
785} // end anonymous namespace.
786
Chris Lattner9fd73612008-04-21 18:56:49 +0000787namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000788class ARMTargetInfo : public TargetInfo {
Chris Lattner9fd73612008-04-21 18:56:49 +0000789public:
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000790 ARMTargetInfo(const std::string& triple) : TargetInfo(triple) {
791 // FIXME: Are the defaults correct for ARM?
Eli Friedman2b161652008-08-21 00:13:15 +0000792 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
793 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:64:64";
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000794 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000795 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner9fd73612008-04-21 18:56:49 +0000796 getARMDefines(Defines);
797 }
798 virtual void getTargetBuiltins(const Builtin::Info *&Records,
799 unsigned &NumRecords) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000800 // FIXME: Implement.
801 Records = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +0000802 NumRecords = 0;
803 }
804 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000805 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +0000806 }
807 virtual const char *getTargetPrefix() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000808 return "arm";
Chris Lattner9fd73612008-04-21 18:56:49 +0000809 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000810 virtual void getGCCRegNames(const char * const *&Names,
811 unsigned &NumNames) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000812 // FIXME: Implement.
813 Names = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +0000814 NumNames = 0;
815 }
816 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
817 unsigned &NumAliases) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000818 // FIXME: Implement.
819 Aliases = 0;
Chris Lattner9fd73612008-04-21 18:56:49 +0000820 NumAliases = 0;
821 }
822 virtual bool validateAsmConstraint(char c,
Nate Begeman222823a2008-04-22 05:03:19 +0000823 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000824 // FIXME: Check if this is complete
Nate Begeman222823a2008-04-22 05:03:19 +0000825 switch (c) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000826 default:
Nate Begeman222823a2008-04-22 05:03:19 +0000827 case 'l': // r0-r7
828 case 'h': // r8-r15
829 case 'w': // VFP Floating point register single precision
830 case 'P': // VFP Floating point register double precision
831 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
832 return true;
833 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000834 return false;
835 }
836 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000837 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +0000838 return "";
839 }
840};
841} // end anonymous namespace.
842
Eli Friedmanbe727fe2008-08-20 07:44:10 +0000843
844namespace {
845class DarwinARMTargetInfo : public ARMTargetInfo {
846public:
847 DarwinARMTargetInfo(const std::string& triple) : ARMTargetInfo(triple) {}
848
849 virtual void getTargetDefines(std::vector<char> &Defines) const {
850 ARMTargetInfo::getTargetDefines(Defines);
851 getDarwinDefines(Defines);
852 }
853};
854} // end anonymous namespace.
855
Chris Lattner4b009652007-07-25 00:24:17 +0000856namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000857class SparcV8TargetInfo : public TargetInfo {
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000858public:
Eli Friedmanff158dd2008-08-20 07:28:14 +0000859 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
860 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +0000861 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
862 "i64:64:64-f32:32:32-f64:64:64-v64:64:64";
Eli Friedmanff158dd2008-08-20 07:28:14 +0000863 }
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000864 virtual void getTargetDefines(std::vector<char> &Defines) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000865 // FIXME: This is missing a lot of important defines; some of the
866 // missing stuff is likely to break system headers.
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000867 Define(Defines, "__sparc");
Eli Friedman1dee5c52008-05-25 05:26:09 +0000868 Define(Defines, "__sparc__");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000869 Define(Defines, "__sparcv8");
870 }
871 virtual void getTargetBuiltins(const Builtin::Info *&Records,
872 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000873 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000874 }
875 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000876 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000877 }
878 virtual const char *getTargetPrefix() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000879 return "sparc";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000880 }
881 virtual void getGCCRegNames(const char * const *&Names,
882 unsigned &NumNames) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000883 // FIXME: Implement!
884 Names = 0;
885 NumNames = 0;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000886 }
887 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
888 unsigned &NumAliases) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000889 // FIXME: Implement!
890 Aliases = 0;
891 NumAliases = 0;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000892 }
893 virtual bool validateAsmConstraint(char c,
894 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000895 // FIXME: Implement!
896 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000897 }
898 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +0000899 // FIXME: Implement!
900 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000901 }
902};
903
904} // end anonymous namespace.
905
Eli Friedmanff158dd2008-08-20 07:28:14 +0000906namespace {
907class SolarisSparcV8TargetInfo : public SparcV8TargetInfo {
908public:
909 SolarisSparcV8TargetInfo(const std::string& triple) :
910 SparcV8TargetInfo(triple) {}
911
912 virtual void getTargetDefines(std::vector<char> &Defines) const {
913 SparcV8TargetInfo::getTargetDefines(Defines);
914 getSolarisDefines(Defines);
915 }
916};
917} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000918
Chris Lattner85970f32008-05-08 05:58:21 +0000919namespace {
920 class PIC16TargetInfo : public TargetInfo{
921 public:
922 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000923 // FIXME: Is IntAlign really supposed to be 16? There seems
924 // little point on a platform with 8-bit loads.
925 IntWidth = IntAlign = LongAlign = LongLongAlign = PointerWidth = 16;
926 PointerAlign = 8;
Sanjiv Guptaebd8f0f2008-08-18 10:05:22 +0000927 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
Chris Lattner85970f32008-05-08 05:58:21 +0000928 }
Chris Lattner727b3c42008-05-09 06:08:39 +0000929 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
930 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner85970f32008-05-08 05:58:21 +0000931 virtual void getTargetDefines(std::vector<char> &Defines) const {
932 Define(Defines, "__pic16");
933 }
934 virtual void getTargetBuiltins(const Builtin::Info *&Records,
935 unsigned &NumRecords) const {}
936 virtual const char *getVAListDeclaration() const { return "";}
937 virtual const char *getClobbers() const {return "";}
938 virtual const char *getTargetPrefix() const {return "";}
939 virtual void getGCCRegNames(const char * const *&Names,
940 unsigned &NumNames) const {}
941 virtual bool validateAsmConstraint(char c,
942 TargetInfo::ConstraintInfo &info) const {
943 return true;
944 }
945 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
946 unsigned &NumAliases) const {}
947 virtual bool useGlobalsForAutomaticVariables() const {return true;}
948 };
949}
950
Chris Lattner4b009652007-07-25 00:24:17 +0000951//===----------------------------------------------------------------------===//
952// Driver code
953//===----------------------------------------------------------------------===//
954
Ted Kremenekb97d7672007-12-04 17:07:35 +0000955static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +0000956 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
957 TT[4] == '-' && TT[1] - '3' < 6);
958}
959
Chris Lattnerfc457002008-03-05 01:18:20 +0000960/// CreateTargetInfo - Return the target info object for the specified target
961/// triple.
962TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Eli Friedman2b161652008-08-21 00:13:15 +0000963 // OS detection; this isn't really anywhere near complete.
964 // Additions and corrections are welcome.
965 bool isDarwin = T.find("-darwin") != std::string::npos;
Chris Lattnerd4faca42008-08-23 18:23:14 +0000966 bool isDragonFly = T.find("-dragonfly") != std::string::npos;
Eli Friedman2b161652008-08-21 00:13:15 +0000967 bool isSolaris = T.find("-solaris") != std::string::npos;
968 bool isLinux = T.find("-linux") != std::string::npos;
969 bool isWindows = T.find("-windows") != std::string::npos ||
970 T.find("-win32") != std::string::npos ||
971 T.find("-mingw") != std::string::npos;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000972
Eli Friedman2b161652008-08-21 00:13:15 +0000973 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0) {
974 if (isDarwin)
975 return new DarwinPPCTargetInfo(T);
976 return new PPC32TargetInfo(T);
977 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000978
Eli Friedman2b161652008-08-21 00:13:15 +0000979 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0) {
980 if (isDarwin)
981 return new DarwinPPC64TargetInfo(T);
982 return new PPC64TargetInfo(T);
983 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000984
Eli Friedman2b161652008-08-21 00:13:15 +0000985 if (T.find("armv6-") == 0 || T.find("arm-") == 0) {
986 if (isDarwin)
987 return new DarwinARMTargetInfo(T);
988 return new ARMTargetInfo(T);
989 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000990
Eli Friedman2b161652008-08-21 00:13:15 +0000991 if (T.find("sparc-") == 0) {
992 if (isSolaris)
993 return new SolarisSparcV8TargetInfo(T);
994 return new SparcV8TargetInfo(T);
995 }
996
997 if (T.find("x86_64-") == 0) {
998 if (isDarwin)
999 return new DarwinX86_64TargetInfo(T);
Daniel Dunbare5a80f22008-09-23 17:37:57 +00001000 if (isLinux)
1001 return new LinuxX86_64TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001002 return new X86_64TargetInfo(T);
1003 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001004
Chris Lattner85970f32008-05-08 05:58:21 +00001005 if (T.find("pic16-") == 0)
1006 return new PIC16TargetInfo(T);
1007
Eli Friedman2b161652008-08-21 00:13:15 +00001008 if (IsX86(T)) {
1009 if (isDarwin)
1010 return new DarwinI386TargetInfo(T);
Eli Friedman5fb0a022008-08-21 00:24:02 +00001011 if (isLinux)
1012 return new LinuxX86_32TargetInfo(T);
Chris Lattnerd4faca42008-08-23 18:23:14 +00001013 if (isDragonFly)
1014 return new DragonFlyX86_32TargetInfo(T);
Eli Friedman23cb7912008-08-21 01:40:19 +00001015 if (isWindows)
1016 return new WindowsX86_32TargetInfo(T);
Eli Friedman2b161652008-08-21 00:13:15 +00001017 return new X86_32TargetInfo(T);
1018 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001019
Chris Lattnerfc457002008-03-05 01:18:20 +00001020 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +00001021}
Ted Kremenekd507bab2008-03-04 17:47:18 +00001022