blob: 3147aaa9bfc9596802d9c359e69298c0dbcee0a8 [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
79
80/// getPowerPCDefines - Return a set of the PowerPC-specific #defines that are
81/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +000082static void getPowerPCDefines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +000083 // Target identification.
Chris Lattner0db667a2007-10-06 06:57:34 +000084 Define(Defs, "__ppc__");
85 Define(Defs, "_ARCH_PPC");
86 Define(Defs, "__POWERPC__");
Chris Lattner4b009652007-07-25 00:24:17 +000087 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +000088 Define(Defs, "_ARCH_PPC64");
89 Define(Defs, "_LP64");
90 Define(Defs, "__LP64__");
91 Define(Defs, "__ppc64__");
Chris Lattner4b009652007-07-25 00:24:17 +000092 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +000093 Define(Defs, "__ppc__");
Chris Lattner4b009652007-07-25 00:24:17 +000094 }
95
96 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +000097 Define(Defs, "_BIG_ENDIAN");
98 Define(Defs, "__BIG_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +000099
100 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000101 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
102 Define(Defs, "__INTMAX_TYPE__", "long int");
103 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
104 Define(Defs, "__PTRDIFF_TYPE__", "long int");
105 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000106 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000107 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
108 Define(Defs, "__INTMAX_TYPE__", "long long int");
109 Define(Defs, "__LONG_MAX__", "2147483647L");
110 Define(Defs, "__PTRDIFF_TYPE__", "int");
111 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000112 }
Chris Lattner0db667a2007-10-06 06:57:34 +0000113 Define(Defs, "__INT_MAX__", "2147483647");
114 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
115 Define(Defs, "__CHAR_BIT__", "8");
116 Define(Defs, "__SCHAR_MAX__", "127");
117 Define(Defs, "__SHRT_MAX__", "32767");
118 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000119
120 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000121 Define(Defs, "__USER_LABEL_PREFIX__", "_");
122 Define(Defs, "__NATURAL_ALIGNMENT__");
123 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000124
Chris Lattner0db667a2007-10-06 06:57:34 +0000125 Define(Defs, "__WCHAR_MAX__", "2147483647");
126 Define(Defs, "__WCHAR_TYPE__", "int");
127 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000128
129 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000130 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
131 Define(Defs, "__FLT_DIG__", "6");
132 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
133 Define(Defs, "__FLT_EVAL_METHOD__", "0");
134 Define(Defs, "__FLT_HAS_INFINITY__");
135 Define(Defs, "__FLT_HAS_QUIET_NAN__");
136 Define(Defs, "__FLT_MANT_DIG__", "24");
137 Define(Defs, "__FLT_MAX_10_EXP__", "38");
138 Define(Defs, "__FLT_MAX_EXP__", "128");
139 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
140 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
141 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
142 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
143 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000144
145 // double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000146 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
147 Define(Defs, "__DBL_DIG__", "15");
148 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
149 Define(Defs, "__DBL_HAS_INFINITY__");
150 Define(Defs, "__DBL_HAS_QUIET_NAN__");
151 Define(Defs, "__DBL_MANT_DIG__", "53");
152 Define(Defs, "__DBL_MAX_10_EXP__", "308");
153 Define(Defs, "__DBL_MAX_EXP__", "1024");
154 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
155 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
156 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
157 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
158 Define(Defs, "__DECIMAL_DIG__", "33");
Chris Lattner4b009652007-07-25 00:24:17 +0000159
160 // 128-bit long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000161 Define(Defs, "__LDBL_DENORM_MIN__",
162 "4.94065645841246544176568792868221e-324L");
163 Define(Defs, "__LDBL_DIG__", "31");
164 Define(Defs, "__LDBL_EPSILON__",
165 "4.94065645841246544176568792868221e-324L");
166 Define(Defs, "__LDBL_HAS_INFINITY__");
167 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
168 Define(Defs, "__LDBL_MANT_DIG__", "106");
169 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
170 Define(Defs, "__LDBL_MAX_EXP__", "1024");
171 Define(Defs, "__LDBL_MAX__",
172 "1.79769313486231580793728971405301e+308L");
173 Define(Defs, "__LDBL_MIN_10_EXP__", "(-291)");
174 Define(Defs, "__LDBL_MIN_EXP__", "(-968)");
175 Define(Defs, "__LDBL_MIN__",
176 "2.00416836000897277799610805135016e-292L");
177 Define(Defs, "__LONG_DOUBLE_128__");
Chris Lattner4b009652007-07-25 00:24:17 +0000178}
179
180/// getX86Defines - Return a set of the X86-specific #defines that are
181/// not tied to a specific subtarget.
Chris Lattner0db667a2007-10-06 06:57:34 +0000182static void getX86Defines(std::vector<char> &Defs, bool is64Bit) {
Chris Lattner4b009652007-07-25 00:24:17 +0000183 // Target identification.
184 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000185 Define(Defs, "_LP64");
186 Define(Defs, "__LP64__");
187 Define(Defs, "__amd64__");
188 Define(Defs, "__amd64");
189 Define(Defs, "__x86_64");
190 Define(Defs, "__x86_64__");
Chris Lattner4b009652007-07-25 00:24:17 +0000191 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000192 Define(Defs, "__i386__");
193 Define(Defs, "__i386");
194 Define(Defs, "i386");
Chris Lattner4b009652007-07-25 00:24:17 +0000195 }
196
197 // Target properties.
Chris Lattner0db667a2007-10-06 06:57:34 +0000198 Define(Defs, "__LITTLE_ENDIAN__");
Chris Lattner4b009652007-07-25 00:24:17 +0000199
200 if (is64Bit) {
Chris Lattner0db667a2007-10-06 06:57:34 +0000201 Define(Defs, "__INTMAX_MAX__", "9223372036854775807L");
202 Define(Defs, "__INTMAX_TYPE__", "long int");
203 Define(Defs, "__LONG_MAX__", "9223372036854775807L");
204 Define(Defs, "__PTRDIFF_TYPE__", "long int");
205 Define(Defs, "__UINTMAX_TYPE__", "long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000206 } else {
Chris Lattner0db667a2007-10-06 06:57:34 +0000207 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
208 Define(Defs, "__INTMAX_TYPE__", "long long int");
209 Define(Defs, "__LONG_MAX__", "2147483647L");
210 Define(Defs, "__PTRDIFF_TYPE__", "int");
211 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
Chris Lattner4b009652007-07-25 00:24:17 +0000212 }
Anders Carlsson82b26282008-07-22 17:16:13 +0000213 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
Chris Lattner0db667a2007-10-06 06:57:34 +0000214 Define(Defs, "__CHAR_BIT__", "8");
215 Define(Defs, "__INT_MAX__", "2147483647");
216 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
217 Define(Defs, "__SCHAR_MAX__", "127");
218 Define(Defs, "__SHRT_MAX__", "32767");
Chris Lattner4b009652007-07-25 00:24:17 +0000219
220 // Subtarget options.
Chris Lattner0db667a2007-10-06 06:57:34 +0000221 Define(Defs, "__nocona");
222 Define(Defs, "__nocona__");
223 Define(Defs, "__tune_nocona__");
224 Define(Defs, "__SSE2_MATH__");
225 Define(Defs, "__SSE2__");
226 Define(Defs, "__SSE_MATH__");
227 Define(Defs, "__SSE__");
228 Define(Defs, "__MMX__");
229 Define(Defs, "__REGISTER_PREFIX__", "");
Chris Lattner4b009652007-07-25 00:24:17 +0000230
Chris Lattner0db667a2007-10-06 06:57:34 +0000231 Define(Defs, "__WCHAR_MAX__", "2147483647");
232 Define(Defs, "__WCHAR_TYPE__", "int");
233 Define(Defs, "__WINT_TYPE__", "int");
Chris Lattner4b009652007-07-25 00:24:17 +0000234
235 // Float macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000236 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
237 Define(Defs, "__FLT_DIG__", "6");
238 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
239 Define(Defs, "__FLT_EVAL_METHOD__", "0");
240 Define(Defs, "__FLT_HAS_INFINITY__");
241 Define(Defs, "__FLT_HAS_QUIET_NAN__");
242 Define(Defs, "__FLT_MANT_DIG__", "24");
243 Define(Defs, "__FLT_MAX_10_EXP__", "38");
244 Define(Defs, "__FLT_MAX_EXP__", "128");
245 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
246 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
247 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
248 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
249 Define(Defs, "__FLT_RADIX__", "2");
Chris Lattner4b009652007-07-25 00:24:17 +0000250
251 // Double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000252 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
253 Define(Defs, "__DBL_DIG__", "15");
254 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
255 Define(Defs, "__DBL_HAS_INFINITY__");
256 Define(Defs, "__DBL_HAS_QUIET_NAN__");
257 Define(Defs, "__DBL_MANT_DIG__", "53");
258 Define(Defs, "__DBL_MAX_10_EXP__", "308");
259 Define(Defs, "__DBL_MAX_EXP__", "1024");
260 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
261 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
262 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
263 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
264 Define(Defs, "__DECIMAL_DIG__", "21");
Chris Lattner4b009652007-07-25 00:24:17 +0000265
266 // 80-bit Long double macros.
Chris Lattner0db667a2007-10-06 06:57:34 +0000267 Define(Defs, "__LDBL_DENORM_MIN__", "3.64519953188247460253e-4951L");
268 Define(Defs, "__LDBL_DIG__", "18");
269 Define(Defs, "__LDBL_EPSILON__", "1.08420217248550443401e-19L");
270 Define(Defs, "__LDBL_HAS_INFINITY__");
271 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
272 Define(Defs, "__LDBL_MANT_DIG__", "64");
273 Define(Defs, "__LDBL_MAX_10_EXP__", "4932");
274 Define(Defs, "__LDBL_MAX_EXP__", "16384");
275 Define(Defs, "__LDBL_MAX__", "1.18973149535723176502e+4932L");
276 Define(Defs, "__LDBL_MIN_10_EXP__", "(-4931)");
277 Define(Defs, "__LDBL_MIN_EXP__", "(-16381)");
278 Define(Defs, "__LDBL_MIN__", "3.36210314311209350626e-4932L");
Chris Lattner4b009652007-07-25 00:24:17 +0000279}
280
Chris Lattnerb6444052008-04-21 20:19:54 +0000281/// getARMDefines - Return a set of the ARM-specific #defines that are
Chris Lattner9fd73612008-04-21 18:56:49 +0000282/// not tied to a specific subtarget.
283static void getARMDefines(std::vector<char> &Defs) {
284 // Target identification.
285 Define(Defs, "__arm");
286 Define(Defs, "__arm__");
287
288 // Target properties.
289 Define(Defs, "__LITTLE_ENDIAN__");
290
291 Define(Defs, "__INTMAX_MAX__", "9223372036854775807LL");
292 Define(Defs, "__INTMAX_TYPE__", "long long int");
293 Define(Defs, "__LONG_MAX__", "2147483647L");
294 Define(Defs, "__PTRDIFF_TYPE__", "int");
295 Define(Defs, "__UINTMAX_TYPE__", "long long unsigned int");
296 Define(Defs, "__SIZE_TYPE__", "long unsigned int");
297
298 Define(Defs, "__CHAR_BIT__", "8");
299 Define(Defs, "__INT_MAX__", "2147483647");
300 Define(Defs, "__LONG_LONG_MAX__", "9223372036854775807LL");
301 Define(Defs, "__SCHAR_MAX__", "127");
302 Define(Defs, "__SHRT_MAX__", "32767");
303
304 // Subtarget options. [hard coded to v6 for now]
305 Define(Defs, "__ARM_ARCH_6K__");
306 Define(Defs, "__ARMEL__");
307 Define(Defs, "__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", "20000");
308
309 Define(Defs, "__WCHAR_MAX__", "2147483647");
310 Define(Defs, "__WCHAR_TYPE__", "int");
311 Define(Defs, "__WINT_TYPE__", "int");
312 Define(Defs, "__DECIMAL_DIG__", "17");
313 Define(Defs, "__FLT_RADIX__", "2");
314
315 // Float macros.
316 Define(Defs, "__FLT_DENORM_MIN__", "1.40129846e-45F");
317 Define(Defs, "__FLT_DIG__", "6");
318 Define(Defs, "__FLT_EPSILON__", "1.19209290e-7F");
319 Define(Defs, "__FLT_EVAL_METHOD__", "0");
320 Define(Defs, "__FLT_HAS_INFINITY__");
321 Define(Defs, "__FLT_HAS_QUIET_NAN__");
322 Define(Defs, "__FLT_MANT_DIG__", "24");
323 Define(Defs, "__FLT_MAX_10_EXP__", "38");
324 Define(Defs, "__FLT_MAX_EXP__", "128");
325 Define(Defs, "__FLT_MAX__", "3.40282347e+38F");
326 Define(Defs, "__FLT_MIN_10_EXP__", "(-37)");
327 Define(Defs, "__FLT_MIN_EXP__", "(-125)");
328 Define(Defs, "__FLT_MIN__", "1.17549435e-38F");
329
330 // Double macros.
331 Define(Defs, "__DBL_DENORM_MIN__", "4.9406564584124654e-324");
332 Define(Defs, "__DBL_DIG__", "15");
333 Define(Defs, "__DBL_EPSILON__", "2.2204460492503131e-16");
334 Define(Defs, "__DBL_HAS_INFINITY__");
335 Define(Defs, "__DBL_HAS_QUIET_NAN__");
336 Define(Defs, "__DBL_MANT_DIG__", "53");
337 Define(Defs, "__DBL_MAX_10_EXP__", "308");
338 Define(Defs, "__DBL_MAX_EXP__", "1024");
339 Define(Defs, "__DBL_MAX__", "1.7976931348623157e+308");
340 Define(Defs, "__DBL_MIN_10_EXP__", "(-307)");
341 Define(Defs, "__DBL_MIN_EXP__", "(-1021)");
342 Define(Defs, "__DBL_MIN__", "2.2250738585072014e-308");
343
344 // 64-bit Long double macros (same as double).
345 Define(Defs, "__LDBL_DENORM_MIN__", "4.9406564584124654e-324");
346 Define(Defs, "__LDBL_DIG__", "15");
347 Define(Defs, "__LDBL_EPSILON__", "2.2204460492503131e-16");
348 Define(Defs, "__LDBL_HAS_INFINITY__");
349 Define(Defs, "__LDBL_HAS_QUIET_NAN__");
350 Define(Defs, "__LDBL_MANT_DIG__", "53");
351 Define(Defs, "__LDBL_MAX_10_EXP__", "308");
352 Define(Defs, "__LDBL_MAX_EXP__", "1024");
353 Define(Defs, "__LDBL_MAX__", "1.7976931348623157e+308");
354 Define(Defs, "__LDBL_MIN_10_EXP__", "(-307)");
355 Define(Defs, "__LDBL_MIN_EXP__", "(-1021)");
356 Define(Defs, "__LDBL_MIN__", "2.2250738585072014e-308");
357}
358
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000359static const char* getI386VAListDeclaration() {
360 return "typedef char* __builtin_va_list;";
361}
362
363static const char* getX86_64VAListDeclaration() {
364 return
365 "typedef struct __va_list_tag {"
366 " unsigned gp_offset;"
367 " unsigned fp_offset;"
368 " void* overflow_arg_area;"
369 " void* reg_save_area;"
370 "} __builtin_va_list[1];";
371}
372
373static const char* getPPCVAListDeclaration() {
374 return
375 "typedef struct __va_list_tag {"
376 " unsigned char gpr;"
377 " unsigned char fpr;"
378 " unsigned short reserved;"
379 " void* overflow_arg_area;"
380 " void* reg_save_area;"
381 "} __builtin_va_list[1];";
382}
383
Chris Lattner9fd73612008-04-21 18:56:49 +0000384static const char* getARMVAListDeclaration() {
385 return "typedef char* __builtin_va_list;";
386}
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000387
Chris Lattner4b009652007-07-25 00:24:17 +0000388/// PPC builtin info.
Chris Lattner9a3dedf2007-12-11 04:36:28 +0000389namespace clang {
Chris Lattner4b009652007-07-25 00:24:17 +0000390namespace PPC {
Chris Lattner4b009652007-07-25 00:24:17 +0000391
392 static const Builtin::Info BuiltinInfo[] = {
393#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
Anders Carlssone1449c12007-12-09 23:17:02 +0000394#include "clang/AST/PPCBuiltins.def"
Chris Lattner4b009652007-07-25 00:24:17 +0000395 };
396
397 static void getBuiltins(const Builtin::Info *&Records, unsigned &NumRecords) {
398 Records = BuiltinInfo;
399 NumRecords = LastTSBuiltin-Builtin::FirstTSBuiltin;
400 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000401
402 static const char * const GCCRegNames[] = {
403 "0", "1", "2", "3", "4", "5", "6", "7",
404 "8", "9", "10", "11", "12", "13", "14", "15",
405 "16", "17", "18", "19", "20", "21", "22", "23",
406 "24", "25", "26", "27", "28", "29", "30", "31",
407 "0", "1", "2", "3", "4", "5", "6", "7",
408 "8", "9", "10", "11", "12", "13", "14", "15",
409 "16", "17", "18", "19", "20", "21", "22", "23",
410 "24", "25", "26", "27", "28", "29", "30", "31",
411 "mq", "lr", "ctr", "ap",
412 "0", "1", "2", "3", "4", "5", "6", "7",
413 "xer",
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 "vrsave", "vscr",
419 "spe_acc", "spefscr",
420 "sfp"
421 };
422
423 static void getGCCRegNames(const char * const *&Names,
424 unsigned &NumNames) {
425 Names = GCCRegNames;
426 NumNames = llvm::array_lengthof(GCCRegNames);
427 }
428
Chris Lattner0fb8d852008-03-08 08:24:01 +0000429 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000430 // While some of these aliases do map to different registers
431 // they still share the same register name.
432 { { "cc", "cr0", "fr0", "r0", "v0"}, "0" },
433 { { "cr1", "fr1", "r1", "sp", "v1"}, "1" },
434 { { "cr2", "fr2", "r2", "toc", "v2"}, "2" },
435 { { "cr3", "fr3", "r3", "v3"}, "3" },
436 { { "cr4", "fr4", "r4", "v4"}, "4" },
437 { { "cr5", "fr5", "r5", "v5"}, "5" },
438 { { "cr6", "fr6", "r6", "v6"}, "6" },
439 { { "cr7", "fr7", "r7", "v7"}, "7" },
440 { { "fr8", "r8", "v8"}, "8" },
441 { { "fr9", "r9", "v9"}, "9" },
442 { { "fr10", "r10", "v10"}, "10" },
443 { { "fr11", "r11", "v11"}, "11" },
444 { { "fr12", "r12", "v12"}, "12" },
445 { { "fr13", "r13", "v13"}, "13" },
446 { { "fr14", "r14", "v14"}, "14" },
447 { { "fr15", "r15", "v15"}, "15" },
448 { { "fr16", "r16", "v16"}, "16" },
449 { { "fr17", "r17", "v17"}, "17" },
450 { { "fr18", "r18", "v18"}, "18" },
451 { { "fr19", "r19", "v19"}, "19" },
452 { { "fr20", "r20", "v20"}, "20" },
453 { { "fr21", "r21", "v21"}, "21" },
454 { { "fr22", "r22", "v22"}, "22" },
455 { { "fr23", "r23", "v23"}, "23" },
456 { { "fr24", "r24", "v24"}, "24" },
457 { { "fr25", "r25", "v25"}, "25" },
458 { { "fr26", "r26", "v26"}, "26" },
459 { { "fr27", "r27", "v27"}, "27" },
460 { { "fr28", "r28", "v28"}, "28" },
461 { { "fr29", "r29", "v29"}, "29" },
462 { { "fr30", "r30", "v30"}, "30" },
463 { { "fr31", "r31", "v31"}, "31" },
464 };
465
Chris Lattner0fb8d852008-03-08 08:24:01 +0000466 static void getGCCRegAliases(const TargetInfo::GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000467 unsigned &NumAliases) {
468 Aliases = GCCRegAliases;
469 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson4ce42302007-11-27 04:11:28 +0000470 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000471
Anders Carlsson4ce42302007-11-27 04:11:28 +0000472 static bool validateAsmConstraint(char c,
473 TargetInfo::ConstraintInfo &info) {
474 switch (c) {
475 default: return false;
476 case 'O': // Zero
477 return true;
478 case 'b': // Base register
479 case 'f': // Floating point register
480 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
481 return true;
482 }
483 }
484
485 const char *getClobbers() {
486 return 0;
487 }
488
Anders Carlsson333052c2007-12-08 19:32:57 +0000489 const char *getTargetPrefix() {
490 return "ppc";
491 }
492
Chris Lattner4b009652007-07-25 00:24:17 +0000493} // End namespace PPC
494
Chris Lattner4b009652007-07-25 00:24:17 +0000495/// X86 builtin info.
496namespace X86 {
Chris Lattner4b009652007-07-25 00:24:17 +0000497 static const Builtin::Info BuiltinInfo[] = {
498#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS },
Anders Carlssone1449c12007-12-09 23:17:02 +0000499#include "clang/AST/X86Builtins.def"
Chris Lattner4b009652007-07-25 00:24:17 +0000500 };
501
502 static void getBuiltins(const Builtin::Info *&Records, unsigned &NumRecords) {
503 Records = BuiltinInfo;
504 NumRecords = LastTSBuiltin-Builtin::FirstTSBuiltin;
505 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000506
507 static const char *GCCRegNames[] = {
508 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
509 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Anders Carlssonc411b492007-11-25 00:23:10 +0000510 "argp", "flags", "fspr", "dirflag", "frame",
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000511 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
512 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
513 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
514 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
515 };
516
517 static void getGCCRegNames(const char * const *&Names,
518 unsigned &NumNames) {
519 Names = GCCRegNames;
520 NumNames = llvm::array_lengthof(GCCRegNames);
521 }
522
Chris Lattner0fb8d852008-03-08 08:24:01 +0000523 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000524 { { "al", "ah", "eax", "rax" }, "ax" },
525 { { "bl", "bh", "ebx", "rbx" }, "bx" },
526 { { "cl", "ch", "ecx", "rcx" }, "cx" },
527 { { "dl", "dh", "edx", "rdx" }, "dx" },
528 { { "esi", "rsi" }, "si" },
Nuno Lopesfd7bf3a2008-07-07 12:18:07 +0000529 { { "edi", "rdi" }, "di" },
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000530 { { "esp", "rsp" }, "sp" },
531 { { "ebp", "rbp" }, "bp" },
532 };
533
Chris Lattner0fb8d852008-03-08 08:24:01 +0000534 static void getGCCRegAliases(const TargetInfo::GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000535 unsigned &NumAliases) {
536 Aliases = GCCRegAliases;
537 NumAliases = llvm::array_lengthof(GCCRegAliases);
538 }
539
Anders Carlsson4ce42302007-11-27 04:11:28 +0000540 static bool validateAsmConstraint(char c,
541 TargetInfo::ConstraintInfo &info) {
542 switch (c) {
543 default: return false;
544 case 'a': // eax.
545 case 'b': // ebx.
546 case 'c': // ecx.
547 case 'd': // edx.
548 case 'S': // esi.
549 case 'D': // edi.
550 case 'A': // edx:eax.
551 case 't': // top of floating point stack.
552 case 'u': // second from top of floating point stack.
553 case 'q': // a, b, c, d registers or any integer register in 64-bit.
Anders Carlssonae77fa02008-03-10 22:37:16 +0000554 case 'Z': // 32-bit integer constant for use with zero-extending x86_64
555 // instructions.
556 case 'N': // unsigned 8-bit integer constant for use with in and out
Anders Carlssonf8e50d92008-02-18 17:00:25 +0000557 // instructions.
Anders Carlsson4ce42302007-11-27 04:11:28 +0000558 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
559 return true;
560 }
561 }
562
Lauro Ramos Venanciobb37a042008-02-26 18:33:46 +0000563 static std::string convertConstraint(const char Constraint) {
564 switch (Constraint) {
565 case 'a': return std::string("{ax}");
566 case 'b': return std::string("{bx}");
567 case 'c': return std::string("{cx}");
568 case 'd': return std::string("{dx}");
569 case 'S': return std::string("{si}");
570 case 'D': return std::string("{di}");
571 case 't': // top of floating point stack.
572 return std::string("{st}");
573 case 'u': // second from top of floating point stack.
574 return std::string("{st(1)}"); // second from top of floating point stack.
Lauro Ramos Venanciobb37a042008-02-26 18:33:46 +0000575 default:
576 return std::string(1, Constraint);
577 }
578 }
579
Anders Carlsson4ce42302007-11-27 04:11:28 +0000580 const char *getClobbers() {
581 return "~{dirflag},~{fpsr},~{flags}";
582 }
583
Anders Carlsson333052c2007-12-08 19:32:57 +0000584 const char *getTargetPrefix() {
585 return "x86";
586 }
587
Chris Lattner4b009652007-07-25 00:24:17 +0000588} // End namespace X86
Chris Lattner9fd73612008-04-21 18:56:49 +0000589
590
591/// ARM builtin info.
592namespace ARM {
593 const char *getTargetPrefix() {
594 return "arm";
595 }
596} // End namespace ARM
597
Chris Lattner9a3dedf2007-12-11 04:36:28 +0000598} // end namespace clang.
Chris Lattner4b009652007-07-25 00:24:17 +0000599
600//===----------------------------------------------------------------------===//
601// Specific target implementations.
602//===----------------------------------------------------------------------===//
603
604
605namespace {
606class DarwinPPCTargetInfo : public DarwinTargetInfo {
607public:
Eli Friedman2fde2a52008-05-20 14:25:01 +0000608 DarwinPPCTargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
609 CharIsSigned = false;
610 }
Ted Kremenek40499482007-12-03 22:06:55 +0000611
Chris Lattner0db667a2007-10-06 06:57:34 +0000612 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000613 DarwinTargetInfo::getTargetDefines(Defines);
614 getPowerPCDefines(Defines, false);
615 }
616 virtual void getTargetBuiltins(const Builtin::Info *&Records,
617 unsigned &NumRecords) const {
618 PPC::getBuiltins(Records, NumRecords);
619 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000620 virtual const char *getVAListDeclaration() const {
621 return getPPCVAListDeclaration();
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000622 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000623 virtual const char *getTargetPrefix() const {
624 return PPC::getTargetPrefix();
625 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000626 virtual void getGCCRegNames(const char * const *&Names,
627 unsigned &NumNames) const {
628 PPC::getGCCRegNames(Names, NumNames);
629 }
630 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
631 unsigned &NumAliases) const {
632 PPC::getGCCRegAliases(Aliases, NumAliases);
633 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000634 virtual bool validateAsmConstraint(char c,
635 TargetInfo::ConstraintInfo &info) const {
636 return PPC::validateAsmConstraint(c, info);
637 }
638 virtual const char *getClobbers() const {
639 return PPC::getClobbers();
640 }
Chris Lattner4b009652007-07-25 00:24:17 +0000641};
642} // end anonymous namespace.
643
644namespace {
645class DarwinPPC64TargetInfo : public DarwinTargetInfo {
646public:
Chris Lattnere5fde952008-05-09 06:17:04 +0000647 DarwinPPC64TargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
Eli Friedman2fde2a52008-05-20 14:25:01 +0000648 CharIsSigned = false;
Chris Lattnere5fde952008-05-09 06:17:04 +0000649 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
650 }
Ted Kremenek40499482007-12-03 22:06:55 +0000651
Chris Lattner0db667a2007-10-06 06:57:34 +0000652 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000653 DarwinTargetInfo::getTargetDefines(Defines);
654 getPowerPCDefines(Defines, true);
655 }
656 virtual void getTargetBuiltins(const Builtin::Info *&Records,
657 unsigned &NumRecords) const {
658 PPC::getBuiltins(Records, NumRecords);
659 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000660 virtual const char *getVAListDeclaration() const {
661 return getPPCVAListDeclaration();
662 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000663 virtual const char *getTargetPrefix() const {
664 return PPC::getTargetPrefix();
665 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000666 virtual void getGCCRegNames(const char * const *&Names,
667 unsigned &NumNames) const {
668 PPC::getGCCRegNames(Names, NumNames);
669 }
670 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
671 unsigned &NumAliases) const {
672 PPC::getGCCRegAliases(Aliases, NumAliases);
673 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000674 virtual bool validateAsmConstraint(char c,
675 TargetInfo::ConstraintInfo &info) const {
676 return PPC::validateAsmConstraint(c, info);
677 }
678 virtual const char *getClobbers() const {
679 return PPC::getClobbers();
680 }
Chris Lattner4b009652007-07-25 00:24:17 +0000681};
682} // end anonymous namespace.
683
684namespace {
685class DarwinI386TargetInfo : public DarwinTargetInfo {
686public:
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000687 DarwinI386TargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
688 DoubleAlign = LongLongAlign = 32;
Eli Friedman4a712852008-06-04 17:01:45 +0000689 LongDoubleWidth = 128;
690 LongDoubleAlign = 128;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000691 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
692 }
693
Chris Lattner0db667a2007-10-06 06:57:34 +0000694 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000695 DarwinTargetInfo::getTargetDefines(Defines);
696 getX86Defines(Defines, false);
697 }
698 virtual void getTargetBuiltins(const Builtin::Info *&Records,
699 unsigned &NumRecords) const {
700 X86::getBuiltins(Records, NumRecords);
701 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000702 virtual const char *getVAListDeclaration() const {
703 return getI386VAListDeclaration();
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000704 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000705 virtual const char *getTargetPrefix() const {
706 return X86::getTargetPrefix();
707 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000708 virtual void getGCCRegNames(const char * const *&Names,
709 unsigned &NumNames) const {
710 X86::getGCCRegNames(Names, NumNames);
711 }
712 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
713 unsigned &NumAliases) const {
714 X86::getGCCRegAliases(Aliases, NumAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000715 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000716 virtual bool validateAsmConstraint(char c,
717 TargetInfo::ConstraintInfo &info) const {
718 return X86::validateAsmConstraint(c, info);
719 }
Lauro Ramos Venanciobb37a042008-02-26 18:33:46 +0000720
721 virtual std::string convertConstraint(const char Constraint) const {
722 return X86::convertConstraint(Constraint);
723 }
724
Anders Carlsson4ce42302007-11-27 04:11:28 +0000725 virtual const char *getClobbers() const {
726 return X86::getClobbers();
727 }
Chris Lattner4b009652007-07-25 00:24:17 +0000728};
729} // end anonymous namespace.
730
731namespace {
732class DarwinX86_64TargetInfo : public DarwinTargetInfo {
733public:
Chris Lattnere5fde952008-05-09 06:17:04 +0000734 DarwinX86_64TargetInfo(const std::string& triple) : DarwinTargetInfo(triple) {
735 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000736 LongDoubleWidth = 128;
737 LongDoubleAlign = 128;
738 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattnere5fde952008-05-09 06:17:04 +0000739 }
Ted Kremenek40499482007-12-03 22:06:55 +0000740
Chris Lattner0db667a2007-10-06 06:57:34 +0000741 virtual void getTargetDefines(std::vector<char> &Defines) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000742 DarwinTargetInfo::getTargetDefines(Defines);
743 getX86Defines(Defines, true);
744 }
745 virtual void getTargetBuiltins(const Builtin::Info *&Records,
746 unsigned &NumRecords) const {
747 X86::getBuiltins(Records, NumRecords);
748 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000749 virtual const char *getVAListDeclaration() const {
750 return getX86_64VAListDeclaration();
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000751 }
Anders Carlsson333052c2007-12-08 19:32:57 +0000752 virtual const char *getTargetPrefix() const {
753 return X86::getTargetPrefix();
754 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000755 virtual void getGCCRegNames(const char * const *&Names,
756 unsigned &NumNames) const {
757 X86::getGCCRegNames(Names, NumNames);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000758 }
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000759 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
760 unsigned &NumAliases) const {
761 X86::getGCCRegAliases(Aliases, NumAliases);
762 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000763 virtual bool validateAsmConstraint(char c,
764 TargetInfo::ConstraintInfo &info) const {
765 return X86::validateAsmConstraint(c, info);
Lauro Ramos Venanciobb37a042008-02-26 18:33:46 +0000766 }
767 virtual std::string convertConstraint(const char Constraint) const {
768 return X86::convertConstraint(Constraint);
769 }
Anders Carlsson4ce42302007-11-27 04:11:28 +0000770 virtual const char *getClobbers() const {
771 return X86::getClobbers();
772 }
Chris Lattner4b009652007-07-25 00:24:17 +0000773};
774} // end anonymous namespace.
775
Chris Lattner9fd73612008-04-21 18:56:49 +0000776
777namespace {
778class DarwinARMTargetInfo : public DarwinTargetInfo {
779public:
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000780 DarwinARMTargetInfo(const std::string& triple) :DarwinTargetInfo(triple) {
781 // FIXME: Are the defaults corrent for ARM?
782 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000783
784 virtual void getTargetDefines(std::vector<char> &Defines) const {
785 DarwinTargetInfo::getTargetDefines(Defines);
786 getARMDefines(Defines);
787 }
788 virtual void getTargetBuiltins(const Builtin::Info *&Records,
789 unsigned &NumRecords) const {
790 NumRecords = 0;
791 }
792 virtual const char *getVAListDeclaration() const {
793 return getARMVAListDeclaration();
794 }
795 virtual const char *getTargetPrefix() const {
796 return ARM::getTargetPrefix();
797 }
798
799 virtual void getGCCRegNames(const char * const *&Names,
800 unsigned &NumNames) const {
801 NumNames = 0;
802 }
803 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
804 unsigned &NumAliases) const {
805 NumAliases = 0;
806 }
807 virtual bool validateAsmConstraint(char c,
Nate Begeman222823a2008-04-22 05:03:19 +0000808 TargetInfo::ConstraintInfo &info) const {
809 switch (c) {
810 default:
811 case 'l': // r0-r7
812 case 'h': // r8-r15
813 case 'w': // VFP Floating point register single precision
814 case 'P': // VFP Floating point register double precision
815 info = (TargetInfo::ConstraintInfo)(info|TargetInfo::CI_AllowsRegister);
816 return true;
817 }
Chris Lattner9fd73612008-04-21 18:56:49 +0000818 return false;
819 }
820 virtual const char *getClobbers() const {
821 return "";
822 }
823};
824} // end anonymous namespace.
825
Chris Lattner4b009652007-07-25 00:24:17 +0000826namespace {
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000827class SolarisSparcV8TargetInfo : public SolarisTargetInfo {
828public:
829 SolarisSparcV8TargetInfo(const std::string& triple) : SolarisTargetInfo(triple) {}
830
831 virtual void getTargetDefines(std::vector<char> &Defines) const {
832 SolarisTargetInfo::getTargetDefines(Defines);
833// getSparcDefines(Defines, false);
834 Define(Defines, "__sparc");
Eli Friedman1dee5c52008-05-25 05:26:09 +0000835 Define(Defines, "__sparc__");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +0000836 Define(Defines, "__sparcv8");
837 }
838 virtual void getTargetBuiltins(const Builtin::Info *&Records,
839 unsigned &NumRecords) const {
840 PPC::getBuiltins(Records, NumRecords);
841 }
842 virtual const char *getVAListDeclaration() const {
843 return getPPCVAListDeclaration();
844 }
845 virtual const char *getTargetPrefix() const {
846 return PPC::getTargetPrefix();
847 }
848 virtual void getGCCRegNames(const char * const *&Names,
849 unsigned &NumNames) const {
850 PPC::getGCCRegNames(Names, NumNames);
851 }
852 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
853 unsigned &NumAliases) const {
854 PPC::getGCCRegAliases(Aliases, NumAliases);
855 }
856 virtual bool validateAsmConstraint(char c,
857 TargetInfo::ConstraintInfo &info) const {
858 return PPC::validateAsmConstraint(c, info);
859 }
860 virtual const char *getClobbers() const {
861 return PPC::getClobbers();
862 }
863};
864
865} // end anonymous namespace.
866
Chris Lattner4b009652007-07-25 00:24:17 +0000867
Chris Lattner85970f32008-05-08 05:58:21 +0000868namespace {
869 class PIC16TargetInfo : public TargetInfo{
870 public:
871 PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000872 // FIXME: Is IntAlign really supposed to be 16? There seems
873 // little point on a platform with 8-bit loads.
874 IntWidth = IntAlign = LongAlign = LongLongAlign = PointerWidth = 16;
875 PointerAlign = 8;
Sanjiv Guptaebd8f0f2008-08-18 10:05:22 +0000876 DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8";
Chris Lattner85970f32008-05-08 05:58:21 +0000877 }
Chris Lattner727b3c42008-05-09 06:08:39 +0000878 virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
879 virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
Chris Lattner85970f32008-05-08 05:58:21 +0000880 virtual void getTargetDefines(std::vector<char> &Defines) const {
881 Define(Defines, "__pic16");
882 }
883 virtual void getTargetBuiltins(const Builtin::Info *&Records,
884 unsigned &NumRecords) const {}
885 virtual const char *getVAListDeclaration() const { return "";}
886 virtual const char *getClobbers() const {return "";}
887 virtual const char *getTargetPrefix() const {return "";}
888 virtual void getGCCRegNames(const char * const *&Names,
889 unsigned &NumNames) const {}
890 virtual bool validateAsmConstraint(char c,
891 TargetInfo::ConstraintInfo &info) const {
892 return true;
893 }
894 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
895 unsigned &NumAliases) const {}
896 virtual bool useGlobalsForAutomaticVariables() const {return true;}
897 };
898}
899
Chris Lattner4b009652007-07-25 00:24:17 +0000900//===----------------------------------------------------------------------===//
901// Driver code
902//===----------------------------------------------------------------------===//
903
Ted Kremenekb97d7672007-12-04 17:07:35 +0000904static inline bool IsX86(const std::string& TT) {
Ted Kremenek40499482007-12-03 22:06:55 +0000905 return (TT.size() >= 5 && TT[0] == 'i' && TT[2] == '8' && TT[3] == '6' &&
906 TT[4] == '-' && TT[1] - '3' < 6);
907}
908
Chris Lattnerfc457002008-03-05 01:18:20 +0000909/// CreateTargetInfo - Return the target info object for the specified target
910/// triple.
911TargetInfo* TargetInfo::CreateTargetInfo(const std::string &T) {
Chris Lattner2c63b9f2007-12-05 18:41:05 +0000912 if (T.find("ppc-") == 0 || T.find("powerpc-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000913 return new DarwinPPCTargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000914
Chris Lattnerfc457002008-03-05 01:18:20 +0000915 if (T.find("ppc64-") == 0 || T.find("powerpc64-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000916 return new DarwinPPC64TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000917
Chris Lattner9fd73612008-04-21 18:56:49 +0000918 if (T.find("armv6-") == 0 || T.find("arm-") == 0)
919 return new DarwinARMTargetInfo(T);
920
Chris Lattnerfc457002008-03-05 01:18:20 +0000921 if (T.find("sparc-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000922 return new SolarisSparcV8TargetInfo(T); // ugly hack
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000923
Chris Lattnerfc457002008-03-05 01:18:20 +0000924 if (T.find("x86_64-") == 0)
Chris Lattner0fb8d852008-03-08 08:24:01 +0000925 return new DarwinX86_64TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000926
Chris Lattner85970f32008-05-08 05:58:21 +0000927 if (T.find("pic16-") == 0)
928 return new PIC16TargetInfo(T);
929
Chris Lattnerfc457002008-03-05 01:18:20 +0000930 if (IsX86(T))
Chris Lattner0fb8d852008-03-08 08:24:01 +0000931 return new DarwinI386TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000932
Chris Lattnerfc457002008-03-05 01:18:20 +0000933 return NULL;
Chris Lattner4b009652007-07-25 00:24:17 +0000934}
Ted Kremenekd507bab2008-03-04 17:47:18 +0000935