 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
39.3% |
286 / 728 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
60.3% |
439 / 728 |
| |
|
Line Coverage: |
63.9% |
651 / 1018 |
| |
 |
|
 |
1 : //===--- Targets.cpp - Implement -arch option and targets -----------------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This file implements construction of a TargetInfo object from a
11 : // target triple.
12 : //
13 : //===----------------------------------------------------------------------===//
14 :
15 : #include "clang/Basic/TargetInfo.h"
16 : #include "clang/Basic/Builtins.h"
17 : #include "clang/Basic/Diagnostic.h"
18 : #include "clang/Basic/LangOptions.h"
19 : #include "clang/Basic/MacroBuilder.h"
20 : #include "clang/Basic/TargetBuiltins.h"
21 : #include "clang/Basic/TargetOptions.h"
22 : #include "llvm/ADT/APFloat.h"
23 : #include "llvm/ADT/OwningPtr.h"
24 : #include "llvm/ADT/STLExtras.h"
25 : #include "llvm/ADT/StringRef.h"
26 : #include "llvm/ADT/StringSwitch.h"
27 : #include "llvm/ADT/Triple.h"
28 : #include "llvm/MC/MCSectionMachO.h"
29 : #include <algorithm>
30 : using namespace clang;
31 :
32 : //===----------------------------------------------------------------------===//
33 : // Common code shared among targets.
34 : //===----------------------------------------------------------------------===//
35 :
36 : /// DefineStd - Define a macro name and standard variants. For example if
37 : /// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
38 : /// when in GNU mode.
39 : static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
40 6479: const LangOptions &Opts) {
6479: branch 1 taken
0: branch 2 not taken
41 6479: assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
42 :
43 : // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
44 : // in the user's namespace.
6112: branch 0 taken
367: branch 1 taken
45 6479: if (Opts.GNUMode)
46 6112: Builder.defineMacro(MacroName);
47 :
48 : // Define __unix.
49 6479: Builder.defineMacro("__" + MacroName);
50 :
51 : // Define __unix__.
52 6479: Builder.defineMacro("__" + MacroName + "__");
53 6479: }
54 :
55 : //===----------------------------------------------------------------------===//
56 : // Defines specific to certain operating systems.
57 : //===----------------------------------------------------------------------===//
58 :
59 : namespace {
60 : template<typename TgtInfo>
0: branch 1 not taken
7: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 29 not taken
0: branch 30 not taken
0: branch 33 not taken
0: branch 34 not taken
0: branch 37 not taken
2: branch 38 taken
0: branch 41 not taken
0: branch 42 not taken
0: branch 45 not taken
0: branch 46 not taken
0: branch 49 not taken
1: branch 50 taken
0: branch 53 not taken
0: branch 54 not taken
0: branch 57 not taken
0: branch 58 not taken
0: branch 61 not taken
1: branch 62 taken
0: branch 65 not taken
0: branch 66 not taken
0: branch 69 not taken
0: branch 70 not taken
0: branch 73 not taken
2221: branch 74 taken
0: branch 77 not taken
0: branch 78 not taken
0: branch 81 not taken
0: branch 82 not taken
0: branch 85 not taken
175: branch 86 taken
0: branch 89 not taken
0: branch 90 not taken
0: branch 93 not taken
0: branch 94 not taken
61 2407: class OSTargetInfo : public TgtInfo {
62 : protected:
63 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
64 : MacroBuilder &Builder) const=0;
65 : public:
66 2410: OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
67 : virtual void getTargetDefines(const LangOptions &Opts,
68 2394: MacroBuilder &Builder) const {
69 2394: TgtInfo::getTargetDefines(Opts, Builder);
70 2394: getOSDefines(Opts, TgtInfo::getTriple(), Builder);
71 2394: }
72 :
73 : };
74 : } // end anonymous namespace
75 :
76 :
77 : static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
78 300: const llvm::Triple &Triple) {
79 300: Builder.defineMacro("__APPLE_CC__", "5621");
80 300: Builder.defineMacro("__APPLE__");
81 300: Builder.defineMacro("__MACH__");
82 300: Builder.defineMacro("OBJC_NEW_PROPERTIES");
83 :
84 : // __weak is always defined, for use in blocks and with objc pointers.
85 300: Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
86 :
87 : // Darwin defines __strong even in C mode (just to nothing).
125: branch 0 taken
175: branch 1 taken
95: branch 3 taken
30: branch 4 taken
270: branch 5 taken
30: branch 6 taken
88 300: if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
89 270: Builder.defineMacro("__strong", "");
90 : else
91 30: Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
92 :
0: branch 0 not taken
300: branch 1 taken
93 300: if (Opts.Static)
94 0: Builder.defineMacro("__STATIC__");
95 : else
96 300: Builder.defineMacro("__DYNAMIC__");
97 :
0: branch 0 not taken
300: branch 1 taken
98 300: if (Opts.POSIXThreads)
99 0: Builder.defineMacro("_REENTRANT");
100 :
101 : // Get the OS version number from the triple.
102 : unsigned Maj, Min, Rev;
103 :
104 : // If no version was given, default to to 10.4.0, for simplifying tests.
52: branch 3 taken
248: branch 4 taken
105 300: if (Triple.getOSName() == "darwin") {
106 52: Min = Rev = 0;
107 52: Maj = 8;
108 : } else
109 248: Triple.getDarwinNumber(Maj, Min, Rev);
110 :
111 : // Set the appropriate OS version define.
6: branch 3 taken
294: branch 4 taken
112 300: if (Triple.getEnvironmentName() == "iphoneos") {
6: branch 0 taken
0: branch 1 not taken
6: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
6: branch 5 taken
113 6: assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
114 : char Str[6];
115 6: Str[0] = '0' + Maj;
116 6: Str[1] = '0' + (Min / 10);
117 6: Str[2] = '0' + (Min % 10);
118 6: Str[3] = '0' + (Rev / 10);
119 6: Str[4] = '0' + (Rev % 10);
120 6: Str[5] = '\0';
121 6: Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
122 : } else {
123 : // For historical reasons that make little sense, the version passed here is
124 : // the "darwin" version, which drops the 10 and offsets by 4.
125 294: Rev = Min;
126 294: Min = Maj - 4;
127 294: Maj = 10;
128 :
294: branch 2 taken
0: branch 3 not taken
129 294: assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
294: branch 0 taken
0: branch 1 not taken
294: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
294: branch 5 taken
130 588: assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
131 : char Str[5];
132 294: Str[0] = '0' + (Maj / 10);
133 294: Str[1] = '0' + (Maj % 10);
134 294: Str[2] = '0' + Min;
135 294: Str[3] = '0' + Rev;
136 294: Str[4] = '\0';
137 294: Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
138 : }
139 300: }
140 :
141 : namespace {
142 : template<typename Target>
0: branch 1 not taken
7: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
2: branch 13 taken
0: branch 14 not taken
0: branch 17 not taken
0: branch 18 not taken
1: branch 21 taken
0: branch 22 not taken
0: branch 25 not taken
0: branch 26 not taken
0: branch 29 not taken
126: branch 30 taken
0: branch 33 not taken
0: branch 34 not taken
0: branch 37 not taken
0: branch 38 not taken
0: branch 41 not taken
167: branch 42 taken
0: branch 45 not taken
0: branch 46 not taken
0: branch 49 not taken
0: branch 50 not taken
143 303: class DarwinTargetInfo : public OSTargetInfo<Target> {
144 : protected:
145 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
146 293: MacroBuilder &Builder) const {
147 293: getDarwinDefines(Builder, Opts, Triple);
148 293: }
149 :
150 : public:
151 306: DarwinTargetInfo(const std::string& triple) :
152 306: OSTargetInfo<Target>(triple) {
153 306: this->TLSSupported = false;
154 306: }
155 :
156 7: virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
157 : // Let MCSectionMachO validate this.
158 7: llvm::StringRef Segment, Section;
159 : unsigned TAA, StubSize;
160 : return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
161 7: TAA, StubSize);
162 : }
163 : };
164 :
165 :
166 : // DragonFlyBSD Target
167 : template<typename Target>
1: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
168 1: class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
169 : protected:
170 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
171 1: MacroBuilder &Builder) const {
172 : // DragonFly defines; list based off of gcc output
173 1: Builder.defineMacro("__DragonFly__");
174 1: Builder.defineMacro("__DragonFly_cc_version", "100001");
175 1: Builder.defineMacro("__ELF__");
176 1: Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
177 1: Builder.defineMacro("__tune_i386__");
178 1: DefineStd(Builder, "unix", Opts);
179 1: }
180 : public:
181 1: DragonFlyBSDTargetInfo(const std::string &triple)
182 1: : OSTargetInfo<Target>(triple) {}
183 : };
184 :
185 : // FreeBSD Target
186 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
4: branch 17 taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
187 4: class FreeBSDTargetInfo : public OSTargetInfo<Target> {
188 : protected:
189 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
190 4: MacroBuilder &Builder) const {
191 : // FreeBSD defines; list based off of gcc output
192 :
193 : // FIXME: Move version number handling to llvm::Triple.
194 4: llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
195 :
196 4: Builder.defineMacro("__FreeBSD__", Release);
197 4: Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
198 4: Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
199 4: DefineStd(Builder, "unix", Opts);
200 4: Builder.defineMacro("__ELF__");
201 4: }
202 : public:
203 4: FreeBSDTargetInfo(const std::string &triple)
204 4: : OSTargetInfo<Target>(triple) {
205 4: this->UserLabelPrefix = "";
206 4: }
207 : };
208 :
209 : // Linux target
210 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
2094: branch 17 taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
4: branch 25 taken
0: branch 26 not taken
0: branch 29 not taken
0: branch 30 not taken
211 2098: class LinuxTargetInfo : public OSTargetInfo<Target> {
212 : protected:
213 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
214 2088: MacroBuilder &Builder) const {
215 : // Linux defines; list based off of gcc output
216 2088: DefineStd(Builder, "unix", Opts);
217 2088: DefineStd(Builder, "linux", Opts);
218 2088: Builder.defineMacro("__gnu_linux__");
219 2088: Builder.defineMacro("__ELF__");
2088: branch 0 taken
2088: branch 1 taken
2088: branch 2 taken
2088: branch 3 taken
0: branch 4 not taken
2084: branch 5 taken
0: branch 6 not taken
4: branch 7 taken
220 2088: if (Opts.POSIXThreads)
221 0: Builder.defineMacro("_REENTRANT");
222 2088: }
223 : public:
224 2098: LinuxTargetInfo(const std::string& triple)
225 2098: : OSTargetInfo<Target>(triple) {
226 2098: this->UserLabelPrefix = "";
227 2098: }
228 : };
229 :
230 : // NetBSD Target
231 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
232 0: class NetBSDTargetInfo : public OSTargetInfo<Target> {
233 : protected:
234 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
235 0: MacroBuilder &Builder) const {
236 : // NetBSD defines; list based off of gcc output
237 0: Builder.defineMacro("__NetBSD__");
238 0: Builder.defineMacro("__unix__");
239 0: Builder.defineMacro("__ELF__");
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
240 0: if (Opts.POSIXThreads)
241 0: Builder.defineMacro("_POSIX_THREADS");
242 0: }
243 : public:
244 0: NetBSDTargetInfo(const std::string &triple)
245 0: : OSTargetInfo<Target>(triple) {
246 0: this->UserLabelPrefix = "";
247 0: }
248 : };
249 :
250 : // OpenBSD Target
251 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
252 0: class OpenBSDTargetInfo : public OSTargetInfo<Target> {
253 : protected:
254 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
255 0: MacroBuilder &Builder) const {
256 : // OpenBSD defines; list based off of gcc output
257 :
258 0: Builder.defineMacro("__OpenBSD__");
259 0: DefineStd(Builder, "unix", Opts);
260 0: Builder.defineMacro("__ELF__");
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
261 0: if (Opts.POSIXThreads)
262 0: Builder.defineMacro("_POSIX_THREADS");
263 0: }
264 : public:
265 0: OpenBSDTargetInfo(const std::string &triple)
266 0: : OSTargetInfo<Target>(triple) {}
267 : };
268 :
269 : // PSP Target
270 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
271 0: class PSPTargetInfo : public OSTargetInfo<Target> {
272 : protected:
273 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
274 0: MacroBuilder &Builder) const {
275 : // PSP defines; list based on the output of the pspdev gcc toolchain.
276 0: Builder.defineMacro("PSP");
277 0: Builder.defineMacro("_PSP");
278 0: Builder.defineMacro("__psp__");
279 0: Builder.defineMacro("__ELF__");
280 0: }
281 : public:
282 0: PSPTargetInfo(const std::string& triple)
283 0: : OSTargetInfo<Target>(triple) {
284 0: this->UserLabelPrefix = "";
285 0: }
286 : };
287 :
288 : // PS3 PPU Target
289 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
290 0: class PS3PPUTargetInfo : public OSTargetInfo<Target> {
291 : protected:
292 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
293 0: MacroBuilder &Builder) const {
294 : // PS3 PPU defines.
295 0: Builder.defineMacro("__PPU__");
296 0: Builder.defineMacro("__CELLOS_LV2__");
297 0: Builder.defineMacro("__ELF__");
298 0: Builder.defineMacro("__LP32__");
299 0: }
300 : public:
301 0: PS3PPUTargetInfo(const std::string& triple)
302 0: : OSTargetInfo<Target>(triple) {
303 0: this->UserLabelPrefix = "";
304 0: this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
305 0: this->SizeType = TargetInfo::UnsignedInt;
306 0: }
307 : };
308 :
309 : // FIXME: Need a real SPU target.
310 : // PS3 SPU Target
311 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
312 0: class PS3SPUTargetInfo : public OSTargetInfo<Target> {
313 : protected:
314 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
315 0: MacroBuilder &Builder) const {
316 : // PS3 PPU defines.
317 0: Builder.defineMacro("__SPU__");
318 0: Builder.defineMacro("__ELF__");
319 0: }
320 : public:
321 0: PS3SPUTargetInfo(const std::string& triple)
322 0: : OSTargetInfo<Target>(triple) {
323 0: this->UserLabelPrefix = "";
324 0: }
325 : };
326 :
327 : // AuroraUX target
328 : template<typename Target>
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 25 not taken
0: branch 26 not taken
329 0: class AuroraUXTargetInfo : public OSTargetInfo<Target> {
330 : protected:
331 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
332 0: MacroBuilder &Builder) const {
333 0: DefineStd(Builder, "sun", Opts);
334 0: DefineStd(Builder, "unix", Opts);
335 0: Builder.defineMacro("__ELF__");
336 0: Builder.defineMacro("__svr4__");
337 0: Builder.defineMacro("__SVR4");
338 0: }
339 : public:
340 0: AuroraUXTargetInfo(const std::string& triple)
341 0: : OSTargetInfo<Target>(triple) {
342 0: this->UserLabelPrefix = "";
343 0: this->WCharType = this->SignedLong;
344 : // FIXME: WIntType should be SignedLong
345 0: }
346 : };
347 :
348 : // Solaris target
349 : template<typename Target>
0: branch 1 not taken
1: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
0: branch 13 not taken
0: branch 14 not taken
0: branch 17 not taken
0: branch 18 not taken
0: branch 21 not taken
0: branch 22 not taken
0: branch 25 not taken
0: branch 26 not taken
350 1: class SolarisTargetInfo : public OSTargetInfo<Target> {
351 : protected:
352 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
353 1: MacroBuilder &Builder) const {
354 1: DefineStd(Builder, "sun", Opts);
355 1: DefineStd(Builder, "unix", Opts);
356 1: Builder.defineMacro("__ELF__");
357 1: Builder.defineMacro("__svr4__");
358 1: Builder.defineMacro("__SVR4");
359 1: }
360 : public:
361 1: SolarisTargetInfo(const std::string& triple)
362 1: : OSTargetInfo<Target>(triple) {
363 1: this->UserLabelPrefix = "";
364 1: this->WCharType = this->SignedLong;
365 : // FIXME: WIntType should be SignedLong
366 1: }
367 : };
368 : } // end anonymous namespace.
369 :
370 : //===----------------------------------------------------------------------===//
371 : // Specific target implementations.
372 : //===----------------------------------------------------------------------===//
373 :
374 : namespace {
375 : // PPC abstract base class
0: branch 1 not taken
10: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
376 10: class PPCTargetInfo : public TargetInfo {
377 : static const Builtin::Info BuiltinInfo[];
378 : static const char * const GCCRegNames[];
379 : static const TargetInfo::GCCRegAlias GCCRegAliases[];
380 :
381 : public:
382 10: PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
383 :
384 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
385 10: unsigned &NumRecords) const {
386 10: Records = BuiltinInfo;
387 10: NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
388 10: }
389 :
390 : virtual void getTargetDefines(const LangOptions &Opts,
391 : MacroBuilder &Builder) const;
392 :
393 10: virtual const char *getVAListDeclaration() const {
394 10: return "typedef char* __builtin_va_list;";
395 : // This is the right definition for ABI/V4: System V.4/eabi.
396 : /*return "typedef struct __va_list_tag {"
397 : " unsigned char gpr;"
398 : " unsigned char fpr;"
399 : " unsigned short reserved;"
400 : " void* overflow_arg_area;"
401 : " void* reg_save_area;"
402 : "} __builtin_va_list[1];";*/
403 : }
404 : virtual void getGCCRegNames(const char * const *&Names,
405 : unsigned &NumNames) const;
406 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
407 : unsigned &NumAliases) const;
408 : virtual bool validateAsmConstraint(const char *&Name,
409 0: TargetInfo::ConstraintInfo &Info) const {
0: branch 0 not taken
0: branch 1 not taken
0: branch 2 not taken
410 0: switch (*Name) {
411 0: default: return false;
412 : case 'O': // Zero
413 0: return true;
414 : case 'b': // Base register
415 : case 'f': // Floating point register
416 0: Info.setAllowsRegister();
417 0: return true;
418 : }
419 : }
420 0: virtual const char *getClobbers() const {
421 0: return "";
422 : }
423 : };
424 :
425 : const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
426 : #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
427 : #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
428 : #include "clang/Basic/BuiltinsPPC.def"
429 : };
430 :
431 :
432 : /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
433 : /// #defines that are not tied to a specific subtarget.
434 : void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
435 10: MacroBuilder &Builder) const {
436 : // Target identification.
437 10: Builder.defineMacro("__ppc__");
438 10: Builder.defineMacro("_ARCH_PPC");
439 10: Builder.defineMacro("__POWERPC__");
4: branch 0 taken
6: branch 1 taken
440 10: if (PointerWidth == 64) {
441 4: Builder.defineMacro("_ARCH_PPC64");
442 4: Builder.defineMacro("_LP64");
443 4: Builder.defineMacro("__LP64__");
444 4: Builder.defineMacro("__ppc64__");
445 : } else {
446 6: Builder.defineMacro("__ppc__");
447 : }
448 :
449 : // Target properties.
450 10: Builder.defineMacro("_BIG_ENDIAN");
451 10: Builder.defineMacro("__BIG_ENDIAN__");
452 :
453 : // Subtarget options.
454 10: Builder.defineMacro("__NATURAL_ALIGNMENT__");
455 10: Builder.defineMacro("__REGISTER_PREFIX__", "");
456 :
457 : // FIXME: Should be controlled by command line option.
458 10: Builder.defineMacro("__LONG_DOUBLE_128__");
459 :
0: branch 0 not taken
10: branch 1 taken
460 10: if (Opts.AltiVec) {
461 0: Builder.defineMacro("__VEC__", "10206");
462 0: Builder.defineMacro("__ALTIVEC__");
463 : }
464 10: }
465 :
466 :
467 : const char * const PPCTargetInfo::GCCRegNames[] = {
468 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
469 : "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
470 : "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
471 : "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
472 : "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
473 : "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
474 : "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
475 : "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
476 : "mq", "lr", "ctr", "ap",
477 : "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
478 : "xer",
479 : "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
480 : "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
481 : "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
482 : "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
483 : "vrsave", "vscr",
484 : "spe_acc", "spefscr",
485 : "sfp"
486 : };
487 :
488 : void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
489 0: unsigned &NumNames) const {
490 0: Names = GCCRegNames;
491 0: NumNames = llvm::array_lengthof(GCCRegNames);
492 0: }
493 :
494 : const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
495 : // While some of these aliases do map to different registers
496 : // they still share the same register name.
497 : { { "0" }, "r0" },
498 : { { "1"}, "r1" },
499 : { { "2" }, "r2" },
500 : { { "3" }, "r3" },
501 : { { "4" }, "r4" },
502 : { { "5" }, "r5" },
503 : { { "6" }, "r6" },
504 : { { "7" }, "r7" },
505 : { { "8" }, "r8" },
506 : { { "9" }, "r9" },
507 : { { "10" }, "r10" },
508 : { { "11" }, "r11" },
509 : { { "12" }, "r12" },
510 : { { "13" }, "r13" },
511 : { { "14" }, "r14" },
512 : { { "15" }, "r15" },
513 : { { "16" }, "r16" },
514 : { { "17" }, "r17" },
515 : { { "18" }, "r18" },
516 : { { "19" }, "r19" },
517 : { { "20" }, "r20" },
518 : { { "21" }, "r21" },
519 : { { "22" }, "r22" },
520 : { { "23" }, "r23" },
521 : { { "24" }, "r24" },
522 : { { "25" }, "r25" },
523 : { { "26" }, "r26" },
524 : { { "27" }, "r27" },
525 : { { "28" }, "r28" },
526 : { { "29" }, "r29" },
527 : { { "30" }, "r30" },
528 : { { "31" }, "r31" },
529 : { { "fr0" }, "f0" },
530 : { { "fr1" }, "f1" },
531 : { { "fr2" }, "f2" },
532 : { { "fr3" }, "f3" },
533 : { { "fr4" }, "f4" },
534 : { { "fr5" }, "f5" },
535 : { { "fr6" }, "f6" },
536 : { { "fr7" }, "f7" },
537 : { { "fr8" }, "f8" },
538 : { { "fr9" }, "f9" },
539 : { { "fr10" }, "f10" },
540 : { { "fr11" }, "f11" },
541 : { { "fr12" }, "f12" },
542 : { { "fr13" }, "f13" },
543 : { { "fr14" }, "f14" },
544 : { { "fr15" }, "f15" },
545 : { { "fr16" }, "f16" },
546 : { { "fr17" }, "f17" },
547 : { { "fr18" }, "f18" },
548 : { { "fr19" }, "f19" },
549 : { { "fr20" }, "f20" },
550 : { { "fr21" }, "f21" },
551 : { { "fr22" }, "f22" },
552 : { { "fr23" }, "f23" },
553 : { { "fr24" }, "f24" },
554 : { { "fr25" }, "f25" },
555 : { { "fr26" }, "f26" },
556 : { { "fr27" }, "f27" },
557 : { { "fr28" }, "f28" },
558 : { { "fr29" }, "f29" },
559 : { { "fr30" }, "f30" },
560 : { { "fr31" }, "f31" },
561 : { { "cc" }, "cr0" },
562 : };
563 :
564 : void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
565 0: unsigned &NumAliases) const {
566 0: Aliases = GCCRegAliases;
567 0: NumAliases = llvm::array_lengthof(GCCRegAliases);
568 0: }
569 : } // end anonymous namespace.
570 :
571 : namespace {
4: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
572 4: class PPC32TargetInfo : public PPCTargetInfo {
573 : public:
574 4: PPC32TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
575 : DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
576 4: "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
577 4: }
578 : };
579 : } // end anonymous namespace.
580 :
581 : namespace {
0: branch 1 not taken
1: branch 2 taken
3: branch 5 taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
582 4: class PPC64TargetInfo : public PPCTargetInfo {
583 : public:
584 4: PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
585 4: LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
586 4: IntMaxType = SignedLong;
587 4: UIntMaxType = UnsignedLong;
588 4: Int64Type = SignedLong;
589 : DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
590 4: "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
591 4: }
592 : };
593 : } // end anonymous namespace.
594 :
595 : namespace {
596 : // Namespace for x86 abstract base class
597 : const Builtin::Info BuiltinInfo[] = {
598 : #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
599 : #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
600 : #include "clang/Basic/BuiltinsX86.def"
601 : };
602 :
603 : static const char* const 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 :
613 : const 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.
0: branch 1 not taken
2489: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
626 2489: class X86TargetInfo : public TargetInfo {
627 : enum X86SSEEnum {
628 : NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
629 : } SSELevel;
630 : enum AMD3DNowEnum {
631 : NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
632 : } AMD3DNowLevel;
633 :
634 : public:
635 2492: X86TargetInfo(const std::string& triple)
636 2492: : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow) {
637 2492: LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
638 2492: }
639 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
640 2490: unsigned &NumRecords) const {
641 2490: Records = BuiltinInfo;
642 2490: NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
643 2490: }
644 : virtual void getGCCRegNames(const char * const *&Names,
645 35: unsigned &NumNames) const {
646 35: Names = GCCRegNames;
647 35: NumNames = llvm::array_lengthof(GCCRegNames);
648 35: }
649 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
650 15: unsigned &NumAliases) const {
651 15: Aliases = GCCRegAliases;
652 15: NumAliases = llvm::array_lengthof(GCCRegAliases);
653 15: }
654 : virtual bool validateAsmConstraint(const char *&Name,
655 : TargetInfo::ConstraintInfo &info) const;
656 : virtual std::string convertConstraint(const char Constraint) const;
657 29: virtual const char *getClobbers() const {
658 29: return "~{dirflag},~{fpsr},~{flags}";
659 : }
660 : virtual void getTargetDefines(const LangOptions &Opts,
661 : MacroBuilder &Builder) const;
662 : virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
663 : const std::string &Name,
664 : bool Enabled) const;
665 : virtual void getDefaultFeatures(const std::string &CPU,
666 : llvm::StringMap<bool> &Features) const;
667 : virtual void HandleTargetFeatures(std::vector<std::string> &Features);
668 : };
669 :
670 : void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
671 2492: llvm::StringMap<bool> &Features) const {
672 : // FIXME: This should not be here.
673 2492: Features["3dnow"] = false;
674 2492: Features["3dnowa"] = false;
675 2492: Features["mmx"] = false;
676 2492: Features["sse"] = false;
677 2492: Features["sse2"] = false;
678 2492: Features["sse3"] = false;
679 2492: Features["ssse3"] = false;
680 2492: Features["sse41"] = false;
681 2492: Features["sse42"] = false;
682 :
683 : // LLVM does not currently recognize this.
684 : // Features["sse4a"] = false;
685 :
686 : // FIXME: This *really* should not be here.
687 :
688 : // X86_64 always has SSE2.
202: branch 0 taken
2290: branch 1 taken
689 2492: if (PointerWidth == 64)
690 202: Features["sse2"] = Features["sse"] = Features["mmx"] = true;
691 :
2492: branch 1 taken
0: branch 2 not taken
2492: branch 4 taken
0: branch 5 not taken
2492: branch 7 taken
0: branch 8 not taken
2492: branch 10 taken
0: branch 11 not taken
2492: branch 13 taken
0: branch 14 not taken
2492: branch 16 taken
0: branch 17 not taken
0: branch 19 not taken
2492: branch 20 taken
2492: branch 21 taken
0: branch 22 not taken
692 2492: if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
693 : CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
694 : ;
2492: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
2492: branch 5 taken
0: branch 6 not taken
2492: branch 7 taken
695 2492: else if (CPU == "pentium-mmx" || CPU == "pentium2")
696 0: setFeatureEnabled(Features, "mmx", true);
0: branch 1 not taken
2492: branch 2 taken
697 2492: else if (CPU == "pentium3")
698 0: setFeatureEnabled(Features, "sse", true);
2491: branch 1 taken
1: branch 2 taken
2357: branch 4 taken
134: branch 5 taken
1: branch 7 taken
2356: branch 8 taken
136: branch 9 taken
2356: branch 10 taken
699 2492: else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
700 136: setFeatureEnabled(Features, "sse2", true);
2345: branch 1 taken
11: branch 2 taken
2345: branch 4 taken
0: branch 5 not taken
0: branch 7 not taken
2345: branch 8 taken
11: branch 9 taken
2345: branch 10 taken
701 2356: else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
702 11: setFeatureEnabled(Features, "sse3", true);
2: branch 1 taken
2343: branch 2 taken
703 2345: else if (CPU == "core2")
704 2: setFeatureEnabled(Features, "ssse3", true);
0: branch 1 not taken
2343: branch 2 taken
705 2343: else if (CPU == "penryn") {
706 0: setFeatureEnabled(Features, "sse4", true);
707 0: Features["sse42"] = false;
0: branch 1 not taken
2343: branch 2 taken
708 2343: } else if (CPU == "atom")
709 0: setFeatureEnabled(Features, "sse3", true);
0: branch 1 not taken
2343: branch 2 taken
710 2343: else if (CPU == "corei7")
711 0: setFeatureEnabled(Features, "sse4", true);
2343: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
2343: branch 5 taken
0: branch 6 not taken
2343: branch 7 taken
712 2343: else if (CPU == "k6" || CPU == "winchip-c6")
713 0: setFeatureEnabled(Features, "mmx", true);
2343: branch 1 taken
0: branch 2 not taken
2343: branch 4 taken
0: branch 5 not taken
2343: branch 7 taken
0: branch 8 not taken
2343: branch 10 taken
0: branch 11 not taken
2343: branch 13 taken
0: branch 14 not taken
0: branch 16 not taken
2343: branch 17 taken
0: branch 18 not taken
2343: branch 19 taken
714 2343: else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
715 : CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
716 0: setFeatureEnabled(Features, "mmx", true);
717 0: setFeatureEnabled(Features, "3dnow", true);
2343: branch 1 taken
0: branch 2 not taken
2343: branch 4 taken
0: branch 5 not taken
0: branch 7 not taken
2343: branch 8 taken
0: branch 9 not taken
2343: branch 10 taken
718 2343: } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
719 0: setFeatureEnabled(Features, "sse", true);
720 0: setFeatureEnabled(Features, "3dnowa", true);
2343: branch 1 taken
0: branch 2 not taken
2343: branch 4 taken
0: branch 5 not taken
2343: branch 7 taken
0: branch 8 not taken
0: branch 10 not taken
2343: branch 11 taken
0: branch 12 not taken
2343: branch 13 taken
721 2343: } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
722 : CPU == "athlon-fx") {
723 0: setFeatureEnabled(Features, "sse2", true);
724 0: setFeatureEnabled(Features, "3dnowa", true);
0: branch 1 not taken
2343: branch 2 taken
725 2343: } else if (CPU == "c3-2")
726 0: setFeatureEnabled(Features, "sse", true);
727 2492: }
728 :
729 : bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
730 : const std::string &Name,
731 153: bool Enabled) const {
732 : // FIXME: This *really* should not be here.
2: branch 2 taken
151: branch 3 taken
0: branch 5 not taken
2: branch 6 taken
0: branch 7 not taken
153: branch 8 taken
733 153: if (!Features.count(Name) && Name != "sse4")
734 0: return false;
735 :
152: branch 0 taken
1: branch 1 taken
736 153: if (Enabled) {
0: branch 1 not taken
152: branch 2 taken
737 152: if (Name == "mmx")
738 0: Features["mmx"] = true;
0: branch 1 not taken
152: branch 2 taken
739 152: else if (Name == "sse")
740 0: Features["mmx"] = Features["sse"] = true;
136: branch 1 taken
16: branch 2 taken
741 152: else if (Name == "sse2")
742 136: Features["mmx"] = Features["sse"] = Features["sse2"] = true;
11: branch 1 taken
5: branch 2 taken
743 16: else if (Name == "sse3")
744 : Features["mmx"] = Features["sse"] = Features["sse2"] =
745 11: Features["sse3"] = true;
3: branch 1 taken
2: branch 2 taken
746 5: else if (Name == "ssse3")
747 : Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
748 3: Features["ssse3"] = true;
2: branch 1 taken
0: branch 2 not taken
749 2: else if (Name == "sse4")
750 : Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
751 2: Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
0: branch 1 not taken
0: branch 2 not taken
752 0: else if (Name == "3dnow")
753 0: Features["3dnowa"] = true;
0: branch 1 not taken
0: branch 2 not taken
754 0: else if (Name == "3dnowa")
755 0: Features["3dnow"] = Features["3dnowa"] = true;
756 : } else {
0: branch 1 not taken
1: branch 2 taken
757 1: if (Name == "mmx")
758 : Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
759 0: Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
0: branch 1 not taken
1: branch 2 taken
760 1: else if (Name == "sse")
761 : Features["sse"] = Features["sse2"] = Features["sse3"] =
762 0: Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1: branch 1 taken
0: branch 2 not taken
763 1: else if (Name == "sse2")
764 : Features["sse2"] = Features["sse3"] = Features["ssse3"] =
765 1: Features["sse41"] = Features["sse42"] = false;
0: branch 1 not taken
0: branch 2 not taken
766 0: else if (Name == "sse3")
767 : Features["sse3"] = Features["ssse3"] = Features["sse41"] =
768 0: Features["sse42"] = false;
0: branch 1 not taken
0: branch 2 not taken
769 0: else if (Name == "ssse3")
770 0: Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
0: branch 1 not taken
0: branch 2 not taken
771 0: else if (Name == "sse4")
772 0: Features["sse41"] = Features["sse42"] = false;
0: branch 1 not taken
0: branch 2 not taken
773 0: else if (Name == "3dnow")
774 0: Features["3dnow"] = Features["3dnowa"] = false;
0: branch 1 not taken
0: branch 2 not taken
775 0: else if (Name == "3dnowa")
776 0: Features["3dnowa"] = false;
777 : }
778 :
779 153: return true;
780 : }
781 :
782 : /// HandleTargetOptions - Perform initialization based on the user
783 : /// configured set of features.
784 2492: void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
785 : // Remember the maximum enabled sselevel.
22428: branch 1 taken
2492: branch 2 taken
786 24920: for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
787 : // Ignore disabled features.
1069: branch 2 taken
21359: branch 3 taken
788 22428: if (Features[i][0] == '-')
789 21359: continue;
790 :
1069: branch 2 taken
0: branch 3 not taken
791 1069: assert(Features[i][0] == '+' && "Invalid target feature!");
792 : X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
793 : .Case("sse42", SSE42)
794 : .Case("sse41", SSE41)
795 : .Case("ssse3", SSSE3)
796 : .Case("sse2", SSE2)
797 : .Case("sse", SSE1)
798 : .Case("mmx", MMX)
799 1069: .Default(NoMMXSSE);
800 1069: SSELevel = std::max(SSELevel, Level);
801 :
802 : AMD3DNowEnum ThreeDNowLevel =
803 : llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
804 : .Case("3dnowa", AMD3DNowAthlon)
805 : .Case("3dnow", AMD3DNow)
806 1069: .Default(NoAMD3DNow);
807 :
808 1069: AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
809 : }
810 2492: }
811 :
812 : /// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
813 : /// that are not tied to a specific subtarget.
814 : void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
815 2476: MacroBuilder &Builder) const {
816 : // Target identification.
196: branch 0 taken
2280: branch 1 taken
817 2476: if (PointerWidth == 64) {
818 196: Builder.defineMacro("_LP64");
819 196: Builder.defineMacro("__LP64__");
820 196: Builder.defineMacro("__amd64__");
821 196: Builder.defineMacro("__amd64");
822 196: Builder.defineMacro("__x86_64");
823 196: Builder.defineMacro("__x86_64__");
824 : } else {
825 2280: DefineStd(Builder, "i386", Opts);
826 : }
827 :
828 : // Target properties.
829 2476: Builder.defineMacro("__LITTLE_ENDIAN__");
830 :
831 : // Subtarget options.
832 2476: Builder.defineMacro("__nocona");
833 2476: Builder.defineMacro("__nocona__");
834 2476: Builder.defineMacro("__tune_nocona__");
835 2476: Builder.defineMacro("__REGISTER_PREFIX__", "");
836 :
837 : // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
838 : // functions in glibc header files that use FP Stack inline asm which the
839 : // backend can't deal with (PR879).
840 2476: Builder.defineMacro("__NO_MATH_INLINES");
841 :
842 : // Each case falls through to the previous one here.
1: branch 0 taken
0: branch 1 not taken
1: branch 2 taken
0: branch 3 not taken
340: branch 4 taken
1: branch 5 taken
0: branch 6 not taken
2133: branch 7 taken
843 2476: switch (SSELevel) {
844 : case SSE42:
845 1: Builder.defineMacro("__SSE4_2__");
846 : case SSE41:
847 1: Builder.defineMacro("__SSE4_1__");
848 : case SSSE3:
849 2: Builder.defineMacro("__SSSE3__");
850 : case SSE3:
851 2: Builder.defineMacro("__SSE3__");
852 : case SSE2:
853 342: Builder.defineMacro("__SSE2__");
854 342: Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
855 : case SSE1:
856 343: Builder.defineMacro("__SSE__");
857 343: Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
858 : case MMX:
859 343: Builder.defineMacro("__MMX__");
860 : case NoMMXSSE:
861 : break;
862 : }
863 :
864 : // Each case falls through to the previous one here.
0: branch 0 not taken
0: branch 1 not taken
2476: branch 2 taken
865 2476: switch (AMD3DNowLevel) {
866 : case AMD3DNowAthlon:
867 0: Builder.defineMacro("__3dNOW_A__");
868 : case AMD3DNow:
869 0: Builder.defineMacro("__3dNOW__");
870 : case NoAMD3DNow:
871 : break;
872 : }
873 2476: }
874 :
875 :
876 : bool
877 : X86TargetInfo::validateAsmConstraint(const char *&Name,
878 50: TargetInfo::ConstraintInfo &Info) const {
0: branch 0 not taken
50: branch 1 taken
879 50: switch (*Name) {
880 0: default: return false;
881 : case 'a': // eax.
882 : case 'b': // ebx.
883 : case 'c': // ecx.
884 : case 'd': // edx.
885 : case 'S': // esi.
886 : case 'D': // edi.
887 : case 'A': // edx:eax.
888 : case 't': // top of floating point stack.
889 : case 'u': // second from top of floating point stack.
890 : case 'q': // Any register accessible as [r]l: a, b, c, and d.
891 : case 'y': // Any MMX register.
892 : case 'x': // Any SSE register.
893 : case 'Q': // Any register accessible as [r]h: a, b, c, and d.
894 : case 'e': // 32-bit signed integer constant for use with zero-extending
895 : // x86_64 instructions.
896 : case 'Z': // 32-bit unsigned integer constant for use with zero-extending
897 : // x86_64 instructions.
898 : case 'N': // unsigned 8-bit integer constant for use with in and out
899 : // instructions.
900 : case 'R': // "legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
901 50: Info.setAllowsRegister();
902 50: return true;
903 : }
904 : }
905 :
906 : std::string
907 49: X86TargetInfo::convertConstraint(const char Constraint) const {
6: branch 0 taken
1: branch 1 taken
2: branch 2 taken
2: branch 3 taken
1: branch 4 taken
1: branch 5 taken
1: branch 6 taken
1: branch 7 taken
34: branch 8 taken
908 49: switch (Constraint) {
909 6: case 'a': return std::string("{ax}");
910 1: case 'b': return std::string("{bx}");
911 2: case 'c': return std::string("{cx}");
912 2: case 'd': return std::string("{dx}");
913 1: case 'S': return std::string("{si}");
914 1: case 'D': return std::string("{di}");
915 : case 't': // top of floating point stack.
916 1: return std::string("{st}");
917 : case 'u': // second from top of floating point stack.
918 1: return std::string("{st(1)}"); // second from top of floating point stack.
919 : default:
920 34: return std::string(1, Constraint);
921 : }
922 : }
923 : } // end anonymous namespace
924 :
925 : namespace {
926 : // X86-32 generic target
0: branch 1 not taken
2223: branch 2 taken
67: branch 5 taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
927 2290: class X86_32TargetInfo : public X86TargetInfo {
928 : public:
929 2290: X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
930 2290: DoubleAlign = LongLongAlign = 32;
931 2290: LongDoubleWidth = 96;
932 2290: LongDoubleAlign = 32;
933 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
934 : "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
935 2290: "a0:0:64-f80:32:32-n8:16:32";
936 2290: SizeType = UnsignedInt;
937 2290: PtrDiffType = SignedInt;
938 2290: IntPtrType = SignedInt;
939 2290: RegParmMax = 3;
940 2290: }
941 2280: virtual const char *getVAListDeclaration() const {
942 2280: return "typedef char* __builtin_va_list;";
943 : }
944 :
945 3: int getEHDataRegisterNumber(unsigned RegNo) const {
3: branch 0 taken
0: branch 1 not taken
946 3: if (RegNo == 0) return 0;
0: branch 0 not taken
0: branch 1 not taken
947 0: if (RegNo == 1) return 2;
948 0: return -1;
949 : }
950 : };
951 : } // end anonymous namespace
952 :
953 : namespace {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
954 0: class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
955 : public:
956 0: OpenBSDI386TargetInfo(const std::string& triple) :
957 0: OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
958 0: SizeType = UnsignedLong;
959 0: IntPtrType = SignedLong;
960 0: PtrDiffType = SignedLong;
961 0: }
962 : };
963 : } // end anonymous namespace
964 :
965 : namespace {
126: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
966 126: class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
967 : public:
968 126: DarwinI386TargetInfo(const std::string& triple) :
969 126: DarwinTargetInfo<X86_32TargetInfo>(triple) {
970 126: LongDoubleWidth = 128;
971 126: LongDoubleAlign = 128;
972 126: SizeType = UnsignedLong;
973 126: IntPtrType = SignedLong;
974 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
975 : "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
976 126: "a0:0:64-f80:128:128-n8:16:32";
977 126: }
978 :
979 : };
980 : } // end anonymous namespace
981 :
982 : namespace {
983 : // x86-32 Windows target
0: branch 1 not taken
2: branch 2 taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
984 2: class WindowsX86_32TargetInfo : public X86_32TargetInfo {
985 : public:
986 2: WindowsX86_32TargetInfo(const std::string& triple)
987 2: : X86_32TargetInfo(triple) {
988 2: TLSSupported = false;
989 2: WCharType = UnsignedShort;
990 2: DoubleAlign = LongLongAlign = 64;
991 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
992 : "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
993 2: "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
994 2: }
995 : virtual void getTargetDefines(const LangOptions &Opts,
996 2: MacroBuilder &Builder) const {
997 2: X86_32TargetInfo::getTargetDefines(Opts, Builder);
998 : // This list is based off of the the list of things MingW defines
999 2: Builder.defineMacro("_WIN32");
1000 2: DefineStd(Builder, "WIN32", Opts);
1001 2: DefineStd(Builder, "WINNT", Opts);
1002 2: Builder.defineMacro("_X86_");
1003 2: }
1004 : };
1005 : } // end anonymous namespace
1006 :
1007 : namespace {
1008 :
1009 : // x86-32 Windows Visual Studio target
2: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1010 2: class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1011 : public:
1012 2: VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1013 2: : WindowsX86_32TargetInfo(triple) {
1014 2: }
1015 : virtual void getTargetDefines(const LangOptions &Opts,
1016 2: MacroBuilder &Builder) const {
1017 2: WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1018 : // The value of the following reflects processor type.
1019 : // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1020 : // We lost the original triple, so we use the default.
1021 2: Builder.defineMacro("_M_IX86", "600");
1022 2: }
1023 : };
1024 : } // end anonymous namespace
1025 :
1026 : namespace {
1027 : // x86-32 MinGW target
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1028 0: class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1029 : public:
1030 0: MinGWX86_32TargetInfo(const std::string& triple)
1031 0: : WindowsX86_32TargetInfo(triple) {
1032 0: }
1033 : virtual void getTargetDefines(const LangOptions &Opts,
1034 0: MacroBuilder &Builder) const {
1035 0: WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1036 0: Builder.defineMacro("__MSVCRT__");
1037 0: Builder.defineMacro("__MINGW32__");
1038 0: Builder.defineMacro("__declspec", "__declspec");
1039 0: }
1040 : };
1041 : } // end anonymous namespace
1042 :
1043 : namespace {
1044 : // x86-32 Cygwin target
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1045 0: class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1046 : public:
1047 0: CygwinX86_32TargetInfo(const std::string& triple)
1048 0: : X86_32TargetInfo(triple) {
1049 0: TLSSupported = false;
1050 0: WCharType = UnsignedShort;
1051 0: DoubleAlign = LongLongAlign = 64;
1052 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1053 : "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1054 0: "a0:0:64-f80:32:32-n8:16:32";
1055 0: }
1056 : virtual void getTargetDefines(const LangOptions &Opts,
1057 0: MacroBuilder &Builder) const {
1058 0: X86_32TargetInfo::getTargetDefines(Opts, Builder);
1059 0: Builder.defineMacro("__CYGWIN__");
1060 0: Builder.defineMacro("__CYGWIN32__");
1061 0: DefineStd(Builder, "unix", Opts);
1062 0: }
1063 : };
1064 : } // end anonymous namespace
1065 :
1066 : namespace {
1067 : // x86-64 generic target
0: branch 1 not taken
175: branch 2 taken
24: branch 5 taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
1068 199: class X86_64TargetInfo : public X86TargetInfo {
1069 : public:
1070 202: X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
1071 202: LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
1072 202: LongDoubleWidth = 128;
1073 202: LongDoubleAlign = 128;
1074 202: IntMaxType = SignedLong;
1075 202: UIntMaxType = UnsignedLong;
1076 202: Int64Type = SignedLong;
1077 202: RegParmMax = 6;
1078 :
1079 : DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1080 : "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
1081 202: "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
1082 202: }
1083 196: virtual const char *getVAListDeclaration() const {
1084 : return "typedef struct __va_list_tag {"
1085 : " unsigned gp_offset;"
1086 : " unsigned fp_offset;"
1087 : " void* overflow_arg_area;"
1088 : " void* reg_save_area;"
1089 : "} __va_list_tag;"
1090 196: "typedef __va_list_tag __builtin_va_list[1];";
1091 : }
1092 :
1093 0: int getEHDataRegisterNumber(unsigned RegNo) const {
0: branch 0 not taken
0: branch 1 not taken
1094 0: if (RegNo == 0) return 0;
0: branch 0 not taken
0: branch 1 not taken
1095 0: if (RegNo == 1) return 1;
1096 0: return -1;
1097 : }
1098 : };
1099 : } // end anonymous namespace
1100 :
1101 : namespace {
1102 : // x86-64 Windows target
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
1103 0: class WindowsX86_64TargetInfo : public X86_64TargetInfo {
1104 : public:
1105 0: WindowsX86_64TargetInfo(const std::string& triple)
1106 0: : X86_64TargetInfo(triple) {
1107 0: TLSSupported = false;
1108 0: WCharType = UnsignedShort;
1109 0: LongWidth = LongAlign = 32;
1110 0: DoubleAlign = LongLongAlign = 64;
1111 0: }
1112 : virtual void getTargetDefines(const LangOptions &Opts,
1113 0: MacroBuilder &Builder) const {
1114 0: X86_64TargetInfo::getTargetDefines(Opts, Builder);
1115 0: Builder.defineMacro("_WIN64");
1116 0: DefineStd(Builder, "WIN64", Opts);
1117 0: }
1118 : };
1119 : } // end anonymous namespace
1120 :
1121 : namespace {
1122 : // x86-64 Windows Visual Studio target
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1123 0: class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1124 : public:
1125 0: VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1126 0: : WindowsX86_64TargetInfo(triple) {
1127 0: }
1128 : virtual void getTargetDefines(const LangOptions &Opts,
1129 0: MacroBuilder &Builder) const {
1130 0: WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1131 0: Builder.defineMacro("_M_X64");
1132 0: }
1133 0: virtual const char *getVAListDeclaration() const {
1134 0: return "typedef char* va_list;";
1135 : }
1136 : };
1137 : } // end anonymous namespace
1138 :
1139 : namespace {
1140 : // x86-64 MinGW target
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1141 0: class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1142 : public:
1143 0: MinGWX86_64TargetInfo(const std::string& triple)
1144 0: : WindowsX86_64TargetInfo(triple) {
1145 0: }
1146 : virtual void getTargetDefines(const LangOptions &Opts,
1147 0: MacroBuilder &Builder) const {
1148 0: WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1149 0: Builder.defineMacro("__MSVCRT__");
1150 0: Builder.defineMacro("__MINGW64__");
1151 0: Builder.defineMacro("__declspec");
1152 0: }
1153 : };
1154 : } // end anonymous namespace
1155 :
1156 : namespace {
167: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1157 167: class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1158 : public:
1159 170: DarwinX86_64TargetInfo(const std::string& triple)
1160 170: : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1161 170: Int64Type = SignedLongLong;
1162 170: }
1163 : };
1164 : } // end anonymous namespace
1165 :
1166 : namespace {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1167 0: class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1168 : public:
1169 0: OpenBSDX86_64TargetInfo(const std::string& triple)
1170 0: : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1171 0: IntMaxType = SignedLongLong;
1172 0: UIntMaxType = UnsignedLongLong;
1173 0: Int64Type = SignedLongLong;
1174 0: }
1175 : };
1176 : } // end anonymous namespace
1177 :
1178 : namespace {
0: branch 3 not taken
7: branch 4 taken
8: branch 9 taken
0: branch 10 not taken
0: branch 15 not taken
0: branch 16 not taken
1179 15: class ARMTargetInfo : public TargetInfo {
1180 : // Possible FPU choices.
1181 : enum FPUMode {
1182 : NoFPU,
1183 : VFP2FPU,
1184 : VFP3FPU,
1185 : NeonFPU
1186 : };
1187 :
1188 15: static bool FPUModeIsVFP(FPUMode Mode) {
1: branch 0 taken
14: branch 1 taken
1: branch 2 taken
0: branch 3 not taken
1189 15: return Mode >= VFP2FPU && Mode <= NeonFPU;
1190 : }
1191 :
1192 : static const TargetInfo::GCCRegAlias GCCRegAliases[];
1193 : static const char * const GCCRegNames[];
1194 :
1195 : std::string ABI, CPU;
1196 :
1197 : unsigned FPU : 3;
1198 :
1199 : unsigned IsThumb : 1;
1200 :
1201 : // Initialized via features.
1202 : unsigned SoftFloat : 1;
1203 : unsigned SoftFloatABI : 1;
1204 :
1205 : public:
1206 15: ARMTargetInfo(const std::string &TripleStr)
1207 15: : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
1208 : {
1209 15: SizeType = UnsignedInt;
1210 15: PtrDiffType = SignedInt;
1211 :
1212 : // FIXME: Should we just treat this as a feature?
1213 15: IsThumb = getTriple().getArchName().startswith("thumb");
1: branch 0 taken
6: branch 1 taken
0: branch 2 not taken
8: branch 3 taken
1214 15: if (IsThumb) {
1215 : DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1216 : "i64:64:64-f32:32:32-f64:64:64-"
1217 1: "v64:64:64-v128:128:128-a0:0:32-n32");
1218 : } else {
1219 : DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1220 : "i64:64:64-f32:32:32-f64:64:64-"
1221 14: "v64:64:64-v128:128:128-a0:0:64-n32");
1222 : }
1223 15: }
1224 7: virtual const char *getABI() const { return ABI.c_str(); }
1225 9: virtual bool setABI(const std::string &Name) {
1226 9: ABI = Name;
1227 :
1228 : // The defaults (above) are for AAPCS, check if we need to change them.
1229 : //
1230 : // FIXME: We need support for -meabi... we could just mangle it into the
1231 : // name.
7: branch 1 taken
2: branch 2 taken
1232 9: if (Name == "apcs-gnu") {
1233 7: DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
1234 7: SizeType = UnsignedLong;
1235 :
1: branch 0 taken
6: branch 1 taken
1236 7: if (IsThumb) {
1237 : DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1238 : "i64:32:32-f32:32:32-f64:32:32-"
1239 1: "v64:64:64-v128:128:128-a0:0:32-n32");
1240 : } else {
1241 : DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1242 : "i64:32:32-f32:32:32-f64:32:32-"
1243 6: "v64:64:64-v128:128:128-a0:0:64-n32");
1244 : }
1245 :
1246 : // FIXME: Override "preferred align" for double and long long.
0: branch 1 not taken
2: branch 2 taken
1247 2: } else if (Name == "aapcs") {
1248 : // FIXME: Enumerated types are variable width in straight AAPCS.
0: branch 1 not taken
0: branch 2 not taken
1249 0: } else if (Name == "aapcs-linux") {
1250 : ;
1251 : } else
1252 0: return false;
1253 :
1254 9: return true;
1255 : }
1256 :
1257 : void getDefaultFeatures(const std::string &CPU,
1258 15: llvm::StringMap<bool> &Features) const {
1259 : // FIXME: This should not be here.
1260 15: Features["vfp2"] = false;
1261 15: Features["vfp3"] = false;
1262 15: Features["neon"] = false;
1263 :
15: branch 1 taken
0: branch 2 not taken
15: branch 4 taken
0: branch 5 not taken
0: branch 7 not taken
15: branch 8 taken
0: branch 9 not taken
15: branch 10 taken
1264 15: if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1265 0: Features["vfp2"] = true;
14: branch 1 taken
1: branch 2 taken
0: branch 4 not taken
14: branch 5 taken
1: branch 6 taken
14: branch 7 taken
1266 15: else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1267 1: Features["neon"] = true;
1268 15: }
1269 :
1270 : virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1271 : const std::string &Name,
1272 7: bool Enabled) const {
4: branch 1 taken
3: branch 2 taken
4: branch 4 taken
0: branch 5 not taken
7: branch 6 taken
0: branch 7 not taken
1273 7: if (Name == "soft-float" || Name == "soft-float-abi") {
1274 7: Features[Name] = Enabled;
0: branch 1 not taken
0: branch 2 not taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
1275 0: } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1276 : // These effectively are a single option, reset them when any is enabled.
0: branch 0 not taken
0: branch 1 not taken
1277 0: if (Enabled)
1278 0: Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1279 0: Features[Name] = Enabled;
1280 : } else
1281 0: return false;
1282 :
1283 7: return true;
1284 : }
1285 :
1286 15: virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
1287 15: FPU = NoFPU;
1288 15: SoftFloat = SoftFloatABI = false;
52: branch 1 taken
15: branch 2 taken
1289 67: for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3: branch 2 taken
49: branch 3 taken
1290 52: if (Features[i] == "+soft-float")
1291 3: SoftFloat = true;
4: branch 2 taken
45: branch 3 taken
1292 49: else if (Features[i] == "+soft-float-abi")
1293 4: SoftFloatABI = true;
0: branch 2 not taken
45: branch 3 taken
1294 45: else if (Features[i] == "+vfp2")
1295 0: FPU = VFP2FPU;
0: branch 2 not taken
45: branch 3 taken
1296 45: else if (Features[i] == "+vfp3")
1297 0: FPU = VFP3FPU;
1: branch 2 taken
44: branch 3 taken
1298 45: else if (Features[i] == "+neon")
1299 1: FPU = NeonFPU;
1300 : }
1301 :
1302 : // Remove front-end specific options which the backend handles differently.
1303 15: std::vector<std::string>::iterator it;
1304 15: it = std::find(Features.begin(), Features.end(), "+soft-float");
3: branch 2 taken
12: branch 3 taken
1305 15: if (it != Features.end())
1306 3: Features.erase(it);
1307 15: it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
4: branch 2 taken
11: branch 3 taken
1308 15: if (it != Features.end())
1309 4: Features.erase(it);
1310 15: }
1311 :
1312 19: static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1313 : return llvm::StringSwitch<const char*>(Name)
1314 : .Cases("arm8", "arm810", "4")
1315 : .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1316 : .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1317 : .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1318 : .Case("ep9312", "4T")
1319 : .Cases("arm10tdmi", "arm1020t", "5T")
1320 : .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1321 : .Case("arm926ej-s", "5TEJ")
1322 : .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1323 : .Cases("xscale", "iwmmxt", "5TE")
1324 : .Case("arm1136j-s", "6J")
1325 : .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
1326 : .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
1327 : .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1328 : .Cases("cortex-a8", "cortex-a9", "7A")
1329 19: .Default(0);
1330 : }
1331 4: virtual bool setCPU(const std::string &Name) {
0: branch 2 not taken
4: branch 3 taken
1332 4: if (!getCPUDefineSuffix(Name))
1333 0: return false;
1334 :
1335 4: CPU = Name;
1336 4: return true;
1337 : }
1338 : virtual void getTargetDefines(const LangOptions &Opts,
1339 15: MacroBuilder &Builder) const {
1340 : // Target identification.
1341 15: Builder.defineMacro("__arm");
1342 15: Builder.defineMacro("__arm__");
1343 :
1344 : // Target properties.
1345 15: Builder.defineMacro("__ARMEL__");
1346 15: Builder.defineMacro("__LITTLE_ENDIAN__");
1347 15: Builder.defineMacro("__REGISTER_PREFIX__", "");
1348 :
1349 15: llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
1350 15: Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
1351 :
1352 : // Subtarget options.
1353 :
1354 : // FIXME: It's more complicated than this and we don't really support
1355 : // interworking.
12: branch 1 taken
3: branch 2 taken
12: branch 4 taken
0: branch 5 not taken
12: branch 6 taken
3: branch 7 taken
1356 15: if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
1357 12: Builder.defineMacro("__THUMB_INTERWORK__");
1358 :
13: branch 1 taken
2: branch 2 taken
6: branch 4 taken
7: branch 5 taken
8: branch 6 taken
7: branch 7 taken
1359 15: if (ABI == "aapcs" || ABI == "aapcs-linux")
1360 8: Builder.defineMacro("__ARM_EABI__");
1361 :
3: branch 0 taken
12: branch 1 taken
1362 15: if (SoftFloat)
1363 3: Builder.defineMacro("__SOFTFP__");
1364 :
0: branch 1 not taken
15: branch 2 taken
1365 15: if (CPU == "xscale")
1366 0: Builder.defineMacro("__XSCALE__");
1367 :
1: branch 0 taken
14: branch 1 taken
1: branch 4 taken
0: branch 5 not taken
1: branch 8 taken
0: branch 9 not taken
1368 15: bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
1: branch 0 taken
14: branch 1 taken
1369 15: if (IsThumb) {
1370 1: Builder.defineMacro("__THUMBEL__");
1371 1: Builder.defineMacro("__thumb__");
1: branch 0 taken
0: branch 1 not taken
1372 1: if (IsThumb2)
1373 1: Builder.defineMacro("__thumb2__");
1374 : }
1375 :
1376 : // Note, this is always on in gcc, even though it doesn't make sense.
1377 15: Builder.defineMacro("__APCS_32__");
1378 :
1: branch 1 taken
14: branch 2 taken
1379 15: if (FPUModeIsVFP((FPUMode) FPU))
1380 1: Builder.defineMacro("__VFP_FP__");
1381 :
1382 : // This only gets set when Neon instructions are actually available, unlike
1383 : // the VFP define, hence the soft float and arch check. This is subtly
1384 : // different from gcc, we follow the intent which was that it should be set
1385 : // when Neon instructions are actually available.
1: branch 0 taken
14: branch 1 taken
1: branch 2 taken
0: branch 3 not taken
1: branch 4 taken
0: branch 5 not taken
1386 15: if (FPU == NeonFPU && !SoftFloat && IsThumb2)
1387 1: Builder.defineMacro("__ARM_NEON__");
1388 :
7: branch 2 taken
8: branch 3 taken
1389 15: if (getTriple().getOS() == llvm::Triple::Darwin)
1390 7: Builder.defineMacro("__USING_SJLJ_EXCEPTIONS__");
1391 15: }
1392 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1393 15: unsigned &NumRecords) const {
1394 : // FIXME: Implement.
1395 15: Records = 0;
1396 15: NumRecords = 0;
1397 15: }
1398 15: virtual const char *getVAListDeclaration() const {
1399 15: return "typedef char* __builtin_va_list;";
1400 : }
1401 : virtual void getGCCRegNames(const char * const *&Names,
1402 : unsigned &NumNames) const;
1403 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1404 : unsigned &NumAliases) const;
1405 : virtual bool validateAsmConstraint(const char *&Name,
1406 0: TargetInfo::ConstraintInfo &Info) const {
1407 : // FIXME: Check if this is complete
1408 0: switch (*Name) {
1409 : default:
1410 : case 'l': // r0-r7
1411 : case 'h': // r8-r15
1412 : case 'w': // VFP Floating point register single precision
1413 : case 'P': // VFP Floating point register double precision
1414 0: Info.setAllowsRegister();
1415 0: return true;
1416 : }
1417 : return false;
1418 : }
1419 6: virtual const char *getClobbers() const {
1420 : // FIXME: Is this really right?
1421 6: return "";
1422 : }
1423 : };
1424 :
1425 : const char * const ARMTargetInfo::GCCRegNames[] = {
1426 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1427 : "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1428 : };
1429 :
1430 : void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
1431 50: unsigned &NumNames) const {
1432 50: Names = GCCRegNames;
1433 50: NumNames = llvm::array_lengthof(GCCRegNames);
1434 50: }
1435 :
1436 : const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
1437 :
1438 : { { "a1" }, "r0" },
1439 : { { "a2" }, "r1" },
1440 : { { "a3" }, "r2" },
1441 : { { "a4" }, "r3" },
1442 : { { "v1" }, "r4" },
1443 : { { "v2" }, "r5" },
1444 : { { "v3" }, "r6" },
1445 : { { "v4" }, "r7" },
1446 : { { "v5" }, "r8" },
1447 : { { "v6", "rfp" }, "r9" },
1448 : { { "sl" }, "r10" },
1449 : { { "fp" }, "r11" },
1450 : { { "ip" }, "r12" },
1451 : { { "sp" }, "r13" },
1452 : { { "lr" }, "r14" },
1453 : { { "pc" }, "r15" },
1454 : };
1455 :
1456 : void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1457 34: unsigned &NumAliases) const {
1458 34: Aliases = GCCRegAliases;
1459 34: NumAliases = llvm::array_lengthof(GCCRegAliases);
1460 34: }
1461 : } // end anonymous namespace.
1462 :
1463 :
1464 : namespace {
1465 : class DarwinARMTargetInfo :
7: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1466 7: public DarwinTargetInfo<ARMTargetInfo> {
1467 : protected:
1468 : virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
1469 7: MacroBuilder &Builder) const {
1470 7: getDarwinDefines(Builder, Opts, Triple);
1471 7: }
1472 :
1473 : public:
1474 7: DarwinARMTargetInfo(const std::string& triple)
1475 7: : DarwinTargetInfo<ARMTargetInfo>(triple) {}
1476 : };
1477 : } // end anonymous namespace.
1478 :
1479 : namespace {
0: branch 1 not taken
1: branch 2 taken
3: branch 5 taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
1480 4: class SparcV8TargetInfo : public TargetInfo {
1481 : static const TargetInfo::GCCRegAlias GCCRegAliases[];
1482 : static const char * const GCCRegNames[];
1483 : public:
1484 4: SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1485 : // FIXME: Support Sparc quad-precision long double?
1486 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1487 4: "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
1488 4: }
1489 : virtual void getTargetDefines(const LangOptions &Opts,
1490 4: MacroBuilder &Builder) const {
1491 4: DefineStd(Builder, "sparc", Opts);
1492 4: Builder.defineMacro("__sparcv8");
1493 4: Builder.defineMacro("__REGISTER_PREFIX__", "");
1494 4: }
1495 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1496 4: unsigned &NumRecords) const {
1497 : // FIXME: Implement!
1498 4: }
1499 4: virtual const char *getVAListDeclaration() const {
1500 4: return "typedef void* __builtin_va_list;";
1501 : }
1502 : virtual void getGCCRegNames(const char * const *&Names,
1503 : unsigned &NumNames) const;
1504 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1505 : unsigned &NumAliases) const;
1506 : virtual bool validateAsmConstraint(const char *&Name,
1507 0: TargetInfo::ConstraintInfo &info) const {
1508 : // FIXME: Implement!
1509 0: return false;
1510 : }
1511 0: virtual const char *getClobbers() const {
1512 : // FIXME: Implement!
1513 0: return "";
1514 : }
1515 : };
1516 :
1517 : const char * const SparcV8TargetInfo::GCCRegNames[] = {
1518 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1519 : "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1520 : "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1521 : "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1522 : };
1523 :
1524 : void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
1525 0: unsigned &NumNames) const {
1526 0: Names = GCCRegNames;
1527 0: NumNames = llvm::array_lengthof(GCCRegNames);
1528 0: }
1529 :
1530 : const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
1531 : { { "g0" }, "r0" },
1532 : { { "g1" }, "r1" },
1533 : { { "g2" }, "r2" },
1534 : { { "g3" }, "r3" },
1535 : { { "g4" }, "r4" },
1536 : { { "g5" }, "r5" },
1537 : { { "g6" }, "r6" },
1538 : { { "g7" }, "r7" },
1539 : { { "o0" }, "r8" },
1540 : { { "o1" }, "r9" },
1541 : { { "o2" }, "r10" },
1542 : { { "o3" }, "r11" },
1543 : { { "o4" }, "r12" },
1544 : { { "o5" }, "r13" },
1545 : { { "o6", "sp" }, "r14" },
1546 : { { "o7" }, "r15" },
1547 : { { "l0" }, "r16" },
1548 : { { "l1" }, "r17" },
1549 : { { "l2" }, "r18" },
1550 : { { "l3" }, "r19" },
1551 : { { "l4" }, "r20" },
1552 : { { "l5" }, "r21" },
1553 : { { "l6" }, "r22" },
1554 : { { "l7" }, "r23" },
1555 : { { "i0" }, "r24" },
1556 : { { "i1" }, "r25" },
1557 : { { "i2" }, "r26" },
1558 : { { "i3" }, "r27" },
1559 : { { "i4" }, "r28" },
1560 : { { "i5" }, "r29" },
1561 : { { "i6", "fp" }, "r30" },
1562 : { { "i7" }, "r31" },
1563 : };
1564 :
1565 : void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1566 0: unsigned &NumAliases) const {
1567 0: Aliases = GCCRegAliases;
1568 0: NumAliases = llvm::array_lengthof(GCCRegAliases);
1569 0: }
1570 : } // end anonymous namespace.
1571 :
1572 : namespace {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1573 0: class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
1574 : public:
1575 0: AuroraUXSparcV8TargetInfo(const std::string& triple) :
1576 0: AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
1577 0: SizeType = UnsignedInt;
1578 0: PtrDiffType = SignedInt;
1579 0: }
1580 : };
1: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1581 1: class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
1582 : public:
1583 1: SolarisSparcV8TargetInfo(const std::string& triple) :
1584 1: SolarisTargetInfo<SparcV8TargetInfo>(triple) {
1585 1: SizeType = UnsignedInt;
1586 1: PtrDiffType = SignedInt;
1587 1: }
1588 : };
1589 : } // end anonymous namespace.
1590 :
1591 : namespace {
5: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1592 5: class PIC16TargetInfo : public TargetInfo{
1593 : public:
1594 5: PIC16TargetInfo(const std::string& triple) : TargetInfo(triple) {
1595 5: TLSSupported = false;
1596 5: IntWidth = 16;
1597 5: LongWidth = LongLongWidth = 32;
1598 5: PointerWidth = 16;
1599 5: IntAlign = 8;
1600 5: LongAlign = LongLongAlign = 8;
1601 5: PointerAlign = 8;
1602 5: SizeType = UnsignedInt;
1603 5: IntMaxType = SignedLong;
1604 5: UIntMaxType = UnsignedLong;
1605 5: IntPtrType = SignedShort;
1606 5: PtrDiffType = SignedInt;
1607 5: SigAtomicType = SignedLong;
1608 5: FloatWidth = 32;
1609 5: FloatAlign = 32;
1610 5: DoubleWidth = 32;
1611 5: DoubleAlign = 32;
1612 5: LongDoubleWidth = 32;
1613 5: LongDoubleAlign = 32;
1614 5: FloatFormat = &llvm::APFloat::IEEEsingle;
1615 5: DoubleFormat = &llvm::APFloat::IEEEsingle;
1616 5: LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1617 5: DescriptionString = "e-p:16:8:8-i8:8:8-i16:8:8-i32:8:8-f32:32:32-n8";
1618 :
1619 5: }
1620 0: virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return 16; }
1621 0: virtual uint64_t getPointerAlignV(unsigned AddrSpace) const { return 8; }
1622 : virtual void getTargetDefines(const LangOptions &Opts,
1623 5: MacroBuilder &Builder) const {
1624 5: Builder.defineMacro("__pic16");
1625 5: Builder.defineMacro("rom", "__attribute__((address_space(1)))");
1626 5: Builder.defineMacro("ram", "__attribute__((address_space(0)))");
1627 : Builder.defineMacro("_section(SectName)",
1628 5: "__attribute__((section(SectName)))");
1629 : Builder.defineMacro("near",
1630 5: "__attribute__((section(\"Address=NEAR\")))");
1631 : Builder.defineMacro("_address(Addr)",
1632 5: "__attribute__((section(\"Address=\"#Addr)))");
1633 5: Builder.defineMacro("_CONFIG(conf)", "asm(\"CONFIG \"#conf)");
1634 : Builder.defineMacro("_interrupt",
1635 : "__attribute__((section(\"interrupt=0x4\"))) \
1636 5: __attribute__((used))");
1637 5: }
1638 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1639 5: unsigned &NumRecords) const {}
1640 5: virtual const char *getVAListDeclaration() const {
1641 5: return "";
1642 : }
1643 0: virtual const char *getClobbers() const {
1644 0: return "";
1645 : }
1646 : virtual void getGCCRegNames(const char * const *&Names,
1647 0: unsigned &NumNames) const {}
1648 : virtual bool validateAsmConstraint(const char *&Name,
1649 0: TargetInfo::ConstraintInfo &info) const {
1650 0: return true;
1651 : }
1652 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1653 0: unsigned &NumAliases) const {}
1654 0: virtual bool useGlobalsForAutomaticVariables() const {return true;}
1655 : };
1656 : }
1657 :
1658 : namespace {
2: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1659 2: class MSP430TargetInfo : public TargetInfo {
1660 : static const char * const GCCRegNames[];
1661 : public:
1662 2: MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
1663 2: TLSSupported = false;
1664 2: IntWidth = 16; IntAlign = 16;
1665 2: LongWidth = 32; LongLongWidth = 64;
1666 2: LongAlign = LongLongAlign = 16;
1667 2: PointerWidth = 16; PointerAlign = 16;
1668 2: SizeType = UnsignedInt;
1669 2: IntMaxType = SignedLong;
1670 2: UIntMaxType = UnsignedLong;
1671 2: IntPtrType = SignedShort;
1672 2: PtrDiffType = SignedInt;
1673 2: SigAtomicType = SignedLong;
1674 2: DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
1675 2: }
1676 : virtual void getTargetDefines(const LangOptions &Opts,
1677 2: MacroBuilder &Builder) const {
1678 2: Builder.defineMacro("MSP430");
1679 2: Builder.defineMacro("__MSP430__");
1680 : // FIXME: defines for different 'flavours' of MCU
1681 2: }
1682 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1683 2: unsigned &NumRecords) const {
1684 : // FIXME: Implement.
1685 2: Records = 0;
1686 2: NumRecords = 0;
1687 2: }
1688 : virtual void getGCCRegNames(const char * const *&Names,
1689 : unsigned &NumNames) const;
1690 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1691 0: unsigned &NumAliases) const {
1692 : // No aliases.
1693 0: Aliases = 0;
1694 0: NumAliases = 0;
1695 0: }
1696 : virtual bool validateAsmConstraint(const char *&Name,
1697 0: TargetInfo::ConstraintInfo &info) const {
1698 : // No target constraints for now.
1699 0: return false;
1700 : }
1701 0: virtual const char *getClobbers() const {
1702 : // FIXME: Is this really right?
1703 0: return "";
1704 : }
1705 2: virtual const char *getVAListDeclaration() const {
1706 : // FIXME: implement
1707 2: return "typedef char* __builtin_va_list;";
1708 : }
1709 : };
1710 :
1711 : const char * const MSP430TargetInfo::GCCRegNames[] = {
1712 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1713 : "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1714 : };
1715 :
1716 : void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
1717 0: unsigned &NumNames) const {
1718 0: Names = GCCRegNames;
1719 0: NumNames = llvm::array_lengthof(GCCRegNames);
1720 0: }
1721 : }
1722 :
1723 :
1724 : namespace {
2: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1725 2: class SystemZTargetInfo : public TargetInfo {
1726 : static const char * const GCCRegNames[];
1727 : public:
1728 2: SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
1729 2: TLSSupported = false;
1730 2: IntWidth = IntAlign = 32;
1731 2: LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
1732 2: PointerWidth = PointerAlign = 64;
1733 : DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
1734 2: "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
1735 2: }
1736 : virtual void getTargetDefines(const LangOptions &Opts,
1737 2: MacroBuilder &Builder) const {
1738 2: Builder.defineMacro("__s390__");
1739 2: Builder.defineMacro("__s390x__");
1740 2: }
1741 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1742 2: unsigned &NumRecords) const {
1743 : // FIXME: Implement.
1744 2: Records = 0;
1745 2: NumRecords = 0;
1746 2: }
1747 :
1748 : virtual void getGCCRegNames(const char * const *&Names,
1749 : unsigned &NumNames) const;
1750 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1751 0: unsigned &NumAliases) const {
1752 : // No aliases.
1753 0: Aliases = 0;
1754 0: NumAliases = 0;
1755 0: }
1756 : virtual bool validateAsmConstraint(const char *&Name,
1757 0: TargetInfo::ConstraintInfo &info) const {
1758 : // FIXME: implement
1759 0: return true;
1760 : }
1761 0: virtual const char *getClobbers() const {
1762 : // FIXME: Is this really right?
1763 0: return "";
1764 : }
1765 2: virtual const char *getVAListDeclaration() const {
1766 : // FIXME: implement
1767 2: return "typedef char* __builtin_va_list;";
1768 : }
1769 : };
1770 :
1771 : const char * const SystemZTargetInfo::GCCRegNames[] = {
1772 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1773 : "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1774 : };
1775 :
1776 : void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
1777 0: unsigned &NumNames) const {
1778 0: Names = GCCRegNames;
1779 0: NumNames = llvm::array_lengthof(GCCRegNames);
1780 0: }
1781 : }
1782 :
1783 : namespace {
3: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1784 3: class BlackfinTargetInfo : public TargetInfo {
1785 : static const char * const GCCRegNames[];
1786 : public:
1787 3: BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
1788 3: TLSSupported = false;
1789 3: DoubleAlign = 32;
1790 3: LongLongAlign = 32;
1791 3: LongDoubleAlign = 32;
1792 3: DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
1793 3: }
1794 :
1795 : virtual void getTargetDefines(const LangOptions &Opts,
1796 3: MacroBuilder &Builder) const {
1797 3: DefineStd(Builder, "bfin", Opts);
1798 3: DefineStd(Builder, "BFIN", Opts);
1799 3: Builder.defineMacro("__ADSPBLACKFIN__");
1800 : // FIXME: This one is really dependent on -mcpu
1801 3: Builder.defineMacro("__ADSPLPBLACKFIN__");
1802 : // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
1803 3: }
1804 :
1805 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1806 3: unsigned &NumRecords) const {
1807 : // FIXME: Implement.
1808 3: Records = 0;
1809 3: NumRecords = 0;
1810 3: }
1811 :
1812 : virtual void getGCCRegNames(const char * const *&Names,
1813 : unsigned &NumNames) const;
1814 :
1815 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1816 0: unsigned &NumAliases) const {
1817 : // No aliases.
1818 0: Aliases = 0;
1819 0: NumAliases = 0;
1820 0: }
1821 :
1822 : virtual bool validateAsmConstraint(const char *&Name,
1823 0: TargetInfo::ConstraintInfo &Info) const {
0: branch 1 not taken
0: branch 2 not taken
1824 0: if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
1825 0: Info.setAllowsRegister();
1826 0: return true;
1827 : }
1828 0: return false;
1829 : }
1830 :
1831 0: virtual const char *getClobbers() const {
1832 0: return "";
1833 : }
1834 :
1835 3: virtual const char *getVAListDeclaration() const {
1836 3: return "typedef char* __builtin_va_list;";
1837 : }
1838 : };
1839 :
1840 : const char * const BlackfinTargetInfo::GCCRegNames[] = {
1841 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1842 : "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
1843 : "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
1844 : "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
1845 : "a0", "a1", "cc",
1846 : "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
1847 : "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
1848 : };
1849 :
1850 : void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
1851 0: unsigned &NumNames) const {
1852 0: Names = GCCRegNames;
1853 0: NumNames = llvm::array_lengthof(GCCRegNames);
1854 0: }
1855 : }
1856 :
1857 : namespace {
1858 :
1859 : // LLVM and Clang cannot be used directly to output native binaries for
1860 : // target, but is used to compile C code to llvm bitcode with correct
1861 : // type and alignment information.
1862 : //
1863 : // TCE uses the llvm bitcode as input and uses it for generating customized
1864 : // target processor and program binary. TCE co-design environment is
1865 : // publicly available in http://tce.cs.tut.fi
1866 :
2: branch 1 taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
1867 2: class TCETargetInfo : public TargetInfo{
1868 : public:
1869 2: TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
1870 2: TLSSupported = false;
1871 2: IntWidth = 32;
1872 2: LongWidth = LongLongWidth = 32;
1873 2: PointerWidth = 32;
1874 2: IntAlign = 32;
1875 2: LongAlign = LongLongAlign = 32;
1876 2: PointerAlign = 32;
1877 2: SizeType = UnsignedInt;
1878 2: IntMaxType = SignedLong;
1879 2: UIntMaxType = UnsignedLong;
1880 2: IntPtrType = SignedInt;
1881 2: PtrDiffType = SignedInt;
1882 2: FloatWidth = 32;
1883 2: FloatAlign = 32;
1884 2: DoubleWidth = 32;
1885 2: DoubleAlign = 32;
1886 2: LongDoubleWidth = 32;
1887 2: LongDoubleAlign = 32;
1888 2: FloatFormat = &llvm::APFloat::IEEEsingle;
1889 2: DoubleFormat = &llvm::APFloat::IEEEsingle;
1890 2: LongDoubleFormat = &llvm::APFloat::IEEEsingle;
1891 : DescriptionString = "E-p:32:32:32-a0:32:32"
1892 : "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
1893 2: "-f32:32:32-f64:32:64-n32";
1894 2: }
1895 :
1896 : virtual void getTargetDefines(const LangOptions &Opts,
1897 2: MacroBuilder &Builder) const {
1898 2: DefineStd(Builder, "tce", Opts);
1899 2: Builder.defineMacro("__TCE__");
1900 2: Builder.defineMacro("__TCE_V1__");
1901 2: }
1902 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1903 2: unsigned &NumRecords) const {}
1904 0: virtual const char *getClobbers() const {
1905 0: return "";
1906 : }
1907 2: virtual const char *getVAListDeclaration() const {
1908 2: return "typedef void* __builtin_va_list;";
1909 : }
1910 : virtual void getGCCRegNames(const char * const *&Names,
1911 0: unsigned &NumNames) const {}
1912 : virtual bool validateAsmConstraint(const char *&Name,
1913 0: TargetInfo::ConstraintInfo &info) const {
1914 0: return true;
1915 : }
1916 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1917 0: unsigned &NumAliases) const {}
1918 : };
1919 : }
1920 :
1921 : namespace {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
1922 0: class MipsTargetInfo : public TargetInfo {
1923 : static const TargetInfo::GCCRegAlias GCCRegAliases[];
1924 : static const char * const GCCRegNames[];
1925 : public:
1926 0: MipsTargetInfo(const std::string& triple) : TargetInfo(triple) {
1927 : DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
1928 0: "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
1929 0: }
1930 : virtual void getTargetDefines(const LangOptions &Opts,
1931 0: MacroBuilder &Builder) const {
1932 0: DefineStd(Builder, "mips", Opts);
1933 0: Builder.defineMacro("_mips");
1934 0: DefineStd(Builder, "MIPSEB", Opts);
1935 0: Builder.defineMacro("_MIPSEB");
1936 0: Builder.defineMacro("__REGISTER_PREFIX__", "");
1937 0: }
1938 : virtual void getTargetBuiltins(const Builtin::Info *&Records,
1939 0: unsigned &NumRecords) const {
1940 : // FIXME: Implement!
1941 0: }
1942 0: virtual const char *getVAListDeclaration() const {
1943 0: return "typedef void* __builtin_va_list;";
1944 : }
1945 : virtual void getGCCRegNames(const char * const *&Names,
1946 : unsigned &NumNames) const;
1947 : virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1948 : unsigned &NumAliases) const;
1949 : virtual bool validateAsmConstraint(const char *&Name,
1950 0: TargetInfo::ConstraintInfo &Info) const {
1951 0: switch (*Name) {
1952 : default:
1953 : case 'r': // CPU registers.
1954 : case 'd': // Equivalent to "r" unless generating MIPS16 code.
1955 : case 'y': // Equivalent to "r", backwards compatibility only.
1956 : case 'f': // floating-point registers.
1957 0: Info.setAllowsRegister();
1958 0: return true;
1959 : }
1960 : return false;
1961 : }
1962 :
1963 0: virtual const char *getClobbers() const {
1964 : // FIXME: Implement!
1965 0: return "";
1966 : }
1967 : };
1968 :
1969 : const char * const MipsTargetInfo::GCCRegNames[] = {
1970 : "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
1971 : "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
1972 : "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
1973 : "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
1974 : "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1975 : "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1976 : "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1977 : "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1978 : "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
1979 : "$fcc5","$fcc6","$fcc7"
1980 : };
1981 :
1982 : void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
1983 0: unsigned &NumNames) const {
1984 0: Names = GCCRegNames;
1985 0: NumNames = llvm::array_lengthof(GCCRegNames);
1986 0: }
1987 :
1988 : const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
1989 : { { "at" }, "$1" },
1990 : { { "v0" }, "$2" },
1991 : { { "v1" }, "$3" },
1992 : { { "a0" }, "$4" },
1993 : { { "a1" }, "$5" },
1994 : { { "a2" }, "$6" },
1995 : { { "a3" }, "$7" },
1996 : { { "t0" }, "$8" },
1997 : { { "t1" }, "$9" },
1998 : { { "t2" }, "$10" },
1999 : { { "t3" }, "$11" },
2000 : { { "t4" }, "$12" },
2001 : { { "t5" }, "$13" },
2002 : { { "t6" }, "$14" },
2003 : { { "t7" }, "$15" },
2004 : { { "s0" }, "$16" },
2005 : { { "s1" }, "$17" },
2006 : { { "s2" }, "$18" },
2007 : { { "s3" }, "$19" },
2008 : { { "s4" }, "$20" },
2009 : { { "s5" }, "$21" },
2010 : { { "s6" }, "$22" },
2011 : { { "s7" }, "$23" },
2012 : { { "t8" }, "$24" },
2013 : { { "t9" }, "$25" },
2014 : { { "k0" }, "$26" },
2015 : { { "k1" }, "$27" },
2016 : { { "gp" }, "$28" },
2017 : { { "sp" }, "$29" },
2018 : { { "fp" }, "$30" },
2019 : { { "ra" }, "$31" }
2020 : };
2021 :
2022 : void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2023 0: unsigned &NumAliases) const {
2024 0: Aliases = GCCRegAliases;
2025 0: NumAliases = llvm::array_lengthof(GCCRegAliases);
2026 0: }
2027 : } // end anonymous namespace.
2028 :
2029 : namespace {
0: branch 1 not taken
0: branch 2 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 9 not taken
0: branch 10 not taken
2030 0: class MipselTargetInfo : public MipsTargetInfo {
2031 : public:
2032 0: MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2033 : DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2034 0: "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2035 0: }
2036 :
2037 : virtual void getTargetDefines(const LangOptions &Opts,
2038 : MacroBuilder &Builder) const;
2039 : };
2040 :
2041 : void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
2042 0: MacroBuilder &Builder) const {
2043 0: DefineStd(Builder, "mips", Opts);
2044 0: Builder.defineMacro("_mips");
2045 0: DefineStd(Builder, "MIPSEL", Opts);
2046 0: Builder.defineMacro("_MIPSEL");
2047 0: Builder.defineMacro("__REGISTER_PREFIX__", "");
2048 0: }
2049 : } // end anonymous namespace.
2050 :
2051 : //===----------------------------------------------------------------------===//
2052 : // Driver code
2053 : //===----------------------------------------------------------------------===//
2054 :
2055 2535: static TargetInfo *AllocateTarget(const std::string &T) {
2056 2535: llvm::Triple Triple(T);
2057 2535: llvm::Triple::OSType os = Triple.getOS();
2058 :
0: branch 1 not taken
15: branch 2 taken
3: branch 3 taken
2: branch 4 taken
0: branch 5 not taken
0: branch 6 not taken
5: branch 7 taken
6: branch 8 taken
4: branch 9 taken
4: branch 10 taken
0: branch 11 not taken
2: branch 12 taken
2: branch 13 taken
2290: branch 14 taken
202: branch 15 taken
2059 2535: switch (Triple.getArch()) {
2060 : default:
2061 0: return NULL;
2062 :
2063 : case llvm::Triple::arm:
2064 : case llvm::Triple::thumb:
7: branch 0 taken
0: branch 1 not taken
8: branch 2 taken
2065 15: switch (os) {
2066 : case llvm::Triple::Darwin:
2067 7: return new DarwinARMTargetInfo(T);
2068 : case llvm::Triple::FreeBSD:
2069 0: return new FreeBSDTargetInfo<ARMTargetInfo>(T);
2070 : default:
2071 8: return new ARMTargetInfo(T);
2072 : }
2073 :
2074 : case llvm::Triple::bfin:
2075 3: return new BlackfinTargetInfo(T);
2076 :
2077 : case llvm::Triple::msp430:
2078 2: return new MSP430TargetInfo(T);
2079 :
2080 : case llvm::Triple::mips:
0: branch 0 not taken
0: branch 1 not taken
2081 0: if (os == llvm::Triple::Psp)
2082 0: return new PSPTargetInfo<MipsTargetInfo>(T);
0: branch 0 not taken
0: branch 1 not taken
2083 0: if (os == llvm::Triple::Linux)
2084 0: return new LinuxTargetInfo<MipsTargetInfo>(T);
2085 0: return new MipsTargetInfo(T);
2086 :
2087 : case llvm::Triple::mipsel:
0: branch 0 not taken
0: branch 1 not taken
2088 0: if (os == llvm::Triple::Psp)
2089 0: return new PSPTargetInfo<MipselTargetInfo>(T);
0: branch 0 not taken
0: branch 1 not taken
2090 0: if (os == llvm::Triple::Linux)
2091 0: return new LinuxTargetInfo<MipselTargetInfo>(T);
2092 0: return new MipselTargetInfo(T);
2093 :
2094 : case llvm::Triple::pic16:
2095 5: return new PIC16TargetInfo(T);
2096 :
2097 : case llvm::Triple::ppc:
2: branch 0 taken
4: branch 1 taken
2098 6: if (os == llvm::Triple::Darwin)
2099 2: return new DarwinTargetInfo<PPCTargetInfo>(T);
2100 4: return new PPC32TargetInfo(T);
2101 :
2102 : case llvm::Triple::ppc64:
1: branch 0 taken
3: branch 1 taken
2103 4: if (os == llvm::Triple::Darwin)
2104 1: return new DarwinTargetInfo<PPC64TargetInfo>(T);
0: branch 0 not taken
3: branch 1 taken
2105 3: else if (os == llvm::Triple::Lv2)
2106 0: return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
2107 3: return new PPC64TargetInfo(T);
2108 :
2109 : case llvm::Triple::sparc:
0: branch 0 not taken
4: branch 1 taken
2110 4: if (os == llvm::Triple::AuroraUX)
2111 0: return new AuroraUXSparcV8TargetInfo(T);
1: branch 0 taken
3: branch 1 taken
2112 4: if (os == llvm::Triple::Solaris)
2113 1: return new SolarisSparcV8TargetInfo(T);
2114 3: return new SparcV8TargetInfo(T);
2115 :
2116 : // FIXME: Need a real SPU target.
2117 : case llvm::Triple::cellspu:
2118 0: return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2119 :
2120 : case llvm::Triple::systemz:
2121 2: return new SystemZTargetInfo(T);
2122 :
2123 : case llvm::Triple::tce:
2124 2: return new TCETargetInfo(T);
2125 :
2126 : case llvm::Triple::x86:
0: branch 0 not taken
126: branch 1 taken
2094: branch 2 taken
1: branch 3 taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
2: branch 10 taken
67: branch 11 taken
2127 2290: switch (os) {
2128 : case llvm::Triple::AuroraUX:
2129 0: return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
2130 : case llvm::Triple::Darwin:
2131 126: return new DarwinI386TargetInfo(T);
2132 : case llvm::Triple::Linux:
2133 2094: return new LinuxTargetInfo<X86_32TargetInfo>(T);
2134 : case llvm::Triple::DragonFly:
2135 1: return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2136 : case llvm::Triple::NetBSD:
2137 0: return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2138 : case llvm::Triple::OpenBSD:
2139 0: return new OpenBSDI386TargetInfo(T);
2140 : case llvm::Triple::FreeBSD:
2141 0: return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
2142 : case llvm::Triple::Solaris:
2143 0: return new SolarisTargetInfo<X86_32TargetInfo>(T);
2144 : case llvm::Triple::Cygwin:
2145 0: return new CygwinX86_32TargetInfo(T);
2146 : case llvm::Triple::MinGW32:
2147 0: return new MinGWX86_32TargetInfo(T);
2148 : case llvm::Triple::Win32:
2149 2: return new VisualStudioWindowsX86_32TargetInfo(T);
2150 : default:
2151 67: return new X86_32TargetInfo(T);
2152 : }
2153 :
2154 : case llvm::Triple::x86_64:
0: branch 0 not taken
170: branch 1 taken
4: branch 2 taken
0: branch 3 not taken
0: branch 4 not taken
0: branch 5 not taken
4: branch 6 taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
24: branch 10 taken
2155 202: switch (os) {
2156 : case llvm::Triple::AuroraUX:
2157 0: return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
2158 : case llvm::Triple::Darwin:
2159 170: return new DarwinX86_64TargetInfo(T);
2160 : case llvm::Triple::Linux:
2161 4: return new LinuxTargetInfo<X86_64TargetInfo>(T);
2162 : case llvm::Triple::DragonFly:
2163 0: return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
2164 : case llvm::Triple::NetBSD:
2165 0: return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2166 : case llvm::Triple::OpenBSD:
2167 0: return new OpenBSDX86_64TargetInfo(T);
2168 : case llvm::Triple::FreeBSD:
2169 4: return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2170 : case llvm::Triple::Solaris:
2171 0: return new SolarisTargetInfo<X86_64TargetInfo>(T);
2172 : case llvm::Triple::MinGW64:
2173 0: return new MinGWX86_64TargetInfo(T);
2174 : case llvm::Triple::Win32: // This is what Triple.h supports now.
2175 0: return new VisualStudioWindowsX86_64TargetInfo(T);
2176 : default:
2177 24: return new X86_64TargetInfo(T);
2178 : }
2179 2535: }
2180 : }
2181 :
2182 : /// CreateTargetInfo - Return the target info object for the specified target
2183 : /// triple.
2184 : TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
2185 2535: TargetOptions &Opts) {
2186 2535: llvm::Triple Triple(Opts.Triple);
2187 :
2188 : // Construct the target
2189 2535: llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
0: branch 1 not taken
2535: branch 2 taken
2190 2535: if (!Target) {
2191 0: Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2192 0: return 0;
2193 : }
2194 :
2195 : // Set the target CPU if specified.
153: branch 1 taken
2382: branch 2 taken
0: branch 5 not taken
153: branch 6 taken
0: branch 7 not taken
2535: branch 8 taken
2196 2535: if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2197 0: Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2198 0: return 0;
2199 : }
2200 :
2201 : // Set the target ABI if specified.
9: branch 1 taken
2526: branch 2 taken
0: branch 5 not taken
9: branch 6 taken
0: branch 7 not taken
2535: branch 8 taken
2202 2535: if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2203 0: Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2204 0: return 0;
2205 : }
2206 :
2207 : // Compute the default target features, we need the target to handle this
2208 : // because features may have dependencies on one another.
2209 2535: llvm::StringMap<bool> Features;
2210 2535: Target->getDefaultFeatures(Opts.CPU, Features);
2211 :
2212 : // Apply the user specified deltas.
11: branch 4 taken
2535: branch 5 taken
2213 5081: for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2214 2535: ie = Opts.Features.end(); it != ie; ++it) {
2215 11: const char *Name = it->c_str();
2216 :
2217 : // Apply the feature via the target.
10: branch 0 taken
1: branch 1 taken
10: branch 2 taken
0: branch 3 not taken
0: branch 8 not taken
11: branch 9 taken
11: branch 10 taken
0: branch 11 not taken
11: branch 13 taken
0: branch 14 not taken
0: branch 16 not taken
11: branch 17 taken
2218 11: if ((Name[0] != '-' && Name[0] != '+') ||
2219 : !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2220 0: Diags.Report(diag::err_target_invalid_feature) << Name;
2221 0: return 0;
2222 : }
2223 : }
2224 :
2225 : // Add the features to the compile options.
2226 : //
2227 : // FIXME: If we are completely confident that we have the right set, we only
2228 : // need to pass the minuses.
2229 2535: Opts.Features.clear();
22480: branch 3 taken
2535: branch 4 taken
2230 27550: for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2231 2535: ie = Features.end(); it != ie; ++it)
1077: branch 4 taken
21403: branch 5 taken
2232 22480: Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2233 2535: Target->HandleTargetFeatures(Opts.Features);
2234 :
2235 2535: return Target.take();
2236 105: }
Generated: 2010-02-10 01:31 by zcov