blob: 9afef32f05f97177cdc7a10281072011f933abac [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikove7772382009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek38591a22007-12-12 18:05:32 +000011// target triple.
Chris Lattner4b009652007-07-25 00:24:17 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner4b009652007-07-25 00:24:17 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerddae7102008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carrutha088d5b2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedmand4011892008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbarca3e9912009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar8dd8f262009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar0433a022009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar8dd8f262009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattnerf54f2212009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner43954312009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
Benjamin Kramerf8a85782010-01-09 18:20:57 +000029#include <algorithm>
Chris Lattner4b009652007-07-25 00:24:17 +000030using namespace clang;
31
Chris Lattner4b009652007-07-25 00:24:17 +000032//===----------------------------------------------------------------------===//
33// Common code shared among targets.
34//===----------------------------------------------------------------------===//
35
Chris Lattnerc345a802009-03-20 16:06:38 +000036/// 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.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000039static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattnerc345a802009-03-20 16:06:38 +000040 const LangOptions &Opts) {
41 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikove7772382009-05-03 13:42:53 +000042
Chris Lattnerc345a802009-03-20 16:06:38 +000043 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
44 // in the user's namespace.
45 if (Opts.GNUMode)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000046 Builder.defineMacro(MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000047
Chris Lattnerc345a802009-03-20 16:06:38 +000048 // Define __unix.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000049 Builder.defineMacro("__" + MacroName);
Anton Korobeynikove7772382009-05-03 13:42:53 +000050
Chris Lattnerc345a802009-03-20 16:06:38 +000051 // Define __unix__.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000052 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerc345a802009-03-20 16:06:38 +000053}
54
Chris Lattnerbd00eb82008-10-05 21:50:58 +000055//===----------------------------------------------------------------------===//
56// Defines specific to certain operating systems.
57//===----------------------------------------------------------------------===//
Chris Lattner43954312009-08-10 19:03:04 +000058
Edwin Török36565e52009-06-30 17:10:35 +000059namespace {
Douglas Gregor937331f2009-07-01 15:12:53 +000060template<typename TgtInfo>
61class OSTargetInfo : public TgtInfo {
Edwin Török36565e52009-06-30 17:10:35 +000062protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +000063 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000064 MacroBuilder &Builder) const=0;
Edwin Török36565e52009-06-30 17:10:35 +000065public:
Douglas Gregor937331f2009-07-01 15:12:53 +000066 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Edwin Török36565e52009-06-30 17:10:35 +000067 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000068 MacroBuilder &Builder) const {
69 TgtInfo::getTargetDefines(Opts, Builder);
70 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Edwin Török2d98f9f2009-06-30 17:00:25 +000071 }
Edwin Török36565e52009-06-30 17:10:35 +000072
73};
Chris Lattnerf54f2212009-08-12 06:24:27 +000074} // end anonymous namespace
Edwin Török2d98f9f2009-06-30 17:00:25 +000075
Chris Lattner43954312009-08-10 19:03:04 +000076
Daniel Dunbareab96a22010-01-26 01:44:04 +000077static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
78 const llvm::Triple &Triple) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000079 Builder.defineMacro("__APPLE_CC__", "5621");
80 Builder.defineMacro("__APPLE__");
81 Builder.defineMacro("__MACH__");
82 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikove7772382009-05-03 13:42:53 +000083
Chris Lattner8181e622009-04-07 16:50:40 +000084 // __weak is always defined, for use in blocks and with objc pointers.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000085 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikove7772382009-05-03 13:42:53 +000086
Chris Lattner8181e622009-04-07 16:50:40 +000087 // Darwin defines __strong even in C mode (just to nothing).
88 if (!Opts.ObjC1 || Opts.getGCMode() == LangOptions::NonGC)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000089 Builder.defineMacro("__strong", "");
Chris Lattner8181e622009-04-07 16:50:40 +000090 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000091 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmaneff0a422009-06-04 23:00:29 +000092
93 if (Opts.Static)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000094 Builder.defineMacro("__STATIC__");
Eli Friedmaneff0a422009-06-04 23:00:29 +000095 else
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000096 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +000097
98 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +000099 Builder.defineMacro("_REENTRANT");
Daniel Dunbar93f64532009-04-10 19:52:24 +0000100
Daniel Dunbareab96a22010-01-26 01:44:04 +0000101 // Get the OS version number from the triple.
Daniel Dunbar93f64532009-04-10 19:52:24 +0000102 unsigned Maj, Min, Rev;
Mike Stump25cf7602009-09-09 15:08:12 +0000103
Daniel Dunbareab96a22010-01-26 01:44:04 +0000104 // If no version was given, default to to 10.4.0, for simplifying tests.
105 if (Triple.getOSName() == "darwin") {
106 Min = Rev = 0;
107 Maj = 8;
108 } else
109 Triple.getDarwinNumber(Maj, Min, Rev);
110
111 // Set the appropriate OS version define.
112 if (Triple.getEnvironmentName() == "iphoneos") {
113 assert(Maj < 10 && Min < 99 && Rev < 99 && "Invalid version!");
114 char Str[6];
115 Str[0] = '0' + Maj;
116 Str[1] = '0' + (Min / 10);
117 Str[2] = '0' + (Min % 10);
118 Str[3] = '0' + (Rev / 10);
119 Str[4] = '0' + (Rev % 10);
120 Str[5] = '\0';
121 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 Rev = Min;
126 Min = Maj - 4;
127 Maj = 10;
128
129 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
130 assert(Maj < 99 && Min < 10 && Rev < 10 && "Invalid version!");
131 char Str[5];
132 Str[0] = '0' + (Maj / 10);
133 Str[1] = '0' + (Maj % 10);
134 Str[2] = '0' + Min;
135 Str[3] = '0' + Rev;
136 Str[4] = '\0';
137 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar93f64532009-04-10 19:52:24 +0000138 }
Eli Friedman872996c2008-08-20 02:34:37 +0000139}
Chris Lattner4b009652007-07-25 00:24:17 +0000140
Chris Lattner43954312009-08-10 19:03:04 +0000141namespace {
Edwin Török36565e52009-06-30 17:10:35 +0000142template<typename Target>
143class DarwinTargetInfo : public OSTargetInfo<Target> {
144protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000145 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000146 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +0000147 getDarwinDefines(Builder, Opts, Triple);
Edwin Török36565e52009-06-30 17:10:35 +0000148 }
Mike Stump25cf7602009-09-09 15:08:12 +0000149
Edwin Török36565e52009-06-30 17:10:35 +0000150public:
151 DarwinTargetInfo(const std::string& triple) :
152 OSTargetInfo<Target>(triple) {
Eric Christopherd109c622010-06-25 19:04:52 +0000153 this->TLSSupported = llvm::Triple(triple).getDarwinMajorNumber() > 10;
Edwin Török36565e52009-06-30 17:10:35 +0000154 }
155
Anders Carlsson41f80b52010-01-30 18:33:31 +0000156 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner43954312009-08-10 19:03:04 +0000157 // Let MCSectionMachO validate this.
158 llvm::StringRef Segment, Section;
159 unsigned TAA, StubSize;
160 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
161 TAA, StubSize);
162 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000163
Anders Carlsson608b5792010-06-08 22:47:50 +0000164 virtual const char *getStaticInitSectionSpecifier() const {
165 // FIXME: We should return 0 when building kexts.
166 return "__TEXT,__StaticInit,regular,pure_instructions";
167 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000168
Edwin Török36565e52009-06-30 17:10:35 +0000169};
170
Chris Lattner43954312009-08-10 19:03:04 +0000171
Edwin Török36565e52009-06-30 17:10:35 +0000172// DragonFlyBSD Target
173template<typename Target>
174class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
175protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000176 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000177 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000178 // DragonFly defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000179 Builder.defineMacro("__DragonFly__");
180 Builder.defineMacro("__DragonFly_cc_version", "100001");
181 Builder.defineMacro("__ELF__");
182 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
183 Builder.defineMacro("__tune_i386__");
184 DefineStd(Builder, "unix", Opts);
Edwin Török36565e52009-06-30 17:10:35 +0000185 }
186public:
Mike Stump25cf7602009-09-09 15:08:12 +0000187 DragonFlyBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000188 : OSTargetInfo<Target>(triple) {}
189};
190
191// FreeBSD Target
192template<typename Target>
193class FreeBSDTargetInfo : public OSTargetInfo<Target> {
194protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000195 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000196 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000197 // FreeBSD defines; list based off of gcc output
198
Daniel Dunbar608b3882009-08-24 09:10:05 +0000199 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000200 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Edwin Török36565e52009-06-30 17:10:35 +0000201
Benjamin Kramereaa3c702010-01-30 19:55:01 +0000202 Builder.defineMacro("__FreeBSD__", Release);
203 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000204 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
205 DefineStd(Builder, "unix", Opts);
206 Builder.defineMacro("__ELF__");
Edwin Török36565e52009-06-30 17:10:35 +0000207 }
208public:
Mike Stump25cf7602009-09-09 15:08:12 +0000209 FreeBSDTargetInfo(const std::string &triple)
Duncan Sandscd2cb662009-07-08 13:55:08 +0000210 : OSTargetInfo<Target>(triple) {
211 this->UserLabelPrefix = "";
212 }
Edwin Török36565e52009-06-30 17:10:35 +0000213};
214
Chris Lattner6f4bed52010-07-07 16:01:42 +0000215// Minix Target
216template<typename Target>
217class MinixTargetInfo : public OSTargetInfo<Target> {
218protected:
219 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
220 MacroBuilder &Builder) const {
221 // Minix defines
222
223 Builder.defineMacro("__minix", "3");
224 Builder.defineMacro("_EM_WSIZE", "4");
225 Builder.defineMacro("_EM_PSIZE", "4");
226 Builder.defineMacro("_EM_SSIZE", "2");
227 Builder.defineMacro("_EM_LSIZE", "4");
228 Builder.defineMacro("_EM_FSIZE", "4");
229 Builder.defineMacro("_EM_DSIZE", "8");
230 DefineStd(Builder, "unix", Opts);
231 }
232public:
233 MinixTargetInfo(const std::string &triple)
234 : OSTargetInfo<Target>(triple) {
235 this->UserLabelPrefix = "";
236 }
237};
238
Edwin Török36565e52009-06-30 17:10:35 +0000239// Linux target
240template<typename Target>
241class LinuxTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000245 // Linux defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000246 DefineStd(Builder, "unix", Opts);
247 DefineStd(Builder, "linux", Opts);
248 Builder.defineMacro("__gnu_linux__");
249 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000250 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000251 Builder.defineMacro("_REENTRANT");
Douglas Gregor9b22a172010-04-21 05:52:38 +0000252 if (Opts.CPlusPlus)
253 Builder.defineMacro("_GNU_SOURCE");
Edwin Török36565e52009-06-30 17:10:35 +0000254 }
255public:
Mike Stump25cf7602009-09-09 15:08:12 +0000256 LinuxTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000257 : OSTargetInfo<Target>(triple) {
258 this->UserLabelPrefix = "";
259 }
260};
261
Chris Lattner25fff082009-07-13 20:29:08 +0000262// NetBSD Target
263template<typename Target>
264class NetBSDTargetInfo : public OSTargetInfo<Target> {
265protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000266 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000267 MacroBuilder &Builder) const {
Chris Lattner25fff082009-07-13 20:29:08 +0000268 // NetBSD defines; list based off of gcc output
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000269 Builder.defineMacro("__NetBSD__");
270 Builder.defineMacro("__unix__");
271 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000272 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000273 Builder.defineMacro("_POSIX_THREADS");
Chris Lattner25fff082009-07-13 20:29:08 +0000274 }
275public:
Mike Stump25cf7602009-09-09 15:08:12 +0000276 NetBSDTargetInfo(const std::string &triple)
Chris Lattner25fff082009-07-13 20:29:08 +0000277 : OSTargetInfo<Target>(triple) {
278 this->UserLabelPrefix = "";
279 }
280};
281
Edwin Török36565e52009-06-30 17:10:35 +0000282// OpenBSD Target
283template<typename Target>
284class OpenBSDTargetInfo : public OSTargetInfo<Target> {
285protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000286 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000287 MacroBuilder &Builder) const {
Edwin Török36565e52009-06-30 17:10:35 +0000288 // OpenBSD defines; list based off of gcc output
289
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000290 Builder.defineMacro("__OpenBSD__");
291 DefineStd(Builder, "unix", Opts);
292 Builder.defineMacro("__ELF__");
Daniel Dunbar62a7cbc2009-09-03 04:54:28 +0000293 if (Opts.POSIXThreads)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000294 Builder.defineMacro("_POSIX_THREADS");
Edwin Török36565e52009-06-30 17:10:35 +0000295 }
296public:
Mike Stump25cf7602009-09-09 15:08:12 +0000297 OpenBSDTargetInfo(const std::string &triple)
Edwin Török36565e52009-06-30 17:10:35 +0000298 : OSTargetInfo<Target>(triple) {}
299};
300
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000301// PSP Target
302template<typename Target>
303class PSPTargetInfo : public OSTargetInfo<Target> {
304protected:
305 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000306 MacroBuilder &Builder) const {
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000307 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000308 Builder.defineMacro("PSP");
309 Builder.defineMacro("_PSP");
310 Builder.defineMacro("__psp__");
311 Builder.defineMacro("__ELF__");
Edward O'Callaghan097309f2009-11-15 10:22:07 +0000312 }
313public:
314 PSPTargetInfo(const std::string& triple)
315 : OSTargetInfo<Target>(triple) {
316 this->UserLabelPrefix = "";
317 }
318};
319
John Thompsoned7bdbc2009-11-19 17:18:50 +0000320// PS3 PPU Target
321template<typename Target>
322class PS3PPUTargetInfo : public OSTargetInfo<Target> {
323protected:
324 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000325 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000326 // PS3 PPU defines.
John Thompsonfdd2fc32010-03-25 16:18:32 +0000327 Builder.defineMacro("__PPC__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000328 Builder.defineMacro("__PPU__");
329 Builder.defineMacro("__CELLOS_LV2__");
330 Builder.defineMacro("__ELF__");
331 Builder.defineMacro("__LP32__");
John Thompson1deeb9f2010-06-24 22:44:13 +0000332 Builder.defineMacro("_ARCH_PPC64");
333 Builder.defineMacro("__powerpc64__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000334 }
335public:
336 PS3PPUTargetInfo(const std::string& triple)
337 : OSTargetInfo<Target>(triple) {
338 this->UserLabelPrefix = "";
John Thompson4c3bd3f2009-12-18 14:21:08 +0000339 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson1deeb9f2010-06-24 22:44:13 +0000340 this->IntMaxType = TargetInfo::SignedLongLong;
341 this->UIntMaxType = TargetInfo::UnsignedLongLong;
342 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson4c3bd3f2009-12-18 14:21:08 +0000343 this->SizeType = TargetInfo::UnsignedInt;
John Thompson1deeb9f2010-06-24 22:44:13 +0000344 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
345 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompsoned7bdbc2009-11-19 17:18:50 +0000346 }
347};
348
349// FIXME: Need a real SPU target.
350// PS3 SPU Target
351template<typename Target>
352class PS3SPUTargetInfo : public OSTargetInfo<Target> {
353protected:
354 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000355 MacroBuilder &Builder) const {
John Thompsoned7bdbc2009-11-19 17:18:50 +0000356 // PS3 PPU defines.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000357 Builder.defineMacro("__SPU__");
358 Builder.defineMacro("__ELF__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000359 }
360public:
361 PS3SPUTargetInfo(const std::string& triple)
362 : OSTargetInfo<Target>(triple) {
363 this->UserLabelPrefix = "";
364 }
365};
366
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000367// AuroraUX target
368template<typename Target>
369class AuroraUXTargetInfo : public OSTargetInfo<Target> {
370protected:
371 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000372 MacroBuilder &Builder) const {
373 DefineStd(Builder, "sun", Opts);
374 DefineStd(Builder, "unix", Opts);
375 Builder.defineMacro("__ELF__");
376 Builder.defineMacro("__svr4__");
377 Builder.defineMacro("__SVR4");
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +0000378 }
379public:
380 AuroraUXTargetInfo(const std::string& triple)
381 : OSTargetInfo<Target>(triple) {
382 this->UserLabelPrefix = "";
383 this->WCharType = this->SignedLong;
384 // FIXME: WIntType should be SignedLong
385 }
386};
387
Edwin Török36565e52009-06-30 17:10:35 +0000388// Solaris target
389template<typename Target>
390class SolarisTargetInfo : public OSTargetInfo<Target> {
391protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +0000392 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000393 MacroBuilder &Builder) const {
394 DefineStd(Builder, "sun", Opts);
395 DefineStd(Builder, "unix", Opts);
396 Builder.defineMacro("__ELF__");
397 Builder.defineMacro("__svr4__");
398 Builder.defineMacro("__SVR4");
Edwin Török36565e52009-06-30 17:10:35 +0000399 }
400public:
Mike Stump25cf7602009-09-09 15:08:12 +0000401 SolarisTargetInfo(const std::string& triple)
Edwin Török36565e52009-06-30 17:10:35 +0000402 : OSTargetInfo<Target>(triple) {
403 this->UserLabelPrefix = "";
404 this->WCharType = this->SignedLong;
405 // FIXME: WIntType should be SignedLong
406 }
407};
Michael J. Spencer01e70082010-10-21 05:21:48 +0000408
409// Windows target
410template<typename Target>
411class WindowsTargetInfo : public OSTargetInfo<Target> {
412protected:
413 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
414 MacroBuilder &Builder) const {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000415 Builder.defineMacro("_WIN32");
416 }
417 void getVisualStudioDefines(const LangOptions &Opts,
418 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +0000419 if (Opts.CPlusPlus) {
420 if (Opts.RTTI)
421 Builder.defineMacro("_CPPRTTI");
422
423 if (Opts.Exceptions)
424 Builder.defineMacro("_CPPUNWIND");
425 }
426
427 if (!Opts.CharIsSigned)
428 Builder.defineMacro("_CHAR_UNSIGNED");
429
430 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
431 // but it works for now.
432 if (Opts.POSIXThreads)
433 Builder.defineMacro("_MT");
Michael J. Spencer4fb461c2010-10-21 08:22:51 +0000434
Michael J. Spencer01e70082010-10-21 05:21:48 +0000435 if (Opts.MSCVersion != 0)
436 Builder.defineMacro("_MSC_VER", llvm::Twine(Opts.MSCVersion));
437
438 if (Opts.Microsoft) {
439 Builder.defineMacro("_MSC_EXTENSIONS");
440
441 if (Opts.CPlusPlus0x) {
442 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
443 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
444 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
445 }
446 }
447
448 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer01e70082010-10-21 05:21:48 +0000449 }
450
Michael J. Spencer01e70082010-10-21 05:21:48 +0000451public:
452 WindowsTargetInfo(const std::string &triple)
453 : OSTargetInfo<Target>(triple) {}
454};
455
Mike Stump25cf7602009-09-09 15:08:12 +0000456} // end anonymous namespace.
Edwin Török36565e52009-06-30 17:10:35 +0000457
Chris Lattnerbd00eb82008-10-05 21:50:58 +0000458//===----------------------------------------------------------------------===//
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000459// Specific target implementations.
460//===----------------------------------------------------------------------===//
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000461
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000462namespace {
463// PPC abstract base class
464class PPCTargetInfo : public TargetInfo {
465 static const Builtin::Info BuiltinInfo[];
466 static const char * const GCCRegNames[];
467 static const TargetInfo::GCCRegAlias GCCRegAliases[];
468
469public:
Eli Friedmand9389be2009-06-05 07:05:05 +0000470 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
471
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000472 virtual void getTargetBuiltins(const Builtin::Info *&Records,
473 unsigned &NumRecords) const {
Chris Lattner4b009652007-07-25 00:24:17 +0000474 Records = BuiltinInfo;
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000475 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000476 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000477
Chris Lattner79682402009-03-20 15:52:06 +0000478 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000479 MacroBuilder &Builder) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000480
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000481 virtual const char *getVAListDeclaration() const {
Chris Lattnera07708f2008-10-27 01:11:29 +0000482 return "typedef char* __builtin_va_list;";
483 // This is the right definition for ABI/V4: System V.4/eabi.
484 /*return "typedef struct __va_list_tag {"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000485 " unsigned char gpr;"
486 " unsigned char fpr;"
487 " unsigned short reserved;"
488 " void* overflow_arg_area;"
489 " void* reg_save_area;"
Chris Lattnera07708f2008-10-27 01:11:29 +0000490 "} __builtin_va_list[1];";*/
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000491 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000492 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000493 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +0000494 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000495 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +0000496 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000497 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +0000498 switch (*Name) {
Anders Carlsson4ce42302007-11-27 04:11:28 +0000499 default: return false;
500 case 'O': // Zero
John Thompson1deeb9f2010-06-24 22:44:13 +0000501 break;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000502 case 'b': // Base register
503 case 'f': // Floating point register
Chris Lattnerc49cc1a2009-04-26 07:16:29 +0000504 Info.setAllowsRegister();
John Thompson1deeb9f2010-06-24 22:44:13 +0000505 break;
506 // FIXME: The following are added to allow parsing.
507 // I just took a guess at what the actions should be.
508 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000509 case 'd': // Floating point register (containing 64-bit value)
John Thompson1deeb9f2010-06-24 22:44:13 +0000510 case 'v': // Altivec vector register
511 Info.setAllowsRegister();
512 break;
513 case 'w':
514 switch (Name[1]) {
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000515 case 'd':// VSX vector register to hold vector double data
516 case 'f':// VSX vector register to hold vector float data
517 case 's':// VSX vector register to hold scalar float data
518 case 'a':// Any VSX register
John Thompson1deeb9f2010-06-24 22:44:13 +0000519 break;
520 default:
521 return false;
522 }
523 Info.setAllowsRegister();
524 Name++; // Skip over 'w'.
525 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000526 case 'h': // `MQ', `CTR', or `LINK' register
527 case 'q': // `MQ' register
528 case 'c': // `CTR' register
529 case 'l': // `LINK' register
530 case 'x': // `CR' register (condition register) number 0
531 case 'y': // `CR' register (condition register)
532 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson1deeb9f2010-06-24 22:44:13 +0000533 Info.setAllowsRegister();
534 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000535 case 'I': // Signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000536 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000537 // (use `L' instead for SImode constants)
538 case 'K': // Unsigned 16-bit constant
539 case 'L': // Signed 16-bit constant shifted left 16 bits
540 case 'M': // Constant larger than 31
541 case 'N': // Exact power of 2
542 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson1deeb9f2010-06-24 22:44:13 +0000543 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000544 // register with one instruction per word
John Thompson1deeb9f2010-06-24 22:44:13 +0000545 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000546 // into a register using three instructions
John Thompson1deeb9f2010-06-24 22:44:13 +0000547 break;
548 case 'm': // Memory operand. Note that on PowerPC targets, m can
549 // include addresses that update the base register. It
550 // is therefore only safe to use `m' in an asm statement
551 // if that asm statement accesses the operand exactly once.
552 // The asm statement must also use `%U<opno>' as a
Sebastian Redl097ce222010-08-17 22:42:34 +0000553 // placeholder for the "update" flag in the corresponding
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000554 // load or store instruction. For example:
John Thompson1deeb9f2010-06-24 22:44:13 +0000555 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000556 // is correct but:
John Thompson1deeb9f2010-06-24 22:44:13 +0000557 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
558 // is not. Use es rather than m if you don't want the base
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000559 // register to be updated.
560 case 'e':
John Thompsone0a39472010-06-25 00:02:05 +0000561 if (Name[1] != 's')
562 return false;
Sebastian Redl097ce222010-08-17 22:42:34 +0000563 // es: A "stable" memory operand; that is, one which does not
John Thompson1deeb9f2010-06-24 22:44:13 +0000564 // include any automodification of the base register. Unlike
565 // `m', this constraint can be used in asm statements that
566 // might access the operand several times, or that might not
John Thompsone0a39472010-06-25 00:02:05 +0000567 // access it at all.
John Thompson1deeb9f2010-06-24 22:44:13 +0000568 Info.setAllowsMemory();
John Thompsone0a39472010-06-25 00:02:05 +0000569 Name++; // Skip over 'e'.
John Thompson1deeb9f2010-06-24 22:44:13 +0000570 break;
571 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000572 // usually better to use `m' or `es' in asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000573 case 'Z': // Memory operand that is an indexed or indirect from a
574 // register (it is usually better to use `m' or `es' in
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000575 // asm statements)
John Thompson1deeb9f2010-06-24 22:44:13 +0000576 Info.setAllowsMemory();
577 Info.setAllowsRegister();
578 break;
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000579 case 'R': // AIX TOC entry
John Thompson1deeb9f2010-06-24 22:44:13 +0000580 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000581 // register (`p' is preferable for asm statements)
582 case 'S': // Constant suitable as a 64-bit mask operand
583 case 'T': // Constant suitable as a 32-bit mask operand
584 case 'U': // System V Release 4 small data area reference
John Thompson1deeb9f2010-06-24 22:44:13 +0000585 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000586 // instructions
587 case 'W': // Vector constant that does not require memory
588 case 'j': // Vector constant that is all zeros.
John Thompson1deeb9f2010-06-24 22:44:13 +0000589 break;
590 // End FIXME.
Anders Carlsson4ce42302007-11-27 04:11:28 +0000591 }
John Thompson1deeb9f2010-06-24 22:44:13 +0000592 return true;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000593 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000594 virtual const char *getClobbers() const {
595 return "";
Anders Carlsson4ce42302007-11-27 04:11:28 +0000596 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000597};
Anders Carlsson4ce42302007-11-27 04:11:28 +0000598
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000599const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000600#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
601#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000602#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000603};
Anton Korobeynikove7772382009-05-03 13:42:53 +0000604
605
Chris Lattnerbef1d722009-03-02 22:27:17 +0000606/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
607/// #defines that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +0000608void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000609 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +0000610 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000611 Builder.defineMacro("__ppc__");
612 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerf8030412010-02-16 18:14:57 +0000613 Builder.defineMacro("__powerpc__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000614 Builder.defineMacro("__POWERPC__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000615 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000616 Builder.defineMacro("_ARCH_PPC64");
617 Builder.defineMacro("_LP64");
618 Builder.defineMacro("__LP64__");
Chris Lattnerf8030412010-02-16 18:14:57 +0000619 Builder.defineMacro("__powerpc64__");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000620 Builder.defineMacro("__ppc64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000621 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000622 Builder.defineMacro("__ppc__");
Chris Lattnerbef1d722009-03-02 22:27:17 +0000623 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000624
Chris Lattnerbef1d722009-03-02 22:27:17 +0000625 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000626 Builder.defineMacro("_BIG_ENDIAN");
627 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000628
Chris Lattnerbef1d722009-03-02 22:27:17 +0000629 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000630 Builder.defineMacro("__NATURAL_ALIGNMENT__");
631 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikove7772382009-05-03 13:42:53 +0000632
Chris Lattnerbef1d722009-03-02 22:27:17 +0000633 // FIXME: Should be controlled by command line option.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000634 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencerd5513a32010-10-21 03:16:25 +0000635
John Thompsoned7bdbc2009-11-19 17:18:50 +0000636 if (Opts.AltiVec) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000637 Builder.defineMacro("__VEC__", "10206");
638 Builder.defineMacro("__ALTIVEC__");
John Thompsoned7bdbc2009-11-19 17:18:50 +0000639 }
Chris Lattnerbef1d722009-03-02 22:27:17 +0000640}
641
Chris Lattner9fd73612008-04-21 18:56:49 +0000642
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000643const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattner14d2bb72009-09-16 05:05:27 +0000644 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
645 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
646 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
647 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
648 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
649 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
650 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
651 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000652 "mq", "lr", "ctr", "ap",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000653 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000654 "xer",
Chris Lattner14d2bb72009-09-16 05:05:27 +0000655 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
656 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
657 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
658 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000659 "vrsave", "vscr",
660 "spe_acc", "spefscr",
661 "sfp"
662};
Chris Lattner4b009652007-07-25 00:24:17 +0000663
Anton Korobeynikove7772382009-05-03 13:42:53 +0000664void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000665 unsigned &NumNames) const {
666 Names = GCCRegNames;
667 NumNames = llvm::array_lengthof(GCCRegNames);
668}
Chris Lattner4b009652007-07-25 00:24:17 +0000669
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000670const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
671 // While some of these aliases do map to different registers
672 // they still share the same register name.
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000673 { { "0" }, "r0" },
674 { { "1"}, "r1" },
675 { { "2" }, "r2" },
676 { { "3" }, "r3" },
677 { { "4" }, "r4" },
678 { { "5" }, "r5" },
679 { { "6" }, "r6" },
680 { { "7" }, "r7" },
681 { { "8" }, "r8" },
682 { { "9" }, "r9" },
683 { { "10" }, "r10" },
684 { { "11" }, "r11" },
685 { { "12" }, "r12" },
686 { { "13" }, "r13" },
687 { { "14" }, "r14" },
688 { { "15" }, "r15" },
689 { { "16" }, "r16" },
690 { { "17" }, "r17" },
691 { { "18" }, "r18" },
692 { { "19" }, "r19" },
693 { { "20" }, "r20" },
694 { { "21" }, "r21" },
695 { { "22" }, "r22" },
696 { { "23" }, "r23" },
697 { { "24" }, "r24" },
698 { { "25" }, "r25" },
699 { { "26" }, "r26" },
700 { { "27" }, "r27" },
701 { { "28" }, "r28" },
702 { { "29" }, "r29" },
703 { { "30" }, "r30" },
704 { { "31" }, "r31" },
705 { { "fr0" }, "f0" },
706 { { "fr1" }, "f1" },
707 { { "fr2" }, "f2" },
708 { { "fr3" }, "f3" },
709 { { "fr4" }, "f4" },
710 { { "fr5" }, "f5" },
711 { { "fr6" }, "f6" },
712 { { "fr7" }, "f7" },
713 { { "fr8" }, "f8" },
714 { { "fr9" }, "f9" },
Mike Stump369c21c2009-09-17 21:15:00 +0000715 { { "fr10" }, "f10" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +0000716 { { "fr11" }, "f11" },
717 { { "fr12" }, "f12" },
718 { { "fr13" }, "f13" },
719 { { "fr14" }, "f14" },
720 { { "fr15" }, "f15" },
721 { { "fr16" }, "f16" },
722 { { "fr17" }, "f17" },
723 { { "fr18" }, "f18" },
724 { { "fr19" }, "f19" },
725 { { "fr20" }, "f20" },
726 { { "fr21" }, "f21" },
727 { { "fr22" }, "f22" },
728 { { "fr23" }, "f23" },
729 { { "fr24" }, "f24" },
730 { { "fr25" }, "f25" },
731 { { "fr26" }, "f26" },
732 { { "fr27" }, "f27" },
733 { { "fr28" }, "f28" },
734 { { "fr29" }, "f29" },
735 { { "fr30" }, "f30" },
736 { { "fr31" }, "f31" },
737 { { "cc" }, "cr0" },
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000738};
739
Anton Korobeynikove7772382009-05-03 13:42:53 +0000740void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000741 unsigned &NumAliases) const {
742 Aliases = GCCRegAliases;
743 NumAliases = llvm::array_lengthof(GCCRegAliases);
744}
745} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +0000746
747namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000748class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000749public:
Chris Lattnerf8030412010-02-16 18:14:57 +0000750 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman2b161652008-08-21 00:13:15 +0000751 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000752 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerf8030412010-02-16 18:14:57 +0000753
754 if (getTriple().getOS() == llvm::Triple::FreeBSD)
755 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman2b161652008-08-21 00:13:15 +0000756 }
Chris Lattner4b009652007-07-25 00:24:17 +0000757};
758} // end anonymous namespace.
759
760namespace {
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000761class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +0000762public:
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000763 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +0000764 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman38e31802009-07-01 03:36:11 +0000765 IntMaxType = SignedLong;
766 UIntMaxType = UnsignedLong;
767 Int64Type = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +0000768 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +0000769 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnere5fde952008-05-09 06:17:04 +0000770 }
Eli Friedmanfd5a4122008-08-20 23:11:40 +0000771};
772} // end anonymous namespace.
773
Daniel Dunbar6501cab2010-05-30 00:07:30 +0000774
775namespace {
776class DarwinPPCTargetInfo :
777 public DarwinTargetInfo<PPCTargetInfo> {
778public:
779 DarwinPPCTargetInfo(const std::string& triple)
780 : DarwinTargetInfo<PPCTargetInfo>(triple) {
781 HasAlignMac68kSupport = true;
782 }
783};
784
785class DarwinPPC64TargetInfo :
786 public DarwinTargetInfo<PPC64TargetInfo> {
787public:
788 DarwinPPC64TargetInfo(const std::string& triple)
789 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
790 HasAlignMac68kSupport = true;
791 }
792};
793} // end anonymous namespace.
794
Chris Lattner4b009652007-07-25 00:24:17 +0000795namespace {
Chris Lattner2c026472010-03-06 21:21:27 +0000796// MBlaze abstract base class
797class MBlazeTargetInfo : public TargetInfo {
798 static const char * const GCCRegNames[];
799 static const TargetInfo::GCCRegAlias GCCRegAliases[];
800
801public:
802 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
803 DescriptionString = "E-p:32:32-i8:8:8-i16:16:16-i64:32:32-f64:32:32-"
804 "v64:32:32-v128:32:32-n32";
805 }
806
807 virtual void getTargetBuiltins(const Builtin::Info *&Records,
808 unsigned &NumRecords) const {
809 // FIXME: Implement.
810 Records = 0;
811 NumRecords = 0;
812 }
813
814 virtual void getTargetDefines(const LangOptions &Opts,
815 MacroBuilder &Builder) const;
816
817 virtual const char *getVAListDeclaration() const {
818 return "typedef char* __builtin_va_list;";
819 }
820 virtual const char *getTargetPrefix() const {
821 return "mblaze";
822 }
823 virtual void getGCCRegNames(const char * const *&Names,
824 unsigned &NumNames) const;
825 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
826 unsigned &NumAliases) const;
827 virtual bool validateAsmConstraint(const char *&Name,
828 TargetInfo::ConstraintInfo &Info) const {
829 switch (*Name) {
830 default: return false;
831 case 'O': // Zero
832 return true;
833 case 'b': // Base register
834 case 'f': // Floating point register
835 Info.setAllowsRegister();
836 return true;
837 }
838 }
839 virtual const char *getClobbers() const {
840 return "";
841 }
842};
843
844/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
845/// #defines that are not tied to a specific subtarget.
846void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
847 MacroBuilder &Builder) const {
848 // Target identification.
849 Builder.defineMacro("__microblaze__");
850 Builder.defineMacro("_ARCH_MICROBLAZE");
851 Builder.defineMacro("__MICROBLAZE__");
852
853 // Target properties.
854 Builder.defineMacro("_BIG_ENDIAN");
855 Builder.defineMacro("__BIG_ENDIAN__");
856
857 // Subtarget options.
858 Builder.defineMacro("__REGISTER_PREFIX__", "");
859}
860
861
862const char * const MBlazeTargetInfo::GCCRegNames[] = {
863 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
864 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
865 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
866 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
867 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
868 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
869 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
870 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
871 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
872 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
873};
874
875void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
876 unsigned &NumNames) const {
877 Names = GCCRegNames;
878 NumNames = llvm::array_lengthof(GCCRegNames);
879}
880
881const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
882 { {"f0"}, "r0" },
883 { {"f1"}, "r1" },
884 { {"f2"}, "r2" },
885 { {"f3"}, "r3" },
886 { {"f4"}, "r4" },
887 { {"f5"}, "r5" },
888 { {"f6"}, "r6" },
889 { {"f7"}, "r7" },
890 { {"f8"}, "r8" },
891 { {"f9"}, "r9" },
892 { {"f10"}, "r10" },
893 { {"f11"}, "r11" },
894 { {"f12"}, "r12" },
895 { {"f13"}, "r13" },
896 { {"f14"}, "r14" },
897 { {"f15"}, "r15" },
898 { {"f16"}, "r16" },
899 { {"f17"}, "r17" },
900 { {"f18"}, "r18" },
901 { {"f19"}, "r19" },
902 { {"f20"}, "r20" },
903 { {"f21"}, "r21" },
904 { {"f22"}, "r22" },
905 { {"f23"}, "r23" },
906 { {"f24"}, "r24" },
907 { {"f25"}, "r25" },
908 { {"f26"}, "r26" },
909 { {"f27"}, "r27" },
910 { {"f28"}, "r28" },
911 { {"f29"}, "r29" },
912 { {"f30"}, "r30" },
913 { {"f31"}, "r31" },
914};
915
916void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
917 unsigned &NumAliases) const {
918 Aliases = GCCRegAliases;
919 NumAliases = llvm::array_lengthof(GCCRegAliases);
920}
921} // end anonymous namespace.
922
923namespace {
Eli Friedman872996c2008-08-20 02:34:37 +0000924// Namespace for x86 abstract base class
925const Builtin::Info BuiltinInfo[] = {
Douglas Gregor2e8a7aa2009-02-16 21:58:21 +0000926#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
927#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
Chris Lattner99ca9d62009-06-14 01:05:48 +0000928#include "clang/Basic/BuiltinsX86.def"
Eli Friedman872996c2008-08-20 02:34:37 +0000929};
Eli Friedman0b7b1cb2008-05-20 14:21:01 +0000930
Nuno Lopesad1010d2009-12-23 17:49:57 +0000931static const char* const GCCRegNames[] = {
Eli Friedman872996c2008-08-20 02:34:37 +0000932 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
933 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
934 "argp", "flags", "fspr", "dirflag", "frame",
935 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
936 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
937 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
938 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15"
939};
940
941const TargetInfo::GCCRegAlias GCCRegAliases[] = {
942 { { "al", "ah", "eax", "rax" }, "ax" },
943 { { "bl", "bh", "ebx", "rbx" }, "bx" },
944 { { "cl", "ch", "ecx", "rcx" }, "cx" },
945 { { "dl", "dh", "edx", "rdx" }, "dx" },
946 { { "esi", "rsi" }, "si" },
947 { { "edi", "rdi" }, "di" },
948 { { "esp", "rsp" }, "sp" },
949 { { "ebp", "rbp" }, "bp" },
950};
951
952// X86 target abstract base class; x86-32 and x86-64 are very close, so
953// most of the implementation can be shared.
954class X86TargetInfo : public TargetInfo {
Chris Lattner715fe4c2009-03-02 22:40:39 +0000955 enum X86SSEEnum {
956 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
957 } SSELevel;
Anders Carlssone5e222f2010-01-27 03:47:49 +0000958 enum AMD3DNowEnum {
959 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
960 } AMD3DNowLevel;
961
Eric Christopher6c4e7872010-04-02 23:50:19 +0000962 bool HasAES;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000963 bool HasAVX;
964
Eli Friedman872996c2008-08-20 02:34:37 +0000965public:
Anton Korobeynikove7772382009-05-03 13:42:53 +0000966 X86TargetInfo(const std::string& triple)
Eric Christopher6c4e7872010-04-02 23:50:19 +0000967 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +0000968 HasAES(false), HasAVX(false) {
Eli Friedman872996c2008-08-20 02:34:37 +0000969 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner4b009652007-07-25 00:24:17 +0000970 }
971 virtual void getTargetBuiltins(const Builtin::Info *&Records,
972 unsigned &NumRecords) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000973 Records = BuiltinInfo;
974 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner4b009652007-07-25 00:24:17 +0000975 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000976 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman872996c2008-08-20 02:34:37 +0000977 unsigned &NumNames) const {
978 Names = GCCRegNames;
979 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000980 }
Anton Korobeynikove7772382009-05-03 13:42:53 +0000981 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson7dd1c952007-11-24 23:38:12 +0000982 unsigned &NumAliases) const {
Eli Friedman872996c2008-08-20 02:34:37 +0000983 Aliases = GCCRegAliases;
984 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlsson8b58e8a2007-10-13 00:45:48 +0000985 }
Anders Carlsson36834a72009-02-28 17:11:49 +0000986 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman872996c2008-08-20 02:34:37 +0000987 TargetInfo::ConstraintInfo &info) const;
988 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlsson4ce42302007-11-27 04:11:28 +0000989 virtual const char *getClobbers() const {
Eli Friedman872996c2008-08-20 02:34:37 +0000990 return "~{dirflag},~{fpsr},~{flags}";
991 }
Chris Lattner79682402009-03-20 15:52:06 +0000992 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +0000993 MacroBuilder &Builder) const;
Daniel Dunbar0838f962009-05-06 21:07:50 +0000994 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
995 const std::string &Name,
996 bool Enabled) const;
Mike Stump25cf7602009-09-09 15:08:12 +0000997 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +0000998 llvm::StringMap<bool> &Features) const;
Daniel Dunbar4f7cd962009-12-19 03:30:57 +0000999 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner4b009652007-07-25 00:24:17 +00001000};
Chris Lattner7d6220c2009-03-02 22:20:04 +00001001
Mike Stump25cf7602009-09-09 15:08:12 +00001002void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001003 llvm::StringMap<bool> &Features) const {
Daniel Dunbar07181d72009-05-06 03:16:41 +00001004 // FIXME: This should not be here.
1005 Features["3dnow"] = false;
1006 Features["3dnowa"] = false;
1007 Features["mmx"] = false;
1008 Features["sse"] = false;
1009 Features["sse2"] = false;
1010 Features["sse3"] = false;
1011 Features["ssse3"] = false;
1012 Features["sse41"] = false;
1013 Features["sse42"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001014 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001015 Features["avx"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001016
Daniel Dunbar07181d72009-05-06 03:16:41 +00001017 // LLVM does not currently recognize this.
1018 // Features["sse4a"] = false;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001019
Daniel Dunbar07181d72009-05-06 03:16:41 +00001020 // FIXME: This *really* should not be here.
1021
1022 // X86_64 always has SSE2.
1023 if (PointerWidth == 64)
1024 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1025
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001026 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1027 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1028 ;
1029 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1030 setFeatureEnabled(Features, "mmx", true);
1031 else if (CPU == "pentium3")
1032 setFeatureEnabled(Features, "sse", true);
1033 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
1034 setFeatureEnabled(Features, "sse2", true);
1035 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
1036 setFeatureEnabled(Features, "sse3", true);
1037 else if (CPU == "core2")
1038 setFeatureEnabled(Features, "ssse3", true);
1039 else if (CPU == "penryn") {
1040 setFeatureEnabled(Features, "sse4", true);
1041 Features["sse42"] = false;
1042 } else if (CPU == "atom")
1043 setFeatureEnabled(Features, "sse3", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001044 else if (CPU == "corei7") {
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001045 setFeatureEnabled(Features, "sse4", true);
Eric Christopher6c4e7872010-04-02 23:50:19 +00001046 setFeatureEnabled(Features, "aes", true);
1047 }
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001048 else if (CPU == "k6" || CPU == "winchip-c6")
1049 setFeatureEnabled(Features, "mmx", true);
Mike Stump25cf7602009-09-09 15:08:12 +00001050 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001051 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1052 setFeatureEnabled(Features, "mmx", true);
1053 setFeatureEnabled(Features, "3dnow", true);
1054 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1055 setFeatureEnabled(Features, "sse", true);
1056 setFeatureEnabled(Features, "3dnowa", true);
1057 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1058 CPU == "athlon-fx") {
Mike Stump25cf7602009-09-09 15:08:12 +00001059 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarc2e55de2009-05-06 21:56:32 +00001060 setFeatureEnabled(Features, "3dnowa", true);
1061 } else if (CPU == "c3-2")
1062 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar07181d72009-05-06 03:16:41 +00001063}
1064
Daniel Dunbar0838f962009-05-06 21:07:50 +00001065bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump25cf7602009-09-09 15:08:12 +00001066 const std::string &Name,
Daniel Dunbar0838f962009-05-06 21:07:50 +00001067 bool Enabled) const {
Eric Christopher850e2012010-03-04 02:26:37 +00001068 // FIXME: This *really* should not be here. We need some way of translating
1069 // options into llvm subtarget features.
1070 if (!Features.count(Name) &&
1071 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar0838f962009-05-06 21:07:50 +00001072 return false;
1073
1074 if (Enabled) {
1075 if (Name == "mmx")
1076 Features["mmx"] = true;
1077 else if (Name == "sse")
1078 Features["mmx"] = Features["sse"] = true;
1079 else if (Name == "sse2")
1080 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
1081 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001082 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001083 Features["sse3"] = true;
1084 else if (Name == "ssse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001085 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001086 Features["ssse3"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001087 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump25cf7602009-09-09 15:08:12 +00001088 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001089 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher850e2012010-03-04 02:26:37 +00001090 else if (Name == "sse4.1")
1091 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1092 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001093 else if (Name == "3dnow")
1094 Features["3dnowa"] = true;
1095 else if (Name == "3dnowa")
1096 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001097 else if (Name == "aes")
1098 Features["aes"] = true;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001099 else if (Name == "avx")
1100 Features["avx"] = true;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001101 } else {
1102 if (Name == "mmx")
Mike Stump25cf7602009-09-09 15:08:12 +00001103 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001104 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1105 else if (Name == "sse")
Mike Stump25cf7602009-09-09 15:08:12 +00001106 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001107 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1108 else if (Name == "sse2")
Mike Stump25cf7602009-09-09 15:08:12 +00001109 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001110 Features["sse41"] = Features["sse42"] = false;
1111 else if (Name == "sse3")
Mike Stump25cf7602009-09-09 15:08:12 +00001112 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbar0838f962009-05-06 21:07:50 +00001113 Features["sse42"] = false;
1114 else if (Name == "ssse3")
1115 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1116 else if (Name == "sse4")
1117 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd794f782010-03-04 02:31:44 +00001118 else if (Name == "sse4.2")
1119 Features["sse42"] = false;
1120 else if (Name == "sse4.1")
1121 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001122 else if (Name == "3dnow")
1123 Features["3dnow"] = Features["3dnowa"] = false;
1124 else if (Name == "3dnowa")
1125 Features["3dnowa"] = false;
Eric Christopher6c4e7872010-04-02 23:50:19 +00001126 else if (Name == "aes")
1127 Features["aes"] = false;
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001128 else if (Name == "avx")
1129 Features["avx"] = false;
Daniel Dunbar0838f962009-05-06 21:07:50 +00001130 }
1131
1132 return true;
1133}
1134
Daniel Dunbar07181d72009-05-06 03:16:41 +00001135/// HandleTargetOptions - Perform initialization based on the user
1136/// configured set of features.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00001137void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001138 // Remember the maximum enabled sselevel.
1139 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1140 // Ignore disabled features.
1141 if (Features[i][0] == '-')
1142 continue;
1143
Eric Christopher6c4e7872010-04-02 23:50:19 +00001144 if (Features[i].substr(1) == "aes") {
1145 HasAES = true;
1146 continue;
1147 }
1148
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001149 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1150 // For now let it be enabled together with other SSE levels.
1151 if (Features[i].substr(1) == "avx") {
1152 HasAVX = true;
1153 continue;
1154 }
1155
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001156 assert(Features[i][0] == '+' && "Invalid target feature!");
1157 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1158 .Case("sse42", SSE42)
1159 .Case("sse41", SSE41)
1160 .Case("ssse3", SSSE3)
Nuno Lopes3a16d782010-03-12 10:20:09 +00001161 .Case("sse3", SSE3)
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001162 .Case("sse2", SSE2)
1163 .Case("sse", SSE1)
1164 .Case("mmx", MMX)
1165 .Default(NoMMXSSE);
1166 SSELevel = std::max(SSELevel, Level);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001167
1168 AMD3DNowEnum ThreeDNowLevel =
Anders Carlssone5e222f2010-01-27 03:47:49 +00001169 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1170 .Case("3dnowa", AMD3DNowAthlon)
1171 .Case("3dnow", AMD3DNow)
1172 .Default(NoAMD3DNow);
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001173
Anders Carlssone5e222f2010-01-27 03:47:49 +00001174 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar8dd8f262009-11-11 09:38:56 +00001175 }
Chris Lattner7d6220c2009-03-02 22:20:04 +00001176}
Chris Lattnerbef1d722009-03-02 22:27:17 +00001177
1178/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1179/// that are not tied to a specific subtarget.
Chris Lattner79682402009-03-20 15:52:06 +00001180void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001181 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001182 // Target identification.
1183 if (PointerWidth == 64) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001184 Builder.defineMacro("_LP64");
1185 Builder.defineMacro("__LP64__");
1186 Builder.defineMacro("__amd64__");
1187 Builder.defineMacro("__amd64");
1188 Builder.defineMacro("__x86_64");
1189 Builder.defineMacro("__x86_64__");
Chris Lattnerbef1d722009-03-02 22:27:17 +00001190 } else {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001191 DefineStd(Builder, "i386", Opts);
Chris Lattnerbef1d722009-03-02 22:27:17 +00001192 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001193
Eric Christopher6c4e7872010-04-02 23:50:19 +00001194 if (HasAES)
1195 Builder.defineMacro("__AES__");
1196
Bruno Cardoso Lopes8a93f512010-08-04 22:29:13 +00001197 if (HasAVX)
1198 Builder.defineMacro("__AVX__");
1199
Chris Lattnerbef1d722009-03-02 22:27:17 +00001200 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001201 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001202
Chris Lattnerbef1d722009-03-02 22:27:17 +00001203 // Subtarget options.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001204 Builder.defineMacro("__nocona");
1205 Builder.defineMacro("__nocona__");
1206 Builder.defineMacro("__tune_nocona__");
1207 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001208
Chris Lattner25ac1c12009-04-19 17:32:33 +00001209 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1210 // functions in glibc header files that use FP Stack inline asm which the
1211 // backend can't deal with (PR879).
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001212 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001213
Chris Lattner715fe4c2009-03-02 22:40:39 +00001214 // Each case falls through to the previous one here.
1215 switch (SSELevel) {
1216 case SSE42:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001217 Builder.defineMacro("__SSE4_2__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001218 case SSE41:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001219 Builder.defineMacro("__SSE4_1__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001220 case SSSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001221 Builder.defineMacro("__SSSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001222 case SSE3:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001223 Builder.defineMacro("__SSE3__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001224 case SSE2:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001225 Builder.defineMacro("__SSE2__");
1226 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001227 case SSE1:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001228 Builder.defineMacro("__SSE__");
1229 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner715fe4c2009-03-02 22:40:39 +00001230 case MMX:
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001231 Builder.defineMacro("__MMX__");
Chris Lattner715fe4c2009-03-02 22:40:39 +00001232 case NoMMXSSE:
1233 break;
1234 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001235
Michael J. Spencer01e70082010-10-21 05:21:48 +00001236 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001237 switch (SSELevel) {
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001238 case SSE42:
1239 case SSE41:
1240 case SSSE3:
1241 case SSE3:
Michael J. Spencer01e70082010-10-21 05:21:48 +00001242 case SSE2:
1243 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1244 break;
1245 case SSE1:
1246 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1247 break;
1248 default:
1249 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1250 }
1251 }
1252
Anders Carlssone5e222f2010-01-27 03:47:49 +00001253 // Each case falls through to the previous one here.
1254 switch (AMD3DNowLevel) {
1255 case AMD3DNowAthlon:
1256 Builder.defineMacro("__3dNOW_A__");
1257 case AMD3DNow:
1258 Builder.defineMacro("__3dNOW__");
1259 case NoAMD3DNow:
1260 break;
1261 }
Chris Lattnerbef1d722009-03-02 22:27:17 +00001262}
Anton Korobeynikove7772382009-05-03 13:42:53 +00001263
1264
Eli Friedman872996c2008-08-20 02:34:37 +00001265bool
Anders Carlsson36834a72009-02-28 17:11:49 +00001266X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001267 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson36834a72009-02-28 17:11:49 +00001268 switch (*Name) {
Eli Friedman872996c2008-08-20 02:34:37 +00001269 default: return false;
Dale Johanneseneba819a2010-08-24 22:33:12 +00001270 case 'Y': // first letter of a pair:
1271 switch (*(Name+1)) {
1272 default: return false;
1273 case '0': // First SSE register.
1274 case 't': // Any SSE register, when SSE2 is enabled.
1275 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1276 case 'm': // any MMX register, when inter-unit moves enabled.
1277 break; // falls through to setAllowsRegister.
1278 }
Eli Friedman872996c2008-08-20 02:34:37 +00001279 case 'a': // eax.
1280 case 'b': // ebx.
1281 case 'c': // ecx.
1282 case 'd': // edx.
1283 case 'S': // esi.
1284 case 'D': // edi.
1285 case 'A': // edx:eax.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001286 case 'f': // any x87 floating point stack register.
Eli Friedman872996c2008-08-20 02:34:37 +00001287 case 't': // top of floating point stack.
1288 case 'u': // second from top of floating point stack.
1289 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson2285e622008-10-06 00:41:45 +00001290 case 'y': // Any MMX register.
Anders Carlssond2459f92008-10-06 19:17:39 +00001291 case 'x': // Any SSE register.
Eli Friedman872996c2008-08-20 02:34:37 +00001292 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johanneseneba819a2010-08-24 22:33:12 +00001293 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1294 case 'l': // "Index" registers: any general register that can be used as an
1295 // index in a base+index memory access.
1296 Info.setAllowsRegister();
1297 return true;
1298 case 'C': // SSE floating point constant.
1299 case 'G': // x87 floating point constant.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001300 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001301 // x86_64 instructions.
Anton Korobeynikove7772382009-05-03 13:42:53 +00001302 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssonff235da2009-01-24 18:03:09 +00001303 // x86_64 instructions.
Eli Friedman872996c2008-08-20 02:34:37 +00001304 return true;
1305 }
Dale Johanneseneba819a2010-08-24 22:33:12 +00001306 return false;
Eli Friedman872996c2008-08-20 02:34:37 +00001307}
1308
1309std::string
1310X86TargetInfo::convertConstraint(const char Constraint) const {
1311 switch (Constraint) {
1312 case 'a': return std::string("{ax}");
1313 case 'b': return std::string("{bx}");
1314 case 'c': return std::string("{cx}");
1315 case 'd': return std::string("{dx}");
1316 case 'S': return std::string("{si}");
1317 case 'D': return std::string("{di}");
Dale Johannesena49254e2010-10-22 21:07:10 +00001318 case 'p': // address
1319 return std::string("im");
Eli Friedman872996c2008-08-20 02:34:37 +00001320 case 't': // top of floating point stack.
1321 return std::string("{st}");
1322 case 'u': // second from top of floating point stack.
1323 return std::string("{st(1)}"); // second from top of floating point stack.
1324 default:
1325 return std::string(1, Constraint);
1326 }
1327}
Eli Friedman872996c2008-08-20 02:34:37 +00001328} // end anonymous namespace
Chris Lattner4b009652007-07-25 00:24:17 +00001329
1330namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001331// X86-32 generic target
1332class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner4b009652007-07-25 00:24:17 +00001333public:
Eli Friedman872996c2008-08-20 02:34:37 +00001334 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1335 DoubleAlign = LongLongAlign = 32;
1336 LongDoubleWidth = 96;
1337 LongDoubleAlign = 32;
Eli Friedman2b161652008-08-21 00:13:15 +00001338 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1339 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001340 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman04ede302009-03-29 20:31:09 +00001341 SizeType = UnsignedInt;
1342 PtrDiffType = SignedInt;
1343 IntPtrType = SignedInt;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001344 RegParmMax = 3;
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001345
1346 // Use fpret for all types.
1347 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1348 (1 << TargetInfo::Double) |
1349 (1 << TargetInfo::LongDouble));
Eli Friedman872996c2008-08-20 02:34:37 +00001350 }
1351 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001352 return "typedef char* __builtin_va_list;";
Eli Friedman872996c2008-08-20 02:34:37 +00001353 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001354
Chris Lattneraa339182009-09-23 06:06:36 +00001355 int getEHDataRegisterNumber(unsigned RegNo) const {
1356 if (RegNo == 0) return 0;
1357 if (RegNo == 1) return 2;
1358 return -1;
1359 }
Eli Friedman872996c2008-08-20 02:34:37 +00001360};
1361} // end anonymous namespace
1362
1363namespace {
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001364class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1365public:
1366 OpenBSDI386TargetInfo(const std::string& triple) :
1367 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1368 SizeType = UnsignedLong;
1369 IntPtrType = SignedLong;
Eli Friedman96ada022009-07-05 22:31:18 +00001370 PtrDiffType = SignedLong;
Eli Friedman1c79f4b2009-07-05 18:47:56 +00001371 }
1372};
1373} // end anonymous namespace
1374
1375namespace {
Edwin Török36565e52009-06-30 17:10:35 +00001376class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman872996c2008-08-20 02:34:37 +00001377public:
Edwin Török36565e52009-06-30 17:10:35 +00001378 DarwinI386TargetInfo(const std::string& triple) :
1379 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman872996c2008-08-20 02:34:37 +00001380 LongDoubleWidth = 128;
1381 LongDoubleAlign = 128;
Eli Friedman04ede302009-03-29 20:31:09 +00001382 SizeType = UnsignedLong;
1383 IntPtrType = SignedLong;
Eli Friedman2b161652008-08-21 00:13:15 +00001384 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1385 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001386 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbar9451c542010-05-27 00:35:16 +00001387 HasAlignMac68kSupport = true;
Edwin Török2d98f9f2009-06-30 17:00:25 +00001388 }
1389
Eli Friedman872996c2008-08-20 02:34:37 +00001390};
Daniel Dunbar64c77a12009-06-29 20:52:51 +00001391} // end anonymous namespace
1392
1393namespace {
Eli Friedman23cb7912008-08-21 01:40:19 +00001394// x86-32 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00001395class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman23cb7912008-08-21 01:40:19 +00001396public:
1397 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00001398 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman8f575172009-04-19 21:38:35 +00001399 TLSSupported = false;
Chris Lattnera8a69e12009-06-24 17:12:15 +00001400 WCharType = UnsignedShort;
Eli Friedmanb28055e2009-06-08 21:16:17 +00001401 DoubleAlign = LongLongAlign = 64;
1402 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikov186e7d32009-12-19 02:05:07 +00001403 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1404 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedman23cb7912008-08-21 01:40:19 +00001405 }
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001406 virtual void getTargetDefines(const LangOptions &Opts,
1407 MacroBuilder &Builder) const {
1408 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1409 }
1410};
1411} // end anonymous namespace
1412
1413namespace {
1414
1415// x86-32 Windows Visual Studio target
1416class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1417public:
1418 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1419 : WindowsX86_32TargetInfo(triple) {
1420 LongDoubleWidth = 64;
1421 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1422 }
1423 virtual void getTargetDefines(const LangOptions &Opts,
1424 MacroBuilder &Builder) const {
1425 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1426 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1427 // The value of the following reflects processor type.
1428 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1429 // We lost the original triple, so we use the default.
1430 Builder.defineMacro("_M_IX86", "600");
1431 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001432};
1433} // end anonymous namespace
1434
1435namespace {
1436// x86-32 MinGW target
1437class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1438public:
1439 MinGWX86_32TargetInfo(const std::string& triple)
1440 : WindowsX86_32TargetInfo(triple) {
1441 }
1442 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001443 MacroBuilder &Builder) const {
1444 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001445 DefineStd(Builder, "WIN32", Opts);
1446 DefineStd(Builder, "WINNT", Opts);
1447 Builder.defineMacro("_X86_");
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001448 Builder.defineMacro("__MSVCRT__");
1449 Builder.defineMacro("__MINGW32__");
1450 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001451 }
1452};
1453} // end anonymous namespace
1454
1455namespace {
1456// x86-32 Cygwin target
1457class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1458public:
1459 CygwinX86_32TargetInfo(const std::string& triple)
1460 : X86_32TargetInfo(triple) {
1461 TLSSupported = false;
1462 WCharType = UnsignedShort;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001463 DoubleAlign = LongLongAlign = 64;
1464 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1465 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001466 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001467 }
1468 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001469 MacroBuilder &Builder) const {
1470 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1471 Builder.defineMacro("__CYGWIN__");
1472 Builder.defineMacro("__CYGWIN32__");
1473 DefineStd(Builder, "unix", Opts);
Douglas Gregor9b22a172010-04-21 05:52:38 +00001474 if (Opts.CPlusPlus)
1475 Builder.defineMacro("_GNU_SOURCE");
Eli Friedman6b6ca942009-06-08 06:11:14 +00001476 }
Eli Friedman23cb7912008-08-21 01:40:19 +00001477};
1478} // end anonymous namespace
1479
1480namespace {
Chris Lattnerf853e732010-04-11 19:29:39 +00001481// x86-32 Haiku target
1482class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1483public:
1484 HaikuX86_32TargetInfo(const std::string& triple)
1485 : X86_32TargetInfo(triple) {
1486 SizeType = UnsignedLong;
Chris Lattner5b8b18a2010-04-22 17:48:00 +00001487 IntPtrType = SignedLong;
1488 PtrDiffType = SignedLong;
Eli Friedman08f845b2010-08-22 01:00:03 +00001489 }
Chris Lattnerf853e732010-04-11 19:29:39 +00001490 virtual void getTargetDefines(const LangOptions &Opts,
1491 MacroBuilder &Builder) const {
1492 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1493 Builder.defineMacro("__INTEL__");
1494 Builder.defineMacro("__HAIKU__");
1495 }
1496};
1497} // end anonymous namespace
1498
1499namespace {
Eli Friedman872996c2008-08-20 02:34:37 +00001500// x86-64 generic target
1501class X86_64TargetInfo : public X86TargetInfo {
1502public:
Chris Lattner79682402009-03-20 15:52:06 +00001503 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnere5fde952008-05-09 06:17:04 +00001504 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001505 LongDoubleWidth = 128;
1506 LongDoubleAlign = 128;
Rafael Espindolabfa7c002010-06-04 23:15:27 +00001507 LargeArrayMinWidth = 128;
1508 LargeArrayAlign = 128;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001509 IntMaxType = SignedLong;
1510 UIntMaxType = UnsignedLong;
Eli Friedman38e31802009-07-01 03:36:11 +00001511 Int64Type = SignedLong;
Anton Korobeynikov8fcffeb2009-04-03 23:38:25 +00001512 RegParmMax = 6;
Chris Lattnerbfbfbaf2009-02-05 07:32:46 +00001513
Eli Friedman2b161652008-08-21 00:13:15 +00001514 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1515 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001516 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f94dbb2010-07-14 23:39:36 +00001517
1518 // Use fpret only for long double.
1519 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner4b009652007-07-25 00:24:17 +00001520 }
Anders Carlsson8b58e8a2007-10-13 00:45:48 +00001521 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001522 return "typedef struct __va_list_tag {"
1523 " unsigned gp_offset;"
1524 " unsigned fp_offset;"
1525 " void* overflow_arg_area;"
1526 " void* reg_save_area;"
John McCall33bf24b2010-05-28 18:25:28 +00001527 "} __va_list_tag;"
Eli Friedman3c79eee2009-07-03 00:45:06 +00001528 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson7dd1c952007-11-24 23:38:12 +00001529 }
Michael J. Spencer3d796932010-10-18 07:10:59 +00001530
Chris Lattneraa339182009-09-23 06:06:36 +00001531 int getEHDataRegisterNumber(unsigned RegNo) const {
1532 if (RegNo == 0) return 0;
1533 if (RegNo == 1) return 1;
1534 return -1;
1535 }
Eli Friedman872996c2008-08-20 02:34:37 +00001536};
1537} // end anonymous namespace
1538
1539namespace {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001540// x86-64 Windows target
Michael J. Spencer01e70082010-10-21 05:21:48 +00001541class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001542public:
1543 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer01e70082010-10-21 05:21:48 +00001544 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001545 TLSSupported = false;
1546 WCharType = UnsignedShort;
Mike Stump4da7a162009-10-08 23:00:00 +00001547 LongWidth = LongAlign = 32;
Michael J. Spencer3d796932010-10-18 07:10:59 +00001548 DoubleAlign = LongLongAlign = 64;
Nate Begeman472bd992010-07-21 02:02:56 +00001549 IntMaxType = SignedLongLong;
1550 UIntMaxType = UnsignedLongLong;
1551 Int64Type = SignedLongLong;
Cameron Esfahani32083822010-09-15 00:28:12 +00001552 SizeType = UnsignedLongLong;
1553 PtrDiffType = SignedLongLong;
1554 IntPtrType = SignedLongLong;
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001555 }
1556 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001557 MacroBuilder &Builder) const {
Michael J. Spencer01e70082010-10-21 05:21:48 +00001558 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer01e70082010-10-21 05:21:48 +00001559 Builder.defineMacro("_WIN64");
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001560 }
1561};
1562} // end anonymous namespace
1563
1564namespace {
1565// x86-64 Windows Visual Studio target
1566class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1567public:
1568 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1569 : WindowsX86_64TargetInfo(triple) {
1570 }
1571 virtual void getTargetDefines(const LangOptions &Opts,
1572 MacroBuilder &Builder) const {
1573 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1574 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001575 Builder.defineMacro("_M_X64");
Michael J. Spencer01e70082010-10-21 05:21:48 +00001576 Builder.defineMacro("_M_AMD64");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001577 }
Chris Lattnerb979e7a2010-08-31 16:44:54 +00001578 virtual const char *getVAListDeclaration() const {
1579 return "typedef char* __builtin_va_list;";
1580 }
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001581};
1582} // end anonymous namespace
1583
1584namespace {
1585// x86-64 MinGW target
1586class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1587public:
1588 MinGWX86_64TargetInfo(const std::string& triple)
1589 : WindowsX86_64TargetInfo(triple) {
1590 }
1591 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001592 MacroBuilder &Builder) const {
1593 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00001594 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001595 Builder.defineMacro("__MSVCRT__");
1596 Builder.defineMacro("__MINGW64__");
1597 Builder.defineMacro("__declspec");
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00001598 }
1599};
1600} // end anonymous namespace
1601
1602namespace {
Eli Friedman38e31802009-07-01 03:36:11 +00001603class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1604public:
Mike Stump25cf7602009-09-09 15:08:12 +00001605 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman38e31802009-07-01 03:36:11 +00001606 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1607 Int64Type = SignedLongLong;
1608 }
1609};
1610} // end anonymous namespace
1611
1612namespace {
Eli Friedman96ada022009-07-05 22:31:18 +00001613class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1614public:
Mike Stump25cf7602009-09-09 15:08:12 +00001615 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman96ada022009-07-05 22:31:18 +00001616 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1617 IntMaxType = SignedLongLong;
1618 UIntMaxType = UnsignedLongLong;
1619 Int64Type = SignedLongLong;
1620 }
1621};
1622} // end anonymous namespace
1623
1624namespace {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001625class ARMTargetInfo : public TargetInfo {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001626 // Possible FPU choices.
1627 enum FPUMode {
1628 NoFPU,
1629 VFP2FPU,
1630 VFP3FPU,
1631 NeonFPU
1632 };
1633
1634 static bool FPUModeIsVFP(FPUMode Mode) {
1635 return Mode >= VFP2FPU && Mode <= NeonFPU;
1636 }
1637
1638 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1639 static const char * const GCCRegNames[];
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001640
Daniel Dunbar33b40752009-12-18 18:42:37 +00001641 std::string ABI, CPU;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001642
1643 unsigned FPU : 3;
1644
Daniel Dunbar48075d82009-12-19 04:15:38 +00001645 unsigned IsThumb : 1;
1646
1647 // Initialized via features.
1648 unsigned SoftFloat : 1;
1649 unsigned SoftFloatABI : 1;
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001650
Chris Lattnerb4527522010-03-03 19:03:45 +00001651 static const Builtin::Info BuiltinInfo[];
1652
Chris Lattner9fd73612008-04-21 18:56:49 +00001653public:
Daniel Dunbarf0156562009-09-17 16:21:10 +00001654 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbar33b40752009-12-18 18:42:37 +00001655 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001656 {
Daniel Dunbarb9531632009-09-14 00:02:24 +00001657 SizeType = UnsignedInt;
1658 PtrDiffType = SignedInt;
Daniel Dunbarf0156562009-09-17 16:21:10 +00001659
Chris Lattnere20b8122010-04-23 16:29:58 +00001660 // {} in inline assembly are neon specifiers, not assembly variant
1661 // specifiers.
1662 NoAsmVariants = true;
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001663
Daniel Dunbar33b40752009-12-18 18:42:37 +00001664 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0a542ca2009-12-18 19:57:13 +00001665 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001666 if (IsThumb) {
1667 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1668 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001669 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001670 } else {
1671 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1672 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001673 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001674 }
John McCall68086b92010-08-21 22:46:04 +00001675
1676 // ARM targets default to using the ARM C++ ABI.
1677 CXXABI = CXXABI_ARM;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00001678 }
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001679 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbarb9531632009-09-14 00:02:24 +00001680 virtual bool setABI(const std::string &Name) {
Daniel Dunbar0d83d512009-09-14 00:35:03 +00001681 ABI = Name;
1682
Daniel Dunbarb9531632009-09-14 00:02:24 +00001683 // The defaults (above) are for AAPCS, check if we need to change them.
1684 //
1685 // FIXME: We need support for -meabi... we could just mangle it into the
1686 // name.
1687 if (Name == "apcs-gnu") {
Daniel Dunbarda94a772010-01-27 20:23:08 +00001688 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbarb9531632009-09-14 00:02:24 +00001689 SizeType = UnsignedLong;
1690
Daniel Dunbar9eb811b2010-04-22 16:14:54 +00001691 // Do not respect the alignment of bit-field types when laying out
1692 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1693 UseBitFieldTypeAlignment = false;
1694
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001695 if (IsThumb) {
1696 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1697 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001698 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001699 } else {
1700 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1701 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001702 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar54f62dc2009-09-22 21:44:58 +00001703 }
1704
Daniel Dunbarb9531632009-09-14 00:02:24 +00001705 // FIXME: Override "preferred align" for double and long long.
1706 } else if (Name == "aapcs") {
1707 // FIXME: Enumerated types are variable width in straight AAPCS.
1708 } else if (Name == "aapcs-linux") {
1709 ;
1710 } else
1711 return false;
1712
1713 return true;
1714 }
Daniel Dunbar48075d82009-12-19 04:15:38 +00001715
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001716 void getDefaultFeatures(const std::string &CPU,
1717 llvm::StringMap<bool> &Features) const {
1718 // FIXME: This should not be here.
1719 Features["vfp2"] = false;
1720 Features["vfp3"] = false;
1721 Features["neon"] = false;
1722
1723 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1724 Features["vfp2"] = true;
1725 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1726 Features["neon"] = true;
1727 }
Michael J. Spencerd5513a32010-10-21 03:16:25 +00001728
Daniel Dunbar48075d82009-12-19 04:15:38 +00001729 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1730 const std::string &Name,
1731 bool Enabled) const {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001732 if (Name == "soft-float" || Name == "soft-float-abi") {
1733 Features[Name] = Enabled;
1734 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1735 // These effectively are a single option, reset them when any is enabled.
1736 if (Enabled)
1737 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1738 Features[Name] = Enabled;
1739 } else
Daniel Dunbar48075d82009-12-19 04:15:38 +00001740 return false;
1741
Daniel Dunbar48075d82009-12-19 04:15:38 +00001742 return true;
1743 }
1744
1745 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001746 FPU = NoFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001747 SoftFloat = SoftFloatABI = false;
1748 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1749 if (Features[i] == "+soft-float")
1750 SoftFloat = true;
1751 else if (Features[i] == "+soft-float-abi")
1752 SoftFloatABI = true;
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001753 else if (Features[i] == "+vfp2")
1754 FPU = VFP2FPU;
1755 else if (Features[i] == "+vfp3")
1756 FPU = VFP3FPU;
1757 else if (Features[i] == "+neon")
1758 FPU = NeonFPU;
Daniel Dunbar48075d82009-12-19 04:15:38 +00001759 }
1760
1761 // Remove front-end specific options which the backend handles differently.
1762 std::vector<std::string>::iterator it;
1763 it = std::find(Features.begin(), Features.end(), "+soft-float");
1764 if (it != Features.end())
1765 Features.erase(it);
1766 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1767 if (it != Features.end())
1768 Features.erase(it);
1769 }
1770
Daniel Dunbar33b40752009-12-18 18:42:37 +00001771 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1772 return llvm::StringSwitch<const char*>(Name)
1773 .Cases("arm8", "arm810", "4")
1774 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1775 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1776 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1777 .Case("ep9312", "4T")
1778 .Cases("arm10tdmi", "arm1020t", "5T")
1779 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1780 .Case("arm926ej-s", "5TEJ")
1781 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1782 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001783 .Case("arm1136j-s", "6J")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001784 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001785 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbar33b40752009-12-18 18:42:37 +00001786 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1787 .Cases("cortex-a8", "cortex-a9", "7A")
1788 .Default(0);
1789 }
1790 virtual bool setCPU(const std::string &Name) {
1791 if (!getCPUDefineSuffix(Name))
1792 return false;
1793
1794 CPU = Name;
1795 return true;
1796 }
Chris Lattner79682402009-03-20 15:52:06 +00001797 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001798 MacroBuilder &Builder) const {
Chris Lattnerbef1d722009-03-02 22:27:17 +00001799 // Target identification.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001800 Builder.defineMacro("__arm");
1801 Builder.defineMacro("__arm__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001802
Chris Lattnerbef1d722009-03-02 22:27:17 +00001803 // Target properties.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001804 Builder.defineMacro("__ARMEL__");
1805 Builder.defineMacro("__LITTLE_ENDIAN__");
1806 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001807
1808 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001809 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikove7772382009-05-03 13:42:53 +00001810
Mike Stumpf90a29f2009-04-08 02:07:04 +00001811 // Subtarget options.
Daniel Dunbarf0156562009-09-17 16:21:10 +00001812
Daniel Dunbar33b40752009-12-18 18:42:37 +00001813 // FIXME: It's more complicated than this and we don't really support
1814 // interworking.
1815 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001816 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001817
Daniel Dunbar33b40752009-12-18 18:42:37 +00001818 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001819 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001820
Daniel Dunbar48075d82009-12-19 04:15:38 +00001821 if (SoftFloat)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001822 Builder.defineMacro("__SOFTFP__");
Daniel Dunbar33b40752009-12-18 18:42:37 +00001823
1824 if (CPU == "xscale")
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001825 Builder.defineMacro("__XSCALE__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001826
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001827 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbarf0156562009-09-17 16:21:10 +00001828 if (IsThumb) {
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001829 Builder.defineMacro("__THUMBEL__");
1830 Builder.defineMacro("__thumb__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001831 if (IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001832 Builder.defineMacro("__thumb2__");
Daniel Dunbarf0156562009-09-17 16:21:10 +00001833 }
1834
1835 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001836 Builder.defineMacro("__APCS_32__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001837
1838 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001839 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar96be2a42009-12-21 23:28:17 +00001840
1841 // This only gets set when Neon instructions are actually available, unlike
1842 // the VFP define, hence the soft float and arch check. This is subtly
1843 // different from gcc, we follow the intent which was that it should be set
1844 // when Neon instructions are actually available.
1845 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001846 Builder.defineMacro("__ARM_NEON__");
Chris Lattner9fd73612008-04-21 18:56:49 +00001847 }
1848 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1849 unsigned &NumRecords) const {
Chris Lattnerb4527522010-03-03 19:03:45 +00001850 Records = BuiltinInfo;
1851 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner9fd73612008-04-21 18:56:49 +00001852 }
1853 virtual const char *getVAListDeclaration() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001854 return "typedef char* __builtin_va_list;";
Chris Lattner9fd73612008-04-21 18:56:49 +00001855 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001856 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001857 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001858 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001859 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001860 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001861 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001862 // FIXME: Check if this is complete
Anders Carlsson36834a72009-02-28 17:11:49 +00001863 switch (*Name) {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001864 default:
Nate Begeman222823a2008-04-22 05:03:19 +00001865 case 'l': // r0-r7
1866 case 'h': // r8-r15
1867 case 'w': // VFP Floating point register single precision
1868 case 'P': // VFP Floating point register double precision
Chris Lattnerc49cc1a2009-04-26 07:16:29 +00001869 Info.setAllowsRegister();
Nate Begeman222823a2008-04-22 05:03:19 +00001870 return true;
1871 }
Chris Lattner9fd73612008-04-21 18:56:49 +00001872 return false;
1873 }
1874 virtual const char *getClobbers() const {
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001875 // FIXME: Is this really right?
Chris Lattner9fd73612008-04-21 18:56:49 +00001876 return "";
1877 }
1878};
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001879
1880const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar663e9f82010-08-11 02:17:20 +00001881 // Integer registers
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001882 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar663e9f82010-08-11 02:17:20 +00001883 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
1884
1885 // Float registers
1886 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
1887 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
1888 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
1889 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31"
1890
1891 // FIXME: Need double and NEON registers, but we need support for aliasing
1892 // multiple registers for that.
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001893};
1894
1895void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00001896 unsigned &NumNames) const {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001897 Names = GCCRegNames;
1898 NumNames = llvm::array_lengthof(GCCRegNames);
1899}
1900
1901const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001902 { { "a1" }, "r0" },
1903 { { "a2" }, "r1" },
1904 { { "a3" }, "r2" },
1905 { { "a4" }, "r3" },
1906 { { "v1" }, "r4" },
1907 { { "v2" }, "r5" },
1908 { { "v3" }, "r6" },
1909 { { "v4" }, "r7" },
1910 { { "v5" }, "r8" },
1911 { { "v6", "rfp" }, "r9" },
1912 { { "sl" }, "r10" },
1913 { { "fp" }, "r11" },
1914 { { "ip" }, "r12" },
Daniel Dunbar00ea8f02010-08-11 02:17:11 +00001915 { { "r13" }, "sp" },
1916 { { "r14" }, "lr" },
1917 { { "r15" }, "pc" },
Daniel Dunbar40b774e2009-09-17 07:03:19 +00001918};
1919
1920void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1921 unsigned &NumAliases) const {
1922 Aliases = GCCRegAliases;
1923 NumAliases = llvm::array_lengthof(GCCRegAliases);
1924}
Chris Lattnerb4527522010-03-03 19:03:45 +00001925
1926const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1927#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1928#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1929#include "clang/Basic/BuiltinsARM.def"
1930};
Chris Lattner9fd73612008-04-21 18:56:49 +00001931} // end anonymous namespace.
1932
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001933
1934namespace {
Mike Stump25cf7602009-09-09 15:08:12 +00001935class DarwinARMTargetInfo :
Edwin Török36565e52009-06-30 17:10:35 +00001936 public DarwinTargetInfo<ARMTargetInfo> {
1937protected:
Daniel Dunbar608b3882009-08-24 09:10:05 +00001938 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001939 MacroBuilder &Builder) const {
Daniel Dunbareab96a22010-01-26 01:44:04 +00001940 getDarwinDefines(Builder, Opts, Triple);
Eli Friedman8f575172009-04-19 21:38:35 +00001941 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001942
Edwin Török36565e52009-06-30 17:10:35 +00001943public:
Mike Stump25cf7602009-09-09 15:08:12 +00001944 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar01045582010-05-27 07:00:26 +00001945 : DarwinTargetInfo<ARMTargetInfo>(triple) {
1946 HasAlignMac68kSupport = true;
1947 }
Eli Friedmanbe727fe2008-08-20 07:44:10 +00001948};
1949} // end anonymous namespace.
1950
Chris Lattner4b009652007-07-25 00:24:17 +00001951namespace {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001952class SparcV8TargetInfo : public TargetInfo {
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001953 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1954 static const char * const GCCRegNames[];
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001955public:
Eli Friedmanff158dd2008-08-20 07:28:14 +00001956 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1957 // FIXME: Support Sparc quad-precision long double?
Eli Friedman2b161652008-08-21 00:13:15 +00001958 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner2e17d912009-11-07 18:59:41 +00001959 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanff158dd2008-08-20 07:28:14 +00001960 }
Chris Lattner79682402009-03-20 15:52:06 +00001961 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00001962 MacroBuilder &Builder) const {
1963 DefineStd(Builder, "sparc", Opts);
1964 Builder.defineMacro("__sparcv8");
1965 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001966 }
1967 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1968 unsigned &NumRecords) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001969 // FIXME: Implement!
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001970 }
1971 virtual const char *getVAListDeclaration() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001972 return "typedef void* __builtin_va_list;";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001973 }
Anton Korobeynikove7772382009-05-03 13:42:53 +00001974 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001975 unsigned &NumNames) const;
Anton Korobeynikove7772382009-05-03 13:42:53 +00001976 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001977 unsigned &NumAliases) const;
Anders Carlsson36834a72009-02-28 17:11:49 +00001978 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001979 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001980 // FIXME: Implement!
1981 return false;
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001982 }
1983 virtual const char *getClobbers() const {
Eli Friedmanff158dd2008-08-20 07:28:14 +00001984 // FIXME: Implement!
1985 return "";
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00001986 }
1987};
1988
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001989const char * const SparcV8TargetInfo::GCCRegNames[] = {
1990 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1991 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1992 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1993 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
1994};
1995
Anton Korobeynikove7772382009-05-03 13:42:53 +00001996void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00001997 unsigned &NumNames) const {
1998 Names = GCCRegNames;
1999 NumNames = llvm::array_lengthof(GCCRegNames);
2000}
2001
2002const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikove7772382009-05-03 13:42:53 +00002003 { { "g0" }, "r0" },
2004 { { "g1" }, "r1" },
2005 { { "g2" }, "r2" },
2006 { { "g3" }, "r3" },
2007 { { "g4" }, "r4" },
2008 { { "g5" }, "r5" },
2009 { { "g6" }, "r6" },
2010 { { "g7" }, "r7" },
2011 { { "o0" }, "r8" },
2012 { { "o1" }, "r9" },
2013 { { "o2" }, "r10" },
2014 { { "o3" }, "r11" },
2015 { { "o4" }, "r12" },
2016 { { "o5" }, "r13" },
2017 { { "o6", "sp" }, "r14" },
2018 { { "o7" }, "r15" },
2019 { { "l0" }, "r16" },
2020 { { "l1" }, "r17" },
2021 { { "l2" }, "r18" },
2022 { { "l3" }, "r19" },
2023 { { "l4" }, "r20" },
2024 { { "l5" }, "r21" },
2025 { { "l6" }, "r22" },
2026 { { "l7" }, "r23" },
2027 { { "i0" }, "r24" },
2028 { { "i1" }, "r25" },
2029 { { "i2" }, "r26" },
2030 { { "i3" }, "r27" },
2031 { { "i4" }, "r28" },
2032 { { "i5" }, "r29" },
2033 { { "i6", "fp" }, "r30" },
2034 { { "i7" }, "r31" },
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002035};
2036
Anton Korobeynikove7772382009-05-03 13:42:53 +00002037void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnerff7c53d2009-01-27 01:58:38 +00002038 unsigned &NumAliases) const {
2039 Aliases = GCCRegAliases;
2040 NumAliases = llvm::array_lengthof(GCCRegAliases);
2041}
Gabor Greif8a3ff0d2008-02-21 16:29:08 +00002042} // end anonymous namespace.
2043
Eli Friedmanff158dd2008-08-20 07:28:14 +00002044namespace {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002045class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2046public:
2047 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2048 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2049 SizeType = UnsignedInt;
2050 PtrDiffType = SignedInt;
2051 }
2052};
Edwin Török36565e52009-06-30 17:10:35 +00002053class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanff158dd2008-08-20 07:28:14 +00002054public:
2055 SolarisSparcV8TargetInfo(const std::string& triple) :
Edwin Török36565e52009-06-30 17:10:35 +00002056 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedman7cca0982008-11-02 02:43:55 +00002057 SizeType = UnsignedInt;
2058 PtrDiffType = SignedInt;
Eli Friedmanff158dd2008-08-20 07:28:14 +00002059 }
2060};
2061} // end anonymous namespace.
Chris Lattner4b009652007-07-25 00:24:17 +00002062
Chris Lattner85970f32008-05-08 05:58:21 +00002063namespace {
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002064 class MSP430TargetInfo : public TargetInfo {
2065 static const char * const GCCRegNames[];
2066 public:
2067 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2068 TLSSupported = false;
Anton Korobeynikov2a6630a2010-01-30 12:55:11 +00002069 IntWidth = 16; IntAlign = 16;
2070 LongWidth = 32; LongLongWidth = 64;
2071 LongAlign = LongLongAlign = 16;
2072 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002073 SizeType = UnsignedInt;
2074 IntMaxType = SignedLong;
2075 UIntMaxType = UnsignedLong;
2076 IntPtrType = SignedShort;
2077 PtrDiffType = SignedInt;
Edward O'Callaghan14a70a32009-11-21 00:49:54 +00002078 SigAtomicType = SignedLong;
Anton Korobeynikov314713f2009-12-19 01:32:37 +00002079 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002080 }
2081 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002082 MacroBuilder &Builder) const {
2083 Builder.defineMacro("MSP430");
2084 Builder.defineMacro("__MSP430__");
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002085 // FIXME: defines for different 'flavours' of MCU
2086 }
2087 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2088 unsigned &NumRecords) const {
2089 // FIXME: Implement.
2090 Records = 0;
2091 NumRecords = 0;
2092 }
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002093 virtual void getGCCRegNames(const char * const *&Names,
2094 unsigned &NumNames) const;
2095 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2096 unsigned &NumAliases) const {
2097 // No aliases.
2098 Aliases = 0;
2099 NumAliases = 0;
2100 }
2101 virtual bool validateAsmConstraint(const char *&Name,
2102 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov174219b2009-10-15 23:17:13 +00002103 // No target constraints for now.
2104 return false;
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002105 }
2106 virtual const char *getClobbers() const {
2107 // FIXME: Is this really right?
2108 return "";
2109 }
2110 virtual const char *getVAListDeclaration() const {
2111 // FIXME: implement
Anton Korobeynikovf5955592009-05-08 18:24:57 +00002112 return "typedef char* __builtin_va_list;";
Anton Korobeynikov954bd3f2009-05-03 13:43:08 +00002113 }
2114 };
2115
2116 const char * const MSP430TargetInfo::GCCRegNames[] = {
2117 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2118 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2119 };
2120
2121 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2122 unsigned &NumNames) const {
2123 Names = GCCRegNames;
2124 NumNames = llvm::array_lengthof(GCCRegNames);
2125 }
2126}
2127
2128
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002129namespace {
2130 class SystemZTargetInfo : public TargetInfo {
2131 static const char * const GCCRegNames[];
2132 public:
2133 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2134 TLSSupported = false;
2135 IntWidth = IntAlign = 32;
2136 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2137 PointerWidth = PointerAlign = 64;
Chris Lattner2e17d912009-11-07 18:59:41 +00002138 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2139 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002140 }
2141 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002142 MacroBuilder &Builder) const {
2143 Builder.defineMacro("__s390__");
2144 Builder.defineMacro("__s390x__");
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002145 }
2146 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2147 unsigned &NumRecords) const {
2148 // FIXME: Implement.
2149 Records = 0;
2150 NumRecords = 0;
2151 }
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002152
Anton Korobeynikov57f236f2009-07-16 20:09:57 +00002153 virtual void getGCCRegNames(const char * const *&Names,
2154 unsigned &NumNames) const;
2155 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2156 unsigned &NumAliases) const {
2157 // No aliases.
2158 Aliases = 0;
2159 NumAliases = 0;
2160 }
2161 virtual bool validateAsmConstraint(const char *&Name,
2162 TargetInfo::ConstraintInfo &info) const {
2163 // FIXME: implement
2164 return true;
2165 }
2166 virtual const char *getClobbers() const {
2167 // FIXME: Is this really right?
2168 return "";
2169 }
2170 virtual const char *getVAListDeclaration() const {
2171 // FIXME: implement
2172 return "typedef char* __builtin_va_list;";
2173 }
2174 };
2175
2176 const char * const SystemZTargetInfo::GCCRegNames[] = {
2177 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2178 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2179 };
2180
2181 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2182 unsigned &NumNames) const {
2183 Names = GCCRegNames;
2184 NumNames = llvm::array_lengthof(GCCRegNames);
2185 }
2186}
2187
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002188namespace {
2189 class BlackfinTargetInfo : public TargetInfo {
2190 static const char * const GCCRegNames[];
2191 public:
2192 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2193 TLSSupported = false;
2194 DoubleAlign = 32;
2195 LongLongAlign = 32;
2196 LongDoubleAlign = 32;
Chris Lattner2e17d912009-11-07 18:59:41 +00002197 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002198 }
2199
2200 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002201 MacroBuilder &Builder) const {
2202 DefineStd(Builder, "bfin", Opts);
2203 DefineStd(Builder, "BFIN", Opts);
2204 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002205 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002206 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002207 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2208 }
2209
2210 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2211 unsigned &NumRecords) const {
2212 // FIXME: Implement.
2213 Records = 0;
2214 NumRecords = 0;
2215 }
2216
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002217 virtual void getGCCRegNames(const char * const *&Names,
2218 unsigned &NumNames) const;
2219
2220 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2221 unsigned &NumAliases) const {
2222 // No aliases.
2223 Aliases = 0;
2224 NumAliases = 0;
2225 }
2226
2227 virtual bool validateAsmConstraint(const char *&Name,
2228 TargetInfo::ConstraintInfo &Info) const {
2229 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2230 Info.setAllowsRegister();
2231 return true;
2232 }
2233 return false;
2234 }
2235
2236 virtual const char *getClobbers() const {
2237 return "";
2238 }
2239
2240 virtual const char *getVAListDeclaration() const {
2241 return "typedef char* __builtin_va_list;";
2242 }
2243 };
2244
2245 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2246 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2247 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2248 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2249 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2250 "a0", "a1", "cc",
2251 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2252 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2253 };
2254
2255 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2256 unsigned &NumNames) const {
2257 Names = GCCRegNames;
2258 NumNames = llvm::array_lengthof(GCCRegNames);
2259 }
2260}
2261
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002262namespace {
2263
Mike Stump25cf7602009-09-09 15:08:12 +00002264 // LLVM and Clang cannot be used directly to output native binaries for
2265 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002266 // type and alignment information.
Mike Stump25cf7602009-09-09 15:08:12 +00002267 //
2268 // TCE uses the llvm bitcode as input and uses it for generating customized
2269 // target processor and program binary. TCE co-design environment is
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002270 // publicly available in http://tce.cs.tut.fi
2271
2272 class TCETargetInfo : public TargetInfo{
2273 public:
2274 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2275 TLSSupported = false;
2276 IntWidth = 32;
2277 LongWidth = LongLongWidth = 32;
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002278 PointerWidth = 32;
2279 IntAlign = 32;
2280 LongAlign = LongLongAlign = 32;
2281 PointerAlign = 32;
2282 SizeType = UnsignedInt;
2283 IntMaxType = SignedLong;
2284 UIntMaxType = UnsignedLong;
2285 IntPtrType = SignedInt;
2286 PtrDiffType = SignedInt;
2287 FloatWidth = 32;
2288 FloatAlign = 32;
2289 DoubleWidth = 32;
2290 DoubleAlign = 32;
2291 LongDoubleWidth = 32;
2292 LongDoubleAlign = 32;
2293 FloatFormat = &llvm::APFloat::IEEEsingle;
2294 DoubleFormat = &llvm::APFloat::IEEEsingle;
2295 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner8a1db932010-03-04 21:07:38 +00002296 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2297 "i16:16:32-i32:32:32-i64:32:32-"
2298 "f32:32:32-f64:64:64-v64:64:64-"
2299 "v128:128:128-a0:0:64-n32";
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002300 }
2301
2302 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002303 MacroBuilder &Builder) const {
2304 DefineStd(Builder, "tce", Opts);
2305 Builder.defineMacro("__TCE__");
2306 Builder.defineMacro("__TCE_V1__");
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002307 }
2308 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2309 unsigned &NumRecords) const {}
Daniel Dunbar2e967de2009-08-24 09:54:37 +00002310 virtual const char *getClobbers() const {
2311 return "";
2312 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002313 virtual const char *getVAListDeclaration() const {
2314 return "typedef void* __builtin_va_list;";
2315 }
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002316 virtual void getGCCRegNames(const char * const *&Names,
2317 unsigned &NumNames) const {}
2318 virtual bool validateAsmConstraint(const char *&Name,
2319 TargetInfo::ConstraintInfo &info) const {
2320 return true;
2321 }
2322 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2323 unsigned &NumAliases) const {}
2324 };
2325}
2326
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002327namespace {
2328class MipsTargetInfo : public TargetInfo {
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002329 std::string ABI, CPU;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002330 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2331 static const char * const GCCRegNames[];
2332public:
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002333 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002334 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2335 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2336 }
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002337 virtual const char *getABI() const { return ABI.c_str(); }
2338 virtual bool setABI(const std::string &Name) {
2339
2340 if ((Name == "o32") || (Name == "eabi")) {
2341 ABI = Name;
2342 return true;
2343 } else
2344 return false;
2345 }
2346 virtual bool setCPU(const std::string &Name) {
2347 CPU = Name;
2348 return true;
2349 }
2350 void getDefaultFeatures(const std::string &CPU,
2351 llvm::StringMap<bool> &Features) const {
2352 Features[ABI] = true;
2353 Features[CPU] = true;
2354 }
2355 virtual void getArchDefines(const LangOptions &Opts,
2356 MacroBuilder &Builder) const {
2357 if (ABI == "o32")
2358 Builder.defineMacro("__mips_o32");
2359 else if (ABI == "eabi")
2360 Builder.defineMacro("__mips_eabi");
2361 }
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002362 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002363 MacroBuilder &Builder) const {
2364 DefineStd(Builder, "mips", Opts);
2365 Builder.defineMacro("_mips");
2366 DefineStd(Builder, "MIPSEB", Opts);
2367 Builder.defineMacro("_MIPSEB");
2368 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002369 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002370 }
2371 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2372 unsigned &NumRecords) const {
2373 // FIXME: Implement!
2374 }
2375 virtual const char *getVAListDeclaration() const {
2376 return "typedef void* __builtin_va_list;";
2377 }
2378 virtual void getGCCRegNames(const char * const *&Names,
2379 unsigned &NumNames) const;
2380 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2381 unsigned &NumAliases) const;
2382 virtual bool validateAsmConstraint(const char *&Name,
2383 TargetInfo::ConstraintInfo &Info) const {
2384 switch (*Name) {
2385 default:
2386 case 'r': // CPU registers.
2387 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2388 case 'y': // Equivalent to "r", backwards compatibility only.
2389 case 'f': // floating-point registers.
2390 Info.setAllowsRegister();
2391 return true;
2392 }
2393 return false;
2394 }
2395
2396 virtual const char *getClobbers() const {
2397 // FIXME: Implement!
2398 return "";
2399 }
2400};
2401
2402const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencerd5513a32010-10-21 03:16:25 +00002403 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002404 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2405 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2406 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2407 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2408 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2409 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2410 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2411 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2412 "$fcc5","$fcc6","$fcc7"
2413};
2414
2415void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2416 unsigned &NumNames) const {
2417 Names = GCCRegNames;
2418 NumNames = llvm::array_lengthof(GCCRegNames);
2419}
2420
2421const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2422 { { "at" }, "$1" },
2423 { { "v0" }, "$2" },
2424 { { "v1" }, "$3" },
2425 { { "a0" }, "$4" },
2426 { { "a1" }, "$5" },
2427 { { "a2" }, "$6" },
2428 { { "a3" }, "$7" },
2429 { { "t0" }, "$8" },
2430 { { "t1" }, "$9" },
2431 { { "t2" }, "$10" },
2432 { { "t3" }, "$11" },
2433 { { "t4" }, "$12" },
2434 { { "t5" }, "$13" },
2435 { { "t6" }, "$14" },
2436 { { "t7" }, "$15" },
2437 { { "s0" }, "$16" },
2438 { { "s1" }, "$17" },
2439 { { "s2" }, "$18" },
2440 { { "s3" }, "$19" },
2441 { { "s4" }, "$20" },
2442 { { "s5" }, "$21" },
2443 { { "s6" }, "$22" },
2444 { { "s7" }, "$23" },
2445 { { "t8" }, "$24" },
2446 { { "t9" }, "$25" },
2447 { { "k0" }, "$26" },
2448 { { "k1" }, "$27" },
2449 { { "gp" }, "$28" },
2450 { { "sp" }, "$29" },
2451 { { "fp" }, "$30" },
2452 { { "ra" }, "$31" }
2453};
2454
2455void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2456 unsigned &NumAliases) const {
2457 Aliases = GCCRegAliases;
2458 NumAliases = llvm::array_lengthof(GCCRegAliases);
2459}
2460} // end anonymous namespace.
2461
2462namespace {
2463class MipselTargetInfo : public MipsTargetInfo {
2464public:
2465 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2466 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2467 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2468 }
2469
2470 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002471 MacroBuilder &Builder) const;
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002472};
2473
2474void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer9ffb10432010-01-09 17:55:51 +00002475 MacroBuilder &Builder) const {
2476 DefineStd(Builder, "mips", Opts);
2477 Builder.defineMacro("_mips");
2478 DefineStd(Builder, "MIPSEL", Opts);
2479 Builder.defineMacro("_MIPSEL");
2480 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher03cc0ef2010-03-02 02:41:08 +00002481 getArchDefines(Opts, Builder);
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002482}
2483} // end anonymous namespace.
2484
Chris Lattner4b009652007-07-25 00:24:17 +00002485//===----------------------------------------------------------------------===//
2486// Driver code
2487//===----------------------------------------------------------------------===//
2488
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002489static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002490 llvm::Triple Triple(T);
2491 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002492
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002493 switch (Triple.getArch()) {
2494 default:
2495 return NULL;
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002496
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002497 case llvm::Triple::arm:
Daniel Dunbar3f361b52009-09-11 01:14:50 +00002498 case llvm::Triple::thumb:
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002499 switch (os) {
Rafael Espindolad16a2202010-06-10 00:46:51 +00002500 case llvm::Triple::Linux:
2501 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002502 case llvm::Triple::Darwin:
Eli Friedman2b161652008-08-21 00:13:15 +00002503 return new DarwinARMTargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002504 case llvm::Triple::FreeBSD:
Edwin Török36565e52009-06-30 17:10:35 +00002505 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002506 default:
2507 return new ARMTargetInfo(T);
2508 }
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002509
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002510 case llvm::Triple::bfin:
Jakob Stoklund Olesen61774372009-08-17 20:08:44 +00002511 return new BlackfinTargetInfo(T);
2512
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002513 case llvm::Triple::msp430:
2514 return new MSP430TargetInfo(T);
Eli Friedman0b7b1cb2008-05-20 14:21:01 +00002515
Edward O'Callaghan097309f2009-11-15 10:22:07 +00002516 case llvm::Triple::mips:
2517 if (os == llvm::Triple::Psp)
2518 return new PSPTargetInfo<MipsTargetInfo>(T);
2519 if (os == llvm::Triple::Linux)
2520 return new LinuxTargetInfo<MipsTargetInfo>(T);
2521 return new MipsTargetInfo(T);
2522
2523 case llvm::Triple::mipsel:
2524 if (os == llvm::Triple::Psp)
2525 return new PSPTargetInfo<MipselTargetInfo>(T);
2526 if (os == llvm::Triple::Linux)
2527 return new LinuxTargetInfo<MipselTargetInfo>(T);
2528 return new MipselTargetInfo(T);
2529
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002530 case llvm::Triple::ppc:
2531 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002532 return new DarwinPPCTargetInfo(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002533 else if (os == llvm::Triple::FreeBSD)
2534 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002535 return new PPC32TargetInfo(T);
2536
2537 case llvm::Triple::ppc64:
2538 if (os == llvm::Triple::Darwin)
Daniel Dunbar6501cab2010-05-30 00:07:30 +00002539 return new DarwinPPC64TargetInfo(T);
John Thompsoned7bdbc2009-11-19 17:18:50 +00002540 else if (os == llvm::Triple::Lv2)
2541 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerf8030412010-02-16 18:14:57 +00002542 else if (os == llvm::Triple::FreeBSD)
2543 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002544 return new PPC64TargetInfo(T);
2545
Chris Lattner2c026472010-03-06 21:21:27 +00002546 case llvm::Triple::mblaze:
2547 return new MBlazeTargetInfo(T);
2548
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002549 case llvm::Triple::sparc:
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002550 if (os == llvm::Triple::AuroraUX)
2551 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002552 if (os == llvm::Triple::Solaris)
2553 return new SolarisSparcV8TargetInfo(T);
2554 return new SparcV8TargetInfo(T);
2555
John Thompsoned7bdbc2009-11-19 17:18:50 +00002556 // FIXME: Need a real SPU target.
2557 case llvm::Triple::cellspu:
2558 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2559
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002560 case llvm::Triple::systemz:
2561 return new SystemZTargetInfo(T);
2562
Eli Friedmanf0ff32f2009-08-19 20:47:07 +00002563 case llvm::Triple::tce:
2564 return new TCETargetInfo(T);
2565
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002566 case llvm::Triple::x86:
2567 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002568 case llvm::Triple::AuroraUX:
2569 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002570 case llvm::Triple::Darwin:
2571 return new DarwinI386TargetInfo(T);
2572 case llvm::Triple::Linux:
2573 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2574 case llvm::Triple::DragonFly:
2575 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2576 case llvm::Triple::NetBSD:
2577 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2578 case llvm::Triple::OpenBSD:
2579 return new OpenBSDI386TargetInfo(T);
2580 case llvm::Triple::FreeBSD:
2581 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner6f4bed52010-07-07 16:01:42 +00002582 case llvm::Triple::Minix:
2583 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002584 case llvm::Triple::Solaris:
2585 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2586 case llvm::Triple::Cygwin:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002587 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002588 case llvm::Triple::MinGW32:
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002589 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002590 case llvm::Triple::Win32:
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002591 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerf853e732010-04-11 19:29:39 +00002592 case llvm::Triple::Haiku:
2593 return new HaikuX86_32TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002594 default:
2595 return new X86_32TargetInfo(T);
2596 }
2597
2598 case llvm::Triple::x86_64:
2599 switch (os) {
Edward O'Callaghan0a7ef9a2009-10-18 13:33:59 +00002600 case llvm::Triple::AuroraUX:
2601 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002602 case llvm::Triple::Darwin:
2603 return new DarwinX86_64TargetInfo(T);
2604 case llvm::Triple::Linux:
2605 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner1eac0812010-01-09 05:41:14 +00002606 case llvm::Triple::DragonFly:
2607 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002608 case llvm::Triple::NetBSD:
2609 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2610 case llvm::Triple::OpenBSD:
2611 return new OpenBSDX86_64TargetInfo(T);
2612 case llvm::Triple::FreeBSD:
2613 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2614 case llvm::Triple::Solaris:
2615 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar8d8e9d62009-09-23 07:31:35 +00002616 case llvm::Triple::MinGW64:
2617 return new MinGWX86_64TargetInfo(T);
2618 case llvm::Triple::Win32: // This is what Triple.h supports now.
Michael J. Spencer4fb461c2010-10-21 08:22:51 +00002619 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar8ba3de02009-08-18 05:47:58 +00002620 default:
2621 return new X86_64TargetInfo(T);
2622 }
2623 }
Chris Lattner4b009652007-07-25 00:24:17 +00002624}
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002625
2626/// CreateTargetInfo - Return the target info object for the specified target
2627/// triple.
2628TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002629 TargetOptions &Opts) {
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002630 llvm::Triple Triple(Opts.Triple);
2631
2632 // Construct the target
2633 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2634 if (!Target) {
2635 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2636 return 0;
2637 }
2638
Daniel Dunbar33b40752009-12-18 18:42:37 +00002639 // Set the target CPU if specified.
2640 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2641 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2642 return 0;
2643 }
2644
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002645 // Set the target ABI if specified.
2646 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2647 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2648 return 0;
2649 }
2650
Charles Davisfed3a2b2010-06-11 01:06:47 +00002651 // Set the target C++ ABI.
John McCall68086b92010-08-21 22:46:04 +00002652 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davisfed3a2b2010-06-11 01:06:47 +00002653 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2654 return 0;
2655 }
2656
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002657 // Compute the default target features, we need the target to handle this
2658 // because features may have dependencies on one another.
2659 llvm::StringMap<bool> Features;
2660 Target->getDefaultFeatures(Opts.CPU, Features);
2661
2662 // Apply the user specified deltas.
2663 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2664 ie = Opts.Features.end(); it != ie; ++it) {
2665 const char *Name = it->c_str();
2666
2667 // Apply the feature via the target.
2668 if ((Name[0] != '-' && Name[0] != '+') ||
2669 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2670 Diags.Report(diag::err_target_invalid_feature) << Name;
2671 return 0;
2672 }
2673 }
2674
2675 // Add the features to the compile options.
2676 //
2677 // FIXME: If we are completely confident that we have the right set, we only
2678 // need to pass the minuses.
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002679 Opts.Features.clear();
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002680 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2681 ie = Features.end(); it != ie; ++it)
Daniel Dunbar4f7cd962009-12-19 03:30:57 +00002682 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2683 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarca3e9912009-11-15 06:48:46 +00002684
2685 return Target.take();
2686}