blob: aadd8ed5397fd64bdbbfcd2128e8770379290db6 [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
37
Chris Lattner4b009652007-07-25 00:24:17 +000038namespace {
Chris Lattner0fb8d852008-03-08 08:24:01 +000039class DarwinTargetInfo : public TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +000040public:
Chris Lattner0fb8d852008-03-08 08:24:01 +000041 DarwinTargetInfo(const std::string& triple) : TargetInfo(triple) {}
Ted Kremenek40499482007-12-03 22:06:55 +000042
Chris Lattner0db667a2007-10-06 06:57:34 +000043 virtual void getTargetDefines(std::vector<char> &Defs) const {
Chris Lattner1ed172d2007-10-17 06:04:46 +000044// FIXME: we need a real target configuration system. For now, only define
45// __APPLE__ if the host has it.
46#ifdef __APPLE__
Chris Lattner0db667a2007-10-06 06:57:34 +000047 Define(Defs, "__APPLE__");
48 Define(Defs, "__MACH__");
Chris Lattner1ed172d2007-10-17 06:04:46 +000049#endif
Nuno Lopese531db82008-07-05 19:32:25 +000050
51/* FIXME. we may also need to distinguish between darwin and linux targets */
52#ifdef linux
53 Define(Defs, "linux");
54#endif
Chris Lattner4b009652007-07-25 00:24:17 +000055
Chris Lattner4b009652007-07-25 00:24:17 +000056 if (0) // darwin_pascal_strings
Chris Lattner0db667a2007-10-06 06:57:34 +000057 Define(Defs, "__PASCAL_STRINGS__");
Chris Lattner4b009652007-07-25 00:24:17 +000058 }
59
60};
Gabor Greif8a3ff0d2008-02-21 16:29:08 +000061
62
Chris Lattner0fb8d852008-03-08 08:24:01 +000063class SolarisTargetInfo : public TargetInfo {
Gabor Greif8a3ff0d2008-02-21 16:29:08 +000064public:
Chris Lattner0fb8d852008-03-08 08:24:01 +000065 SolarisTargetInfo(const std::string& triple) : TargetInfo(triple) {}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +000066
67 virtual void getTargetDefines(std::vector<char> &Defs) const {
68// FIXME: we need a real target configuration system. For now, only define
69// __SUN__ if the host has it.
70#ifdef __SUN__
71 Define(Defs, "__SUN__");
72 Define(Defs, "__SOLARIS__");
73#endif
Gabor Greif8a3ff0d2008-02-21 16:29:08 +000074 }
75
76};
Chris Lattner4b009652007-07-25 00:24:17 +000077} // end anonymous namespace.
78
Eli Friedman872996c2008-08-20 02:34:37 +000079static void getDarwinDefines(std::vector<char> &Defs) {
80 Define(Defs, "__APPLE__");
81 Define(Defs, "__MACH__");
82
83 if (0) // darwin_pascal_strings
84 Define(Defs, "__PASCAL_STRINGS__");
85}
Chris Lattner4b009652007-07-25 00:24:17 +000086
87/// getPowerPCDefines - Return a set of the PowerPC-specific #defines that are
88/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +000089static void getPowerPCDefines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +000090 // Target identification.
Chris Lattner0db667a2007-10-06 06:57:34 +000091 Define(Defs, "__ppc__");
92 Define(Defs, "_ARCH_PPC");
93 Define(Defs, "__POWERPC__");
Chris Lattner4b009652007-07-25 00:24:17 +000094 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +000095 Define(Defs, "_ARCH_PPC64");
96 Define(Defs, "_LP64");
97 Define(Defs, "__LP64__");
98 Define(Defs, "__ppc64__");
Chris Lattner4b009652007-07-25 00:24:17 +000099 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000100 Define(Defs, "__ppc__");
Chris Lattner4b009652007-07-25 00:24:17 +0000101 }
102
103 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +0000104 Define(Defs, "_BIG_ENDIAN");
105 Define(Defs, "__BIG_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +0000106
107 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000108 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
109 Define(Defs, "__INTMAX_TYPE__", "long int");
110 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
111 Define(Defs, "__PTRDIFF_TYPE__", "long int");
112 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000113 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000114 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
115 Define(Defs, "__INTMAX_TYPE__", "long long int");
116 Define(Defs, "__LONG_MAX__", "2147483647L");
117 Define(Defs, "__PTRDIFF_TYPE__", "int");
118 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000119 }
Chris Lattner0db667a2007-10-06 06:57:34 +0000120 Define(Defs, "__INT_MAX__", "2147483647");
121 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
122 Define(Defs, "__CHAR_BIT__", "8");
123 Define(Defs, "__SCHAR_MAX__", "127");
124 Define(Defs, "__SHRT_MAX__", "32767");
125 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000126
127 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000128 Define(Defs, "__USER_LABEL_PREFIX__", "_");
129 Define(Defs, "__NATURAL_ALIGNMENT__");
130 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000131
Chris Lattner0db667a2007-10-06 06:57:34 +0000132 Define(Defs, "__WCHAR_MAX__", "2147483647");
133 Define(Defs, "__WCHAR_TYPE__", "int");
134 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000135
136 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000137 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
138 Define(Defs, "__FLT_DIG__", "6");
139 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
140 Define(Defs, "__FLT_EVAL_METHOD__", "0");
141 Define(Defs, "__FLT_HAS_INFINITY__");
142 Define(Defs, "__FLT_HAS_QUIET_NAN__");
143 Define(Defs, "__FLT_MANT_DIG__", "24");
144 Define(Defs, "__FLT_MAX_10_EXP__", "38");
145 Define(Defs, "__FLT_MAX_EXP__", "128");
146 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
147 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
148 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
149 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
150 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000151
152 // double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000153 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
154 Define(Defs, "__DBL_DIG__", "15");
155 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
156 Define(Defs, "__DBL_HAS_INFINITY__");
157 Define(Defs, "__DBL_HAS_QUIET_NAN__");
158 Define(Defs, "__DBL_MANT_DIG__", "53");
159 Define(Defs, "__DBL_MAX_10_EXP__", "308");
160 Define(Defs, "__DBL_MAX_EXP__", "1024");
161 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
162 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
163 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
164 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
165 Define(Defs, "__DECIMAL_DIG__", "33");
Chris Lattner4b009652007-07-25 00:24:17 +0000166
167 // 128-bit long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000168 Define(Defs, "__LDBL_DENORM_MIN__",
169 "4.94065645841246544176568792868221e-324L");
170 Define(Defs, "__LDBL_DIG__", "31");
171 Define(Defs, "__LDBL_EPSILON__",
172 "4.94065645841246544176568792868221e-324L");
173 Define(Defs, "__LDBL_HAS_INFINITY__");
174 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
175 Define(Defs, "__LDBL_MANT_DIG__", "106");
176 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
177 Define(Defs, "__LDBL_MAX_EXP__", "1024");
178 Define(Defs, "__LDBL_MAX__",
179 "1.79769313486231580793728971405301e+308L");
180 Define(Defs, "__LDBL_MIN_10_EXP__", "(-291)");
181 Define(Defs, "__LDBL_MIN_EXP__", "(-968)");
182 Define(Defs, "__LDBL_MIN__",
183 "2.00416836000897277799610805135016e-292L");
184 Define(Defs, "__LONG_DOUBLE_128__");
Chris Lattner4b009652007-07-25 00:24:17 +0000185}
186
187/// getX86Defines - Return a set of the X86-specific #defines that are
188/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +0000189static void getX86Defines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +0000190 // Target identification.
191 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000192 Define(Defs, "_LP64");
193 Define(Defs, "__LP64__");
194 Define(Defs, "__amd64__");
195 Define(Defs, "__amd64");
196 Define(Defs, "__x86_64");
197 Define(Defs, "__x86_64__");
Chris Lattner4b009652007-07-25 00:24:17 +0000198 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000199 Define(Defs, "__i386__");
200 Define(Defs, "__i386");
201 Define(Defs, "i386");
Chris Lattner4b009652007-07-25 00:24:17 +0000202 }
203
204 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +0000205 Define(Defs, "__LITTLE_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +0000206
207 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000208 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
209 Define(Defs, "__INTMAX_TYPE__", "long int");
210 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
211 Define(Defs, "__PTRDIFF_TYPE__", "long int");
212 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000213 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000214 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
215 Define(Defs, "__INTMAX_TYPE__", "long long int");
216 Define(Defs, "__LONG_MAX__", "2147483647L");
217 Define(Defs, "__PTRDIFF_TYPE__", "int");
218 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000219 }
Anders Carlsson82b26282008-07-22 17:16:13 +0000220 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner0db667a2007-10-06 06:57:34 +0000221 Define(Defs, "__CHAR_BIT__", "8");
222 Define(Defs, "__INT_MAX__", "2147483647");
223 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
224 Define(Defs, "__SCHAR_MAX__", "127");
225 Define(Defs, "__SHRT_MAX__", "32767");
Chris Lattner4b009652007-07-25 00:24:17 +0000226
227 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000228 Define(Defs, "__nocona");
229 Define(Defs, "__nocona__");
230 Define(Defs, "__tune_nocona__");
231 Define(Defs, "__SSE2_MATH__");
232 Define(Defs, "__SSE2__");
233 Define(Defs, "__SSE_MATH__");
234 Define(Defs, "__SSE__");
235 Define(Defs, "__MMX__");
236 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000237
Chris Lattner0db667a2007-10-06 06:57:34 +0000238 Define(Defs, "__WCHAR_MAX__", "2147483647");
239 Define(Defs, "__WCHAR_TYPE__", "int");
240 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000241
242 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000243 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
244 Define(Defs, "__FLT_DIG__", "6");
245 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
246 Define(Defs, "__FLT_EVAL_METHOD__", "0");
247 Define(Defs, "__FLT_HAS_INFINITY__");
248 Define(Defs, "__FLT_HAS_QUIET_NAN__");
249 Define(Defs, "__FLT_MANT_DIG__", "24");
250 Define(Defs, "__FLT_MAX_10_EXP__", "38");
251 Define(Defs, "__FLT_MAX_EXP__", "128");
252 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
253 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
254 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
255 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
256 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000257
258 // Double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000259 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
260 Define(Defs, "__DBL_DIG__", "15");
261 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
262 Define(Defs, "__DBL_HAS_INFINITY__");
263 Define(Defs, "__DBL_HAS_QUIET_NAN__");
264 Define(Defs, "__DBL_MANT_DIG__", "53");
265 Define(Defs, "__DBL_MAX_10_EXP__", "308");
266 Define(Defs, "__DBL_MAX_EXP__", "1024");
267 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
268 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
269 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
270 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
271 Define(Defs, "__DECIMAL_DIG__", "21");
Chris Lattner4b009652007-07-25 00:24:17 +0000272
273 // 80-bit Long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000274 Define(Defs, "__LDBL_DENORM_MIN__", "3.64519953188247460253e-4951L");
275 Define(Defs, "__LDBL_DIG__", "18");
276 Define(Defs, "__LDBL_EPSILON__", "1.08420217248550443401e-19L");
277 Define(Defs, "__LDBL_HAS_INFINITY__");
278 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
279 Define(Defs, "__LDBL_MANT_DIG__", "64");
280 Define(Defs, "__LDBL_MAX_10_EXP__", "4932");
281 Define(Defs, "__LDBL_MAX_EXP__", "16384");
282 Define(Defs, "__LDBL_MAX__", "1.18973149535723176502e+4932L");
283 Define(Defs, "__LDBL_MIN_10_EXP__", "(-4931)");
284 Define(Defs, "__LDBL_MIN_EXP__", "(-16381)");
285 Define(Defs, "__LDBL_MIN__", "3.36210314311209350626e-4932L");
Chris Lattner4b009652007-07-25 00:24:17 +0000286}
287
Chris Lattnerb6444052008-04-21 20:19:54 +0000288/// getARMDefines - Return a set of the ARM-specific #defines that are
Chris Lattner9fd73612008-04-21 18:56:49 +0000289/// not tied to a specific subtarget.
290static void getARMDefines(std::vector<char> &Defs) {
291 // Target identification.
292 Define(Defs, "__arm");
293 Define(Defs, "__arm__");
294
295 // Target properties.
296 Define(Defs, "__LITTLE_ENDIAN__");
297
298 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
299 Define(Defs, "__INTMAX_TYPE__", "long long int");
300 Define(Defs, "__LONG_MAX__", "2147483647L");
301 Define(Defs, "__PTRDIFF_TYPE__", "int");
302 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
303 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
304
305 Define(Defs, "__CHAR_BIT__", "8");
306 Define(Defs, "__INT_MAX__", "2147483647");
307 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
308 Define(Defs, "__SCHAR_MAX__", "127");
309 Define(Defs, "__SHRT_MAX__", "32767");
310
311 // Subtarget options. [hard coded to v6 for now]
312 Define(Defs, "__ARM_ARCH_6K__");
313 Define(Defs, "__ARMEL__");
314 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", "20000");
315
316 Define(Defs, "__WCHAR_MAX__", "2147483647");
317 Define(Defs, "__WCHAR_TYPE__", "int");
318 Define(Defs, "__WINT_TYPE__", "int");
319 Define(Defs, "__DECIMAL_DIG__", "17");
320 Define(Defs, "__FLT_RADIX__", "2");
321
322 // Float macros.
323 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
324 Define(Defs, "__FLT_DIG__", "6");
325 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
326 Define(Defs, "__FLT_EVAL_METHOD__", "0");
327 Define(Defs, "__FLT_HAS_INFINITY__");
328 Define(Defs, "__FLT_HAS_QUIET_NAN__");
329 Define(Defs, "__FLT_MANT_DIG__", "24");
330 Define(Defs, "__FLT_MAX_10_EXP__", "38");
331 Define(Defs, "__FLT_MAX_EXP__", "128");
332 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
333 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
334 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
335 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
336
337 // Double macros.
338 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
339 Define(Defs, "__DBL_DIG__", "15");
340 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
341 Define(Defs, "__DBL_HAS_INFINITY__");
342 Define(Defs, "__DBL_HAS_QUIET_NAN__");
343 Define(Defs, "__DBL_MANT_DIG__", "53");
344 Define(Defs, "__DBL_MAX_10_EXP__", "308");
345 Define(Defs, "__DBL_MAX_EXP__", "1024");
346 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
347 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
348 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
349 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
350
351 // 64-bit Long double macros (same as double).
352 Define(Defs, "__LDBL_DENORM_MIN__", "4.9406564584124654e-324");
353 Define(Defs, "__LDBL_DIG__", "15");
354 Define(Defs, "__LDBL_EPSILON__", "2.2204460492503131e-16");
355 Define(Defs, "__LDBL_HAS_INFINITY__");
356 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
357 Define(Defs, "__LDBL_MANT_DIG__", "53");
358 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
359 Define(Defs, "__LDBL_MAX_EXP__", "1024");
360 Define(Defs, "__LDBL_MAX__", "1.7976931348623157e+308");
361 Define(Defs, "__LDBL_MIN_10_EXP__", "(-307)");
362 Define(Defs, "__LDBL_MIN_EXP__", "(-1021)");
363 Define(Defs, "__LDBL_MIN__", "2.2250738585072014e-308");
364}
365
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000366static const char* getI386VAListDeclaration() {
367 return "typedef char* __builtin_va_list;";
368}
369
370static const char* getX86_64VAListDeclaration() {
371 return
372 "typedef struct __va_list_tag {"
373 " unsigned gp_offset;"
374 " unsigned fp_offset;"
375 " void* overflow_arg_area;"
376 " void* reg_save_area;"
377 "} __builtin_va_list[1];";
378}
379
380static const char* getPPCVAListDeclaration() {
381 return
382 "typedef struct __va_list_tag {"
383 " unsigned char gpr;"
384 " unsigned char fpr;"
385 " unsigned short reserved;"
386 " void* overflow_arg_area;"
387 " void* reg_save_area;"
388 "} __builtin_va_list[1];";
389}
390
Chris Lattner9fd73612008-04-21 18:56:49 +0000391static const char* getARMVAListDeclaration() {
392 return "typedef char* __builtin_va_list;";
393}
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000394
Chris Lattner4b009652007-07-25 00:24:17 +0000395/// PPC builtin info.
Chris Lattner9a3dedf2007-12-11 04:36:28 +0000396namespace clang {
Chris Lattner4b009652007-07-25 00:24:17 +0000397namespace PPC {
Chris Lattner4b009652007-07-25 00:24:17 +0000398
399 static const Builtin::Info BuiltinInfo[] = {
400#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
Anders Carlssone1449c12007-12-09 23:17:02 +0000401#include "clang/AST/PPCBuiltins.def"
Chris Lattner4b009652007-07-25 00:24:17 +0000402 };
403
404 static void getBuiltins(const Builtin::Info *&Records, unsigned &NumRecords) {
405 Records = BuiltinInfo;
406 NumRecords = LastTSBuiltin-Builtin::FirstTSBuiltin;
407 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000408
409 static const char * const GCCRegNames[] = {
410 "0", "1", "2", "3", "4", "5", "6", "7",
411 "8", "9", "10", "11", "12", "13", "14", "15",
412 "16", "17", "18", "19", "20", "21", "22", "23",
413 "24", "25", "26", "27", "28", "29", "30", "31",
414 "0", "1", "2", "3", "4", "5", "6", "7",
415 "8", "9", "10", "11", "12", "13", "14", "15",
416 "16", "17", "18", "19", "20", "21", "22", "23",
417 "24", "25", "26", "27", "28", "29", "30", "31",
418 "mq", "lr", "ctr", "ap",
419 "0", "1", "2", "3", "4", "5", "6", "7",
420 "xer",
421 "0", "1", "2", "3", "4", "5", "6", "7",
422 "8", "9", "10", "11", "12", "13", "14", "15",
423 "16", "17", "18", "19", "20", "21", "22", "23",
424 "24", "25", "26", "27", "28", "29", "30", "31",
425 "vrsave", "vscr",
426 "spe_acc", "spefscr",
427 "sfp"
428 };
429
430 static void getGCCRegNames(const char * const *&Names,
431 unsigned &NumNames) {
432 Names = GCCRegNames;
433 NumNames = llvm::array_lengthof(GCCRegNames);
434 }
435
Chris Lattner0fb8d852008-03-08 08:24:01 +0000436 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000437 // While some of these aliases do map to different registers
438 // they still share the same register name.
439 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
440 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
441 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
442 { { "cr3", "fr3", "r3", "v3"}, "3" },
443 { { "cr4", "fr4", "r4", "v4"}, "4" },
444 { { "cr5", "fr5", "r5", "v5"}, "5" },
445 { { "cr6", "fr6", "r6", "v6"}, "6" },
446 { { "cr7", "fr7", "r7", "v7"}, "7" },
447 { { "fr8", "r8", "v8"}, "8" },
448 { { "fr9", "r9", "v9"}, "9" },
449 { { "fr10", "r10", "v10"}, "10" },
450 { { "fr11", "r11", "v11"}, "11" },
451 { { "fr12", "r12", "v12"}, "12" },
452 { { "fr13", "r13", "v13"}, "13" },
453 { { "fr14", "r14", "v14"}, "14" },
454 { { "fr15", "r15", "v15"}, "15" },
455 { { "fr16", "r16", "v16"}, "16" },
456 { { "fr17", "r17", "v17"}, "17" },
457 { { "fr18", "r18", "v18"}, "18" },
458 { { "fr19", "r19", "v19"}, "19" },
459 { { "fr20", "r20", "v20"}, "20" },
460 { { "fr21", "r21", "v21"}, "21" },
461 { { "fr22", "r22", "v22"}, "22" },
462 { { "fr23", "r23", "v23"}, "23" },
463 { { "fr24", "r24", "v24"}, "24" },
464 { { "fr25", "r25", "v25"}, "25" },
465 { { "fr26", "r26", "v26"}, "26" },
466 { { "fr27", "r27", "v27"}, "27" },
467 { { "fr28", "r28", "v28"}, "28" },
468 { { "fr29", "r29", "v29"}, "29" },
469 { { "fr30", "r30", "v30"}, "30" },
470 { { "fr31", "r31", "v31"}, "31" },
471 };
472
Chris Lattner0fb8d852008-03-08 08:24:01 +0000473 static void getGCCRegAliases(const TargetInfo::GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000474 unsigned &NumAliases) {
475 Aliases = GCCRegAliases;
476 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson4ce42302007-11-27 04:11:28 +0000477 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000478
Anders Carlsson4ce42302007-11-27 04:11:28 +0000479 static bool validateAsmConstraint(char c,
480 TargetInfo::ConstraintInfo &info) {
481 switch (c) {
482 default: return false;
483 case 'O': // Zero
484 return true;
485 case 'b': // Base register
486 case 'f': // Floating point register
487 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
488 return true;
489 }
490 }
491
492 const char *getClobbers() {
493 return 0;
494 }
495
Anders Carlsson333052c2007-12-08 19:32:57 +0000496 const char *getTargetPrefix() {
497 return "ppc";
498 }
499
Chris Lattner4b009652007-07-25 00:24:17 +0000500} // End namespace PPC
Chris Lattner9fd73612008-04-21 18:56:49 +0000501
502
503/// ARM builtin info.
504namespace ARM {
505 const char *getTargetPrefix() {
506 return "arm";
507 }
508} // End namespace ARM
509
Chris Lattner9a3dedf2007-12-11 04:36:28 +0000510} // end namespace clang.
Chris Lattner4b009652007-07-25 00:24:17 +0000511
512//===----------------------------------------------------------------------===//
513// Specific target implementations.
514//===----------------------------------------------------------------------===//
515
516
517namespace {
518class DarwinPPCTargetInfo : public DarwinTargetInfo {
519public:
Eli Friedman2fde2a52008-05-20 14:25:01 +0000520 DarwinPPCTargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
521 CharIsSigned = false;
522 }
Ted Kremenek40499482007-12-03 22:06:55 +0000523
Chris Lattner0db667a2007-10-06 06:57:34 +0000524 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000525 DarwinTargetInfo::getTargetDefines(Defines);
526 getPowerPCDefines(Defines, false);
527 }
528 virtual void getTargetBuiltins(const Builtin::Info *&Records,
529 unsigned &NumRecords) const {
530 PPC::getBuiltins(Records, NumRecords);
531 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000532 virtual const char *getVAListDeclaration() const {
533 return getPPCVAListDeclaration();
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000534 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000535 virtual const char *getTargetPrefix() const {
536 return PPC::getTargetPrefix();
537 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000538 virtual void getGCCRegNames(const char * const *&Names,
539 unsigned &NumNames) const {
540 PPC::getGCCRegNames(Names, NumNames);
541 }
542 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
543 unsigned &NumAliases) const {
544 PPC::getGCCRegAliases(Aliases, NumAliases);
545 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000546 virtual bool validateAsmConstraint(char c,
547 TargetInfo::ConstraintInfo &info) const {
548 return PPC::validateAsmConstraint(c, info);
549 }
550 virtual const char *getClobbers() const {
551 return PPC::getClobbers();
552 }
Chris Lattner4b009652007-07-25 00:24:17 +0000553};
554} // end anonymous namespace.
555
556namespace {
557class DarwinPPC64TargetInfo : public DarwinTargetInfo {
558public:
Chris Lattnere5fde952008-05-09 06:17:04 +0000559 DarwinPPC64TargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
Eli Friedman2fde2a52008-05-20 14:25:01 +0000560 CharIsSigned = false;
Chris Lattnere5fde952008-05-09 06:17:04 +0000561 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
562 }
Ted Kremenek40499482007-12-03 22:06:55 +0000563
Chris Lattner0db667a2007-10-06 06:57:34 +0000564 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000565 DarwinTargetInfo::getTargetDefines(Defines);
566 getPowerPCDefines(Defines, true);
567 }
568 virtual void getTargetBuiltins(const Builtin::Info *&Records,
569 unsigned &NumRecords) const {
570 PPC::getBuiltins(Records, NumRecords);
571 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000572 virtual const char *getVAListDeclaration() const {
573 return getPPCVAListDeclaration();
574 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000575 virtual const char *getTargetPrefix() const {
576 return PPC::getTargetPrefix();
577 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000578 virtual void getGCCRegNames(const char * const *&Names,
579 unsigned &NumNames) const {
580 PPC::getGCCRegNames(Names, NumNames);
581 }
582 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
583 unsigned &NumAliases) const {
584 PPC::getGCCRegAliases(Aliases, NumAliases);
585 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000586 virtual bool validateAsmConstraint(char c,
587 TargetInfo::ConstraintInfo &info) const {
588 return PPC::validateAsmConstraint(c, info);
589 }
590 virtual const char *getClobbers() const {
591 return PPC::getClobbers();
592 }
Chris Lattner4b009652007-07-25 00:24:17 +0000593};
594} // end anonymous namespace.
595
596namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000597// Namespace for x86 abstract base class
598const Builtin::Info BuiltinInfo[] = {
599#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
600#include "clang/AST/X86Builtins.def"
601};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000602
Eli Friedman872996c2008-08-20 02:34:37 +0000603const char *GCCRegNames[] = {
604 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
605 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
606 "argp", "flags", "fspr", "dirflag", "frame",
607 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
608 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
609 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
610 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
611};
612
613const TargetInfo::GCCRegAlias GCCRegAliases[] = {
614 { { "al", "ah", "eax", "rax" }, "ax" },
615 { { "bl", "bh", "ebx", "rbx" }, "bx" },
616 { { "cl", "ch", "ecx", "rcx" }, "cx" },
617 { { "dl", "dh", "edx", "rdx" }, "dx" },
618 { { "esi", "rsi" }, "si" },
619 { { "edi", "rdi" }, "di" },
620 { { "esp", "rsp" }, "sp" },
621 { { "ebp", "rbp" }, "bp" },
622};
623
624// X86 target abstract base class; x86-32 and x86-64 are very close, so
625// most of the implementation can be shared.
626class X86TargetInfo : public TargetInfo {
627public:
628 X86TargetInfo(const std::string& triple) : TargetInfo(triple) {
629 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000630 }
631 virtual void getTargetBuiltins(const Builtin::Info *&Records,
632 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000633 Records = BuiltinInfo;
634 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000635 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000636 virtual const char *getTargetPrefix() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000637 return "x86";
Anders Carlsson333052c2007-12-08 19:32:57 +0000638 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000639 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000640 unsigned &NumNames) const {
641 Names = GCCRegNames;
642 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000643 }
644 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
645 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000646 Aliases = GCCRegAliases;
647 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000648 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000649 virtual bool validateAsmConstraint(char c,
Eli Friedman872996c2008-08-20 02:34:37 +0000650 TargetInfo::ConstraintInfo &info) const;
651 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000652 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000653 return "~{dirflag},~{fpsr},~{flags}";
654 }
Chris Lattner4b009652007-07-25 00:24:17 +0000655};
Eli Friedman872996c2008-08-20 02:34:37 +0000656
657bool
658X86TargetInfo::validateAsmConstraint(char c,
659 TargetInfo::ConstraintInfo &info) const {
660 switch (c) {
661 default: return false;
662 case 'a': // eax.
663 case 'b': // ebx.
664 case 'c': // ecx.
665 case 'd': // edx.
666 case 'S': // esi.
667 case 'D': // edi.
668 case 'A': // edx:eax.
669 case 't': // top of floating point stack.
670 case 'u': // second from top of floating point stack.
671 case 'q': // Any register accessible as [r]l: a, b, c, and d.
672 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
673 case 'Z': // 32-bit integer constant for use with zero-extending x86_64
674 // instructions.
675 case 'N': // unsigned 8-bit integer constant for use with in and out
676 // instructions.
677 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
678 return true;
679 }
680}
681
682std::string
683X86TargetInfo::convertConstraint(const char Constraint) const {
684 switch (Constraint) {
685 case 'a': return std::string("{ax}");
686 case 'b': return std::string("{bx}");
687 case 'c': return std::string("{cx}");
688 case 'd': return std::string("{dx}");
689 case 'S': return std::string("{si}");
690 case 'D': return std::string("{di}");
691 case 't': // top of floating point stack.
692 return std::string("{st}");
693 case 'u': // second from top of floating point stack.
694 return std::string("{st(1)}"); // second from top of floating point stack.
695 default:
696 return std::string(1, Constraint);
697 }
698}
699
700} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +0000701
702namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000703// X86-32 generic target
704class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000705public:
Eli Friedman872996c2008-08-20 02:34:37 +0000706 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
707 DoubleAlign = LongLongAlign = 32;
708 LongDoubleWidth = 96;
709 LongDoubleAlign = 32;
710 }
711 virtual const char *getVAListDeclaration() const {
712 return getI386VAListDeclaration();
713 }
714 virtual void getTargetDefines(std::vector<char> &Defines) const {
715 getX86Defines(Defines, false);
716 }
717};
718} // end anonymous namespace
719
720namespace {
721// x86-32 Darwin (OS X) target
722class DarwinI386TargetInfo : public X86_32TargetInfo {
723public:
724 DarwinI386TargetInfo(const std::string& triple) : X86_32TargetInfo(triple) {
725 LongDoubleWidth = 128;
726 LongDoubleAlign = 128;
727 }
728 virtual void getTargetDefines(std::vector<char> &Defines) const {
729 X86_32TargetInfo::getTargetDefines(Defines);
730 getDarwinDefines(Defines);
731 }
732};
733} // end anonymous namespace
734
735namespace {
736// x86-64 generic target
737class X86_64TargetInfo : public X86TargetInfo {
738public:
739 X86_64TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000740 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000741 LongDoubleWidth = 128;
742 LongDoubleAlign = 128;
Chris Lattner4b009652007-07-25 00:24:17 +0000743 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000744 virtual const char *getVAListDeclaration() const {
745 return getX86_64VAListDeclaration();
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000746 }
Eli Friedman872996c2008-08-20 02:34:37 +0000747 virtual void getTargetDefines(std::vector<char> &Defines) const {
748 getX86Defines(Defines, true);
Anders Carlsson333052c2007-12-08 19:32:57 +0000749 }
Eli Friedman872996c2008-08-20 02:34:37 +0000750};
751} // end anonymous namespace
752
753namespace {
754// x86-64 Darwin (OS X) target
755class DarwinX86_64TargetInfo : public X86_64TargetInfo {
756public:
757 DarwinX86_64TargetInfo(const std::string& triple) :
758 X86_64TargetInfo(triple) {}
759
760 virtual void getTargetDefines(std::vector<char> &Defines) const {
761 X86_64TargetInfo::getTargetDefines(Defines);
762 getDarwinDefines(Defines);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000763 }
Chris Lattner4b009652007-07-25 00:24:17 +0000764};
765} // end anonymous namespace.
766
Chris Lattner9fd73612008-04-21 18:56:49 +0000767
768namespace {
769class DarwinARMTargetInfo : public DarwinTargetInfo {
770public:
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000771 DarwinARMTargetInfo(const std::string& triple) :DarwinTargetInfo(triple) {
772 // FIXME: Are the defaults corrent for ARM?
773 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000774
775 virtual void getTargetDefines(std::vector<char> &Defines) const {
776 DarwinTargetInfo::getTargetDefines(Defines);
777 getARMDefines(Defines);
778 }
779 virtual void getTargetBuiltins(const Builtin::Info *&Records,
780 unsigned &NumRecords) const {
781 NumRecords = 0;
782 }
783 virtual const char *getVAListDeclaration() const {
784 return getARMVAListDeclaration();
785 }
786 virtual const char *getTargetPrefix() const {
787 return ARM::getTargetPrefix();
788 }
789
790 virtual void getGCCRegNames(const char * const *&Names,
791 unsigned &NumNames) const {
792 NumNames = 0;
793 }
794 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
795 unsigned &NumAliases) const {
796 NumAliases = 0;
797 }
798 virtual bool validateAsmConstraint(char c,
Nate Begeman222823a2008-04-22 05:03:19 +0000799 TargetInfo::ConstraintInfo &info) const {
800 switch (c) {
801 default:
802 case 'l': // r0-r7
803 case 'h': // r8-r15
804 case 'w': // VFP Floating point register single precision
805 case 'P': // VFP Floating point register double precision
806 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
807 return true;
808 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000809 return false;
810 }
811 virtual const char *getClobbers() const {
812 return "";
813 }
814};
815} // end anonymous namespace.
816
Chris Lattner4b009652007-07-25 00:24:17 +0000817namespace {
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000818class SolarisSparcV8TargetInfo : public SolarisTargetInfo {
819public:
820 SolarisSparcV8TargetInfo(const std::string& triple) : SolarisTargetInfo(triple) {}
821
822 virtual void getTargetDefines(std::vector<char> &Defines) const {
823 SolarisTargetInfo::getTargetDefines(Defines);
824// getSparcDefines(Defines, false);
825 Define(Defines, "__sparc");
Eli Friedman1dee5c52008-05-25 05:26:09 +0000826 Define(Defines, "__sparc__");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000827 Define(Defines, "__sparcv8");
828 }
829 virtual void getTargetBuiltins(const Builtin::Info *&Records,
830 unsigned &NumRecords) const {
831 PPC::getBuiltins(Records, NumRecords);
832 }
833 virtual const char *getVAListDeclaration() const {
834 return getPPCVAListDeclaration();
835 }
836 virtual const char *getTargetPrefix() const {
837 return PPC::getTargetPrefix();
838 }
839 virtual void getGCCRegNames(const char * const *&Names,
840 unsigned &NumNames) const {
841 PPC::getGCCRegNames(Names, NumNames);
842 }
843 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
844 unsigned &NumAliases) const {
845 PPC::getGCCRegAliases(Aliases, NumAliases);
846 }
847 virtual bool validateAsmConstraint(char c,
848 TargetInfo::ConstraintInfo &info) const {
849 return PPC::validateAsmConstraint(c, info);
850 }
851 virtual const char *getClobbers() const {
852 return PPC::getClobbers();
853 }
854};
855
856} // end anonymous namespace.
857
Chris Lattner4b009652007-07-25 00:24:17 +0000858
Chris Lattner85970f32008-05-08 05:58:21 +0000859namespace {
860 class PIC16TargetInfo : public TargetInfo{
861 public:
862 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000863 // FIXME: Is IntAlign really supposed to be 16? There seems
864 // little point on a platform with 8-bit loads.
865 IntWidth = IntAlign = LongAlign = LongLongAlign = PointerWidth = 16;
866 PointerAlign = 8;
Sanjiv Guptaebd8f0f2008-08-18 10:05:22 +0000867 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
Chris Lattner85970f32008-05-08 05:58:21 +0000868 }
Chris Lattner727b3c42008-05-09 06:08:39 +0000869 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
870 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner85970f32008-05-08 05:58:21 +0000871 virtual void getTargetDefines(std::vector<char> &Defines) const {
872 Define(Defines, "__pic16");
873 }
874 virtual void getTargetBuiltins(const Builtin::Info *&Records,
875 unsigned &NumRecords) const {}
876 virtual const char *getVAListDeclaration() const { return "";}
877 virtual const char *getClobbers() const {return "";}
878 virtual const char *getTargetPrefix() const {return "";}
879 virtual void getGCCRegNames(const char * const *&Names,
880 unsigned &NumNames) const {}
881 virtual bool validateAsmConstraint(char c,
882 TargetInfo::ConstraintInfo &info) const {
883 return true;
884 }
885 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
886 unsigned &NumAliases) const {}
887 virtual bool useGlobalsForAutomaticVariables() const {return true;}
888 };
889}
890
Chris Lattner4b009652007-07-25 00:24:17 +0000891//===----------------------------------------------------------------------===//
892// Driver code
893//===----------------------------------------------------------------------===//
894
Ted Kremenekb97d7672007-12-04 17:07:35 +0000895static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +0000896 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
897 TT[4] == '-' && TT[1] - '3' < 6);
898}
899
Chris Lattnerfc457002008-03-05 01:18:20 +0000900/// CreateTargetInfo - Return the target info object for the specified target
901/// triple.
902TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Chris Lattner2c63b9f2007-12-05 18:41:05 +0000903 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000904 return new DarwinPPCTargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000905
Chris Lattnerfc457002008-03-05 01:18:20 +0000906 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000907 return new DarwinPPC64TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000908
Chris Lattner9fd73612008-04-21 18:56:49 +0000909 if (T.find("armv6-") == 0 || T.find("arm-") == 0)
910 return new DarwinARMTargetInfo(T);
911
Chris Lattnerfc457002008-03-05 01:18:20 +0000912 if (T.find("sparc-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000913 return new SolarisSparcV8TargetInfo(T); // ugly hack
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000914
Chris Lattnerfc457002008-03-05 01:18:20 +0000915 if (T.find("x86_64-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000916 return new DarwinX86_64TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000917
Chris Lattner85970f32008-05-08 05:58:21 +0000918 if (T.find("pic16-") == 0)
919 return new PIC16TargetInfo(T);
920
Chris Lattnerfc457002008-03-05 01:18:20 +0000921 if (IsX86(T))
Chris Lattner0fb8d852008-03-08 08:24:01 +0000922 return new DarwinI386TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000923
Chris Lattnerfc457002008-03-05 01:18:20 +0000924 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +0000925}
Ted Kremenekd507bab2008-03-04 17:47:18 +0000926