blob: 631aa1f33d9f61e6f2a493986dd3897644726c31 [file] [log] [blame]
Chris Lattner5ba61f02006-10-14 07:39:34 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-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 Lattner5ba61f02006-10-14 07:39:34 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek6f6ff372007-12-12 18:05:32 +000011// target triple.
Chris Lattner5ba61f02006-10-14 07:39:34 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5ba61f02006-10-14 07:39:34 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerc7c6dd42008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth26b29a02010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000029#include <algorithm>
Chris Lattner5ba61f02006-10-14 07:39:34 +000030using namespace clang;
31
Chris Lattner5ba61f02006-10-14 07:39:34 +000032//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000033// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000034//===----------------------------------------------------------------------===//
35
Chris Lattner1e1c0b92009-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 Kramer2d6fda32010-01-09 17:55:51 +000039static void DefineStd(MacroBuilder &Builder, llvm::StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000040 const LangOptions &Opts) {
41 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000042
Chris Lattner1e1c0b92009-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 Kramer2d6fda32010-01-09 17:55:51 +000046 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000047
Chris Lattner1e1c0b92009-03-20 16:06:38 +000048 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000049 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000050
Chris Lattner1e1c0b92009-03-20 16:06:38 +000051 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000052 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000053}
54
Chris Lattner09d98f52008-10-05 21:50:58 +000055//===----------------------------------------------------------------------===//
56// Defines specific to certain operating systems.
57//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000058
Torok Edwinb2b37c62009-06-30 17:10:35 +000059namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000060template<typename TgtInfo>
61class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000062protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000063 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000064 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000065public:
Douglas Gregorc05d2a12009-07-01 15:12:53 +000066 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwinb2b37c62009-06-30 17:10:35 +000067 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000068 MacroBuilder &Builder) const {
69 TgtInfo::getTargetDefines(Opts, Builder);
70 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000071 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000072
73};
Chris Lattner859c37a2009-08-12 06:24:27 +000074} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000075
Chris Lattner30ba6742009-08-10 19:03:04 +000076
Daniel Dunbard86666f2010-01-26 01:44:04 +000077static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
78 const llvm::Triple &Triple) {
Benjamin Kramer2d6fda32010-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 Korobeynikov9d026dd2009-05-03 13:42:53 +000083
Chris Lattner2a5c0a32009-04-07 16:50:40 +000084 // __weak is always defined, for use in blocks and with objc pointers.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000085 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000086
Chris Lattner2a5c0a32009-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 Kramer2d6fda32010-01-09 17:55:51 +000089 Builder.defineMacro("__strong", "");
Chris Lattner2a5c0a32009-04-07 16:50:40 +000090 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000091 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
Eli Friedmanfd4b1552009-06-04 23:00:29 +000092
93 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000094 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +000095 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000096 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +000097
98 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000099 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000100
Daniel Dunbard86666f2010-01-26 01:44:04 +0000101 // Get the OS version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000102 unsigned Maj, Min, Rev;
Mike Stump11289f42009-09-09 15:08:12 +0000103
Daniel Dunbard86666f2010-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 Dunbar497ff132009-04-10 19:52:24 +0000138 }
Eli Friedman3fd920a2008-08-20 02:34:37 +0000139}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000140
Chris Lattner30ba6742009-08-10 19:03:04 +0000141namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000142template<typename Target>
143class DarwinTargetInfo : public OSTargetInfo<Target> {
144protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000145 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000146 MacroBuilder &Builder) const {
Daniel Dunbard86666f2010-01-26 01:44:04 +0000147 getDarwinDefines(Builder, Opts, Triple);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000148 }
Mike Stump11289f42009-09-09 15:08:12 +0000149
Torok Edwinb2b37c62009-06-30 17:10:35 +0000150public:
151 DarwinTargetInfo(const std::string& triple) :
152 OSTargetInfo<Target>(triple) {
Eric Christopher17c7b892010-06-25 19:04:52 +0000153 this->TLSSupported = llvm::Triple(triple).getDarwinMajorNumber() > 10;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000154 }
155
Anders Carlsson0b0a1222010-01-30 18:33:31 +0000156 virtual std::string isValidSectionSpecifier(llvm::StringRef SR) const {
Chris Lattner30ba6742009-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. Spencer4c0ffa82010-10-21 03:16:25 +0000163
Anders Carlsson851318a2010-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. Spencer4c0ffa82010-10-21 03:16:25 +0000168
Torok Edwinb2b37c62009-06-30 17:10:35 +0000169};
170
Chris Lattner30ba6742009-08-10 19:03:04 +0000171
Torok Edwinb2b37c62009-06-30 17:10:35 +0000172// DragonFlyBSD Target
173template<typename Target>
174class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
175protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000176 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000177 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000178 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-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);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000185 }
186public:
Mike Stump11289f42009-09-09 15:08:12 +0000187 DragonFlyBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000188 : OSTargetInfo<Target>(triple) {}
189};
190
191// FreeBSD Target
192template<typename Target>
193class FreeBSDTargetInfo : public OSTargetInfo<Target> {
194protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000195 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000196 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000197 // FreeBSD defines; list based off of gcc output
198
Daniel Dunbar40165182009-08-24 09:10:05 +0000199 // FIXME: Move version number handling to llvm::Triple.
Benjamin Kramer31a68e72010-01-30 19:55:01 +0000200 llvm::StringRef Release = Triple.getOSName().substr(strlen("freebsd"), 1);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000201
Benjamin Kramer31a68e72010-01-30 19:55:01 +0000202 Builder.defineMacro("__FreeBSD__", Release);
203 Builder.defineMacro("__FreeBSD_cc_version", Release + "00001");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000204 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
205 DefineStd(Builder, "unix", Opts);
206 Builder.defineMacro("__ELF__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000207 }
208public:
Mike Stump11289f42009-09-09 15:08:12 +0000209 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands9cb27e92009-07-08 13:55:08 +0000210 : OSTargetInfo<Target>(triple) {
211 this->UserLabelPrefix = "";
212 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000213};
214
Chris Lattner3e2ee142010-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
Torok Edwinb2b37c62009-06-30 17:10:35 +0000239// Linux target
240template<typename Target>
241class LinuxTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000245 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-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 Dunbara77eaeb2009-09-03 04:54:28 +0000250 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000251 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000252 if (Opts.CPlusPlus)
253 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000254 }
255public:
Mike Stump11289f42009-09-09 15:08:12 +0000256 LinuxTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000257 : OSTargetInfo<Target>(triple) {
258 this->UserLabelPrefix = "";
259 }
260};
261
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000262// NetBSD Target
263template<typename Target>
264class NetBSDTargetInfo : public OSTargetInfo<Target> {
265protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000266 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000267 MacroBuilder &Builder) const {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000268 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000269 Builder.defineMacro("__NetBSD__");
270 Builder.defineMacro("__unix__");
271 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000272 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000273 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000274 }
275public:
Mike Stump11289f42009-09-09 15:08:12 +0000276 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000277 : OSTargetInfo<Target>(triple) {
278 this->UserLabelPrefix = "";
279 }
280};
281
Torok Edwinb2b37c62009-06-30 17:10:35 +0000282// OpenBSD Target
283template<typename Target>
284class OpenBSDTargetInfo : public OSTargetInfo<Target> {
285protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000286 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000287 MacroBuilder &Builder) const {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000288 // OpenBSD defines; list based off of gcc output
289
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000290 Builder.defineMacro("__OpenBSD__");
291 DefineStd(Builder, "unix", Opts);
292 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000293 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000294 Builder.defineMacro("_POSIX_THREADS");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000295 }
296public:
Mike Stump11289f42009-09-09 15:08:12 +0000297 OpenBSDTargetInfo(const std::string &triple)
Torok Edwinb2b37c62009-06-30 17:10:35 +0000298 : OSTargetInfo<Target>(triple) {}
299};
300
Edward O'Callaghane9a58b12009-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 Kramer2d6fda32010-01-09 17:55:51 +0000306 MacroBuilder &Builder) const {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000307 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000308 Builder.defineMacro("PSP");
309 Builder.defineMacro("_PSP");
310 Builder.defineMacro("__psp__");
311 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000312 }
313public:
314 PSPTargetInfo(const std::string& triple)
315 : OSTargetInfo<Target>(triple) {
316 this->UserLabelPrefix = "";
317 }
318};
319
John Thompsone467e192009-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 Kramer2d6fda32010-01-09 17:55:51 +0000325 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000326 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000327 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000328 Builder.defineMacro("__PPU__");
329 Builder.defineMacro("__CELLOS_LV2__");
330 Builder.defineMacro("__ELF__");
331 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000332 Builder.defineMacro("_ARCH_PPC64");
333 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000334 }
335public:
336 PS3PPUTargetInfo(const std::string& triple)
337 : OSTargetInfo<Target>(triple) {
338 this->UserLabelPrefix = "";
John Thompson6f8dba72009-12-18 14:21:08 +0000339 this->LongWidth = this->LongAlign = this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000340 this->IntMaxType = TargetInfo::SignedLongLong;
341 this->UIntMaxType = TargetInfo::UnsignedLongLong;
342 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000343 this->SizeType = TargetInfo::UnsignedInt;
John Thompson07a61a42010-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 Thompsone467e192009-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 Kramer2d6fda32010-01-09 17:55:51 +0000355 MacroBuilder &Builder) const {
John Thompsone467e192009-11-19 17:18:50 +0000356 // PS3 PPU defines.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000357 Builder.defineMacro("__SPU__");
358 Builder.defineMacro("__ELF__");
John Thompsone467e192009-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'Callaghan9dda8e982009-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 Kramer2d6fda32010-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'Callaghan9dda8e982009-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
Torok Edwinb2b37c62009-06-30 17:10:35 +0000388// Solaris target
389template<typename Target>
390class SolarisTargetInfo : public OSTargetInfo<Target> {
391protected:
Daniel Dunbar40165182009-08-24 09:10:05 +0000392 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-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");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000399 }
400public:
Mike Stump11289f42009-09-09 15:08:12 +0000401 SolarisTargetInfo(const std::string& triple)
Torok Edwinb2b37c62009-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. Spencer4992ca4b2010-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. Spencer54bf3c32010-10-21 08:22:51 +0000415 Builder.defineMacro("_WIN32");
416 }
417 void getVisualStudioDefines(const LangOptions &Opts,
418 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-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. Spencer54bf3c32010-10-21 08:22:51 +0000434
Michael J. Spencer4992ca4b2010-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. Spencer4992ca4b2010-10-21 05:21:48 +0000449 }
450
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000451public:
452 WindowsTargetInfo(const std::string &triple)
453 : OSTargetInfo<Target>(triple) {}
454};
455
Mike Stump11289f42009-09-09 15:08:12 +0000456} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000457
Chris Lattner09d98f52008-10-05 21:50:58 +0000458//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000459// Specific target implementations.
460//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000461
Eli Friedmanb9e5bed2008-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 Friedman9ffd4a92009-06-05 07:05:05 +0000470 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {}
471
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000472 virtual void getTargetBuiltins(const Builtin::Info *&Records,
473 unsigned &NumRecords) const {
Chris Lattner10a5b382007-01-29 05:24:35 +0000474 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000475 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000476 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000477
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000478 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000479 MacroBuilder &Builder) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000480
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000481 virtual const char *getVAListDeclaration() const {
Chris Lattner69f9bc22008-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 Friedmanb9e5bed2008-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 Lattner69f9bc22008-10-27 01:11:29 +0000490 "} __builtin_va_list[1];";*/
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000491 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000492 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000493 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000494 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000495 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +0000496 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +0000497 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +0000498 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000499 default: return false;
500 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000501 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000502 case 'b': // Base register
503 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000504 Info.setAllowsRegister();
John Thompson07a61a42010-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. Spencer4c0ffa82010-10-21 03:16:25 +0000509 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-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. Spencer4c0ffa82010-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 Thompson07a61a42010-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. Spencer4c0ffa82010-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 Thompson07a61a42010-06-24 22:44:13 +0000533 Info.setAllowsRegister();
534 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000535 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000536 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-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 Thompson07a61a42010-06-24 22:44:13 +0000543 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000544 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000545 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000546 // into a register using three instructions
John Thompson07a61a42010-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 Redldd008712010-08-17 22:42:34 +0000553 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000554 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000555 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000556 // is correct but:
John Thompson07a61a42010-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. Spencer4c0ffa82010-10-21 03:16:25 +0000559 // register to be updated.
560 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000561 if (Name[1] != 's')
562 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000563 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-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 Thompsonceebdf12010-06-25 00:02:05 +0000567 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000568 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000569 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000570 break;
571 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000572 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-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. Spencer4c0ffa82010-10-21 03:16:25 +0000575 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000576 Info.setAllowsMemory();
577 Info.setAllowsRegister();
578 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000579 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000580 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-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 Thompson07a61a42010-06-24 22:44:13 +0000585 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-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 Thompson07a61a42010-06-24 22:44:13 +0000589 break;
590 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000591 }
John Thompson07a61a42010-06-24 22:44:13 +0000592 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000593 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000594 virtual const char *getClobbers() const {
595 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000596 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000597};
Anders Carlssonf511f642007-11-27 04:11:28 +0000598
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000599const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Douglas Gregor9eebd972009-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 Lattner5abdec72009-06-14 01:05:48 +0000602#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000603};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000604
605
Chris Lattnerecd49032009-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 Lattner4ba73aa02009-03-20 15:52:06 +0000608void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000609 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000610 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000611 Builder.defineMacro("__ppc__");
612 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000613 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000614 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000615 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000616 Builder.defineMacro("_ARCH_PPC64");
617 Builder.defineMacro("_LP64");
618 Builder.defineMacro("__LP64__");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000619 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000620 Builder.defineMacro("__ppc64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000621 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000622 Builder.defineMacro("__ppc__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000623 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000624
Chris Lattnerecd49032009-03-02 22:27:17 +0000625 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000626 Builder.defineMacro("_BIG_ENDIAN");
627 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000628
Chris Lattnerecd49032009-03-02 22:27:17 +0000629 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000630 Builder.defineMacro("__NATURAL_ALIGNMENT__");
631 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000632
Chris Lattnerecd49032009-03-02 22:27:17 +0000633 // FIXME: Should be controlled by command line option.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000634 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000635
John Thompsone467e192009-11-19 17:18:50 +0000636 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000637 Builder.defineMacro("__VEC__", "10206");
638 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000639 }
Chris Lattnerecd49032009-03-02 22:27:17 +0000640}
641
Chris Lattner17df24e2008-04-21 18:56:49 +0000642
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000643const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-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 Friedmanb9e5bed2008-08-20 23:11:40 +0000652 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +0000653 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000654 "xer",
Chris Lattnerf7ff53d2009-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 Friedmanb9e5bed2008-08-20 23:11:40 +0000659 "vrsave", "vscr",
660 "spe_acc", "spefscr",
661 "sfp"
662};
Chris Lattner10a5b382007-01-29 05:24:35 +0000663
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000664void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000665 unsigned &NumNames) const {
666 Names = GCCRegNames;
667 NumNames = llvm::array_lengthof(GCCRegNames);
668}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000669
Eli Friedmanb9e5bed2008-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 Dunbar1da76c42009-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 Stumpfaacf012009-09-17 21:15:00 +0000715 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-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 Friedmanb9e5bed2008-08-20 23:11:40 +0000738};
739
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000740void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000741 unsigned &NumAliases) const {
742 Aliases = GCCRegAliases;
743 NumAliases = llvm::array_lengthof(GCCRegAliases);
744}
745} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +0000746
Chris Lattner5ba61f02006-10-14 07:39:34 +0000747namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000748class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000749public:
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000750 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedman873f65a2008-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 Lattner5c67237f2009-11-07 18:59:41 +0000752 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000753
754 if (getTriple().getOS() == llvm::Triple::FreeBSD)
755 this->SizeType = TargetInfo::UnsignedInt;
Eli Friedman873f65a2008-08-21 00:13:15 +0000756 }
Chris Lattner5ba61f02006-10-14 07:39:34 +0000757};
758} // end anonymous namespace.
759
760namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000761class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +0000762public:
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000763 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000764 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +0000765 IntMaxType = SignedLong;
766 UIntMaxType = UnsignedLong;
767 Int64Type = SignedLong;
Eli Friedman873f65a2008-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 Lattner5c67237f2009-11-07 18:59:41 +0000769 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Chris Lattnerba7a6c12008-05-09 06:17:04 +0000770 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000771};
772} // end anonymous namespace.
773
Daniel Dunbar0e15c9a2010-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 Lattner5ba61f02006-10-14 07:39:34 +0000795namespace {
Chris Lattner5178f562010-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 Friedman3fd920a2008-08-20 02:34:37 +0000924// Namespace for x86 abstract base class
925const Builtin::Info BuiltinInfo[] = {
Douglas Gregor9eebd972009-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 Lattner5abdec72009-06-14 01:05:48 +0000928#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +0000929};
Eli Friedmanb5366062008-05-20 14:21:01 +0000930
Nuno Lopescfca1f02009-12-23 17:49:57 +0000931static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-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 Lattner96e43572009-03-02 22:40:39 +0000955 enum X86SSEEnum {
956 NoMMXSSE, MMX, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42
957 } SSELevel;
Anders Carlssone437c682010-01-27 03:47:49 +0000958 enum AMD3DNowEnum {
959 NoAMD3DNow, AMD3DNow, AMD3DNowAthlon
960 } AMD3DNowLevel;
961
Eric Christophere1ddaf92010-04-02 23:50:19 +0000962 bool HasAES;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +0000963 bool HasAVX;
964
Eli Friedman3fd920a2008-08-20 02:34:37 +0000965public:
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000966 X86TargetInfo(const std::string& triple)
Eric Christophere1ddaf92010-04-02 23:50:19 +0000967 : TargetInfo(triple), SSELevel(NoMMXSSE), AMD3DNowLevel(NoAMD3DNow),
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +0000968 HasAES(false), HasAVX(false) {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000969 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +0000970 }
Chris Lattner10a5b382007-01-29 05:24:35 +0000971 virtual void getTargetBuiltins(const Builtin::Info *&Records,
972 unsigned &NumRecords) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000973 Records = BuiltinInfo;
974 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000975 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000976 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman3fd920a2008-08-20 02:34:37 +0000977 unsigned &NumNames) const {
978 Names = GCCRegNames;
979 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000980 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000981 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson5fa3f342007-11-24 23:38:12 +0000982 unsigned &NumAliases) const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000983 Aliases = GCCRegAliases;
984 NumAliases = llvm::array_lengthof(GCCRegAliases);
Anders Carlssona7408e72007-10-13 00:45:48 +0000985 }
Anders Carlsson58436352009-02-28 17:11:49 +0000986 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman3fd920a2008-08-20 02:34:37 +0000987 TargetInfo::ConstraintInfo &info) const;
Dale Johannesen7d3dfc02010-10-29 23:12:32 +0000988 virtual const llvm::Type* adjustInlineAsmType(std::string& Constraint,
989 const llvm::Type* Ty,
990 llvm::LLVMContext& Context) const;
Eli Friedman3fd920a2008-08-20 02:34:37 +0000991 virtual std::string convertConstraint(const char Constraint) const;
Anders Carlssonf511f642007-11-27 04:11:28 +0000992 virtual const char *getClobbers() const {
Eli Friedman3fd920a2008-08-20 02:34:37 +0000993 return "~{dirflag},~{fpsr},~{flags}";
994 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000995 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000996 MacroBuilder &Builder) const;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +0000997 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
998 const std::string &Name,
999 bool Enabled) const;
Mike Stump11289f42009-09-09 15:08:12 +00001000 virtual void getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001001 llvm::StringMap<bool> &Features) const;
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001002 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Chris Lattner5ba61f02006-10-14 07:39:34 +00001003};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001004
Mike Stump11289f42009-09-09 15:08:12 +00001005void X86TargetInfo::getDefaultFeatures(const std::string &CPU,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001006 llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001007 // FIXME: This should not be here.
1008 Features["3dnow"] = false;
1009 Features["3dnowa"] = false;
1010 Features["mmx"] = false;
1011 Features["sse"] = false;
1012 Features["sse2"] = false;
1013 Features["sse3"] = false;
1014 Features["ssse3"] = false;
1015 Features["sse41"] = false;
1016 Features["sse42"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001017 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001018 Features["avx"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001019
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001020 // LLVM does not currently recognize this.
1021 // Features["sse4a"] = false;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001022
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001023 // FIXME: This *really* should not be here.
1024
1025 // X86_64 always has SSE2.
1026 if (PointerWidth == 64)
1027 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1028
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001029 if (CPU == "generic" || CPU == "i386" || CPU == "i486" || CPU == "i586" ||
1030 CPU == "pentium" || CPU == "i686" || CPU == "pentiumpro")
1031 ;
1032 else if (CPU == "pentium-mmx" || CPU == "pentium2")
1033 setFeatureEnabled(Features, "mmx", true);
1034 else if (CPU == "pentium3")
1035 setFeatureEnabled(Features, "sse", true);
1036 else if (CPU == "pentium-m" || CPU == "pentium4" || CPU == "x86-64")
1037 setFeatureEnabled(Features, "sse2", true);
1038 else if (CPU == "yonah" || CPU == "prescott" || CPU == "nocona")
1039 setFeatureEnabled(Features, "sse3", true);
1040 else if (CPU == "core2")
1041 setFeatureEnabled(Features, "ssse3", true);
1042 else if (CPU == "penryn") {
1043 setFeatureEnabled(Features, "sse4", true);
1044 Features["sse42"] = false;
1045 } else if (CPU == "atom")
1046 setFeatureEnabled(Features, "sse3", true);
Eric Christophere1ddaf92010-04-02 23:50:19 +00001047 else if (CPU == "corei7") {
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001048 setFeatureEnabled(Features, "sse4", true);
Eric Christophere1ddaf92010-04-02 23:50:19 +00001049 setFeatureEnabled(Features, "aes", true);
1050 }
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001051 else if (CPU == "k6" || CPU == "winchip-c6")
1052 setFeatureEnabled(Features, "mmx", true);
Mike Stump11289f42009-09-09 15:08:12 +00001053 else if (CPU == "k6-2" || CPU == "k6-3" || CPU == "athlon" ||
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001054 CPU == "athlon-tbird" || CPU == "winchip2" || CPU == "c3") {
1055 setFeatureEnabled(Features, "mmx", true);
1056 setFeatureEnabled(Features, "3dnow", true);
1057 } else if (CPU == "athlon-4" || CPU == "athlon-xp" || CPU == "athlon-mp") {
1058 setFeatureEnabled(Features, "sse", true);
1059 setFeatureEnabled(Features, "3dnowa", true);
1060 } else if (CPU == "k8" || CPU == "opteron" || CPU == "athlon64" ||
1061 CPU == "athlon-fx") {
Mike Stump11289f42009-09-09 15:08:12 +00001062 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbarf9d90272009-05-06 21:56:32 +00001063 setFeatureEnabled(Features, "3dnowa", true);
1064 } else if (CPU == "c3-2")
1065 setFeatureEnabled(Features, "sse", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001066}
1067
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001068bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Mike Stump11289f42009-09-09 15:08:12 +00001069 const std::string &Name,
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001070 bool Enabled) const {
Eric Christopher399ffa52010-03-04 02:26:37 +00001071 // FIXME: This *really* should not be here. We need some way of translating
1072 // options into llvm subtarget features.
1073 if (!Features.count(Name) &&
1074 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001075 return false;
1076
1077 if (Enabled) {
1078 if (Name == "mmx")
1079 Features["mmx"] = true;
1080 else if (Name == "sse")
1081 Features["mmx"] = Features["sse"] = true;
1082 else if (Name == "sse2")
1083 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
1084 else if (Name == "sse3")
Mike Stump11289f42009-09-09 15:08:12 +00001085 Features["mmx"] = Features["sse"] = Features["sse2"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001086 Features["sse3"] = true;
1087 else if (Name == "ssse3")
Mike Stump11289f42009-09-09 15:08:12 +00001088 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001089 Features["ssse3"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001090 else if (Name == "sse4" || Name == "sse4.2")
Mike Stump11289f42009-09-09 15:08:12 +00001091 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001092 Features["ssse3"] = Features["sse41"] = Features["sse42"] = true;
Eric Christopher399ffa52010-03-04 02:26:37 +00001093 else if (Name == "sse4.1")
1094 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1095 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001096 else if (Name == "3dnow")
1097 Features["3dnowa"] = true;
1098 else if (Name == "3dnowa")
1099 Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001100 else if (Name == "aes")
1101 Features["aes"] = true;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001102 else if (Name == "avx")
1103 Features["avx"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001104 } else {
1105 if (Name == "mmx")
Mike Stump11289f42009-09-09 15:08:12 +00001106 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001107 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1108 else if (Name == "sse")
Mike Stump11289f42009-09-09 15:08:12 +00001109 Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001110 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1111 else if (Name == "sse2")
Mike Stump11289f42009-09-09 15:08:12 +00001112 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001113 Features["sse41"] = Features["sse42"] = false;
1114 else if (Name == "sse3")
Mike Stump11289f42009-09-09 15:08:12 +00001115 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001116 Features["sse42"] = false;
1117 else if (Name == "ssse3")
1118 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
1119 else if (Name == "sse4")
1120 Features["sse41"] = Features["sse42"] = false;
Eric Christophercfeceff2010-03-04 02:31:44 +00001121 else if (Name == "sse4.2")
1122 Features["sse42"] = false;
1123 else if (Name == "sse4.1")
1124 Features["sse41"] = Features["sse42"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001125 else if (Name == "3dnow")
1126 Features["3dnow"] = Features["3dnowa"] = false;
1127 else if (Name == "3dnowa")
1128 Features["3dnowa"] = false;
Eric Christophere1ddaf92010-04-02 23:50:19 +00001129 else if (Name == "aes")
1130 Features["aes"] = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001131 else if (Name == "avx")
1132 Features["avx"] = false;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00001133 }
1134
1135 return true;
1136}
1137
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00001138/// HandleTargetOptions - Perform initialization based on the user
1139/// configured set of features.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00001140void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00001141 // Remember the maximum enabled sselevel.
1142 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1143 // Ignore disabled features.
1144 if (Features[i][0] == '-')
1145 continue;
1146
Eric Christophere1ddaf92010-04-02 23:50:19 +00001147 if (Features[i].substr(1) == "aes") {
1148 HasAES = true;
1149 continue;
1150 }
1151
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001152 // FIXME: Not sure yet how to treat AVX in regard to SSE levels.
1153 // For now let it be enabled together with other SSE levels.
1154 if (Features[i].substr(1) == "avx") {
1155 HasAVX = true;
1156 continue;
1157 }
1158
Daniel Dunbar979586e2009-11-11 09:38:56 +00001159 assert(Features[i][0] == '+' && "Invalid target feature!");
1160 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Features[i].substr(1))
1161 .Case("sse42", SSE42)
1162 .Case("sse41", SSE41)
1163 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00001164 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00001165 .Case("sse2", SSE2)
1166 .Case("sse", SSE1)
1167 .Case("mmx", MMX)
1168 .Default(NoMMXSSE);
1169 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001170
1171 AMD3DNowEnum ThreeDNowLevel =
Anders Carlssone437c682010-01-27 03:47:49 +00001172 llvm::StringSwitch<AMD3DNowEnum>(Features[i].substr(1))
1173 .Case("3dnowa", AMD3DNowAthlon)
1174 .Case("3dnow", AMD3DNow)
1175 .Default(NoAMD3DNow);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001176
Anders Carlssone437c682010-01-27 03:47:49 +00001177 AMD3DNowLevel = std::max(AMD3DNowLevel, ThreeDNowLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00001178 }
Chris Lattnerc25d8a72009-03-02 22:20:04 +00001179}
Chris Lattnerecd49032009-03-02 22:27:17 +00001180
1181/// X86TargetInfo::getTargetDefines - Return a set of the X86-specific #defines
1182/// that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001183void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001184 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001185 // Target identification.
1186 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001187 Builder.defineMacro("_LP64");
1188 Builder.defineMacro("__LP64__");
1189 Builder.defineMacro("__amd64__");
1190 Builder.defineMacro("__amd64");
1191 Builder.defineMacro("__x86_64");
1192 Builder.defineMacro("__x86_64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001193 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001194 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00001195 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001196
Eric Christophere1ddaf92010-04-02 23:50:19 +00001197 if (HasAES)
1198 Builder.defineMacro("__AES__");
1199
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001200 if (HasAVX)
1201 Builder.defineMacro("__AVX__");
1202
Chris Lattnerecd49032009-03-02 22:27:17 +00001203 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001204 Builder.defineMacro("__LITTLE_ENDIAN__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001205
Chris Lattnerecd49032009-03-02 22:27:17 +00001206 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001207 Builder.defineMacro("__nocona");
1208 Builder.defineMacro("__nocona__");
1209 Builder.defineMacro("__tune_nocona__");
1210 Builder.defineMacro("__REGISTER_PREFIX__", "");
Chris Lattner96e43572009-03-02 22:40:39 +00001211
Chris Lattner6df41af2009-04-19 17:32:33 +00001212 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
1213 // functions in glibc header files that use FP Stack inline asm which the
1214 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001215 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001216
Chris Lattner96e43572009-03-02 22:40:39 +00001217 // Each case falls through to the previous one here.
1218 switch (SSELevel) {
1219 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001220 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00001221 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001222 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00001223 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001224 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001225 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001226 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00001227 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001228 Builder.defineMacro("__SSE2__");
1229 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00001230 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001231 Builder.defineMacro("__SSE__");
1232 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00001233 case MMX:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001234 Builder.defineMacro("__MMX__");
Chris Lattner96e43572009-03-02 22:40:39 +00001235 case NoMMXSSE:
1236 break;
1237 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001238
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001239 if (Opts.Microsoft && PointerWidth == 32) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001240 switch (SSELevel) {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001241 case SSE42:
1242 case SSE41:
1243 case SSSE3:
1244 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001245 case SSE2:
1246 Builder.defineMacro("_M_IX86_FP", llvm::Twine(2));
1247 break;
1248 case SSE1:
1249 Builder.defineMacro("_M_IX86_FP", llvm::Twine(1));
1250 break;
1251 default:
1252 Builder.defineMacro("_M_IX86_FP", llvm::Twine(0));
1253 }
1254 }
1255
Anders Carlssone437c682010-01-27 03:47:49 +00001256 // Each case falls through to the previous one here.
1257 switch (AMD3DNowLevel) {
1258 case AMD3DNowAthlon:
1259 Builder.defineMacro("__3dNOW_A__");
1260 case AMD3DNow:
1261 Builder.defineMacro("__3dNOW__");
1262 case NoAMD3DNow:
1263 break;
1264 }
Chris Lattnerecd49032009-03-02 22:27:17 +00001265}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001266
1267
Eli Friedman3fd920a2008-08-20 02:34:37 +00001268bool
Anders Carlsson58436352009-02-28 17:11:49 +00001269X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00001270 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00001271 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001272 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00001273 case 'Y': // first letter of a pair:
1274 switch (*(Name+1)) {
1275 default: return false;
1276 case '0': // First SSE register.
1277 case 't': // Any SSE register, when SSE2 is enabled.
1278 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
1279 case 'm': // any MMX register, when inter-unit moves enabled.
1280 break; // falls through to setAllowsRegister.
1281 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001282 case 'a': // eax.
1283 case 'b': // ebx.
1284 case 'c': // ecx.
1285 case 'd': // edx.
1286 case 'S': // esi.
1287 case 'D': // edi.
1288 case 'A': // edx:eax.
Dale Johannesen46742a42010-08-24 22:33:12 +00001289 case 'f': // any x87 floating point stack register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001290 case 't': // top of floating point stack.
1291 case 'u': // second from top of floating point stack.
1292 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00001293 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00001294 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001295 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00001296 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
1297 case 'l': // "Index" registers: any general register that can be used as an
1298 // index in a base+index memory access.
1299 Info.setAllowsRegister();
1300 return true;
1301 case 'C': // SSE floating point constant.
1302 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001303 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001304 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001305 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00001306 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00001307 return true;
1308 }
Dale Johannesen46742a42010-08-24 22:33:12 +00001309 return false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001310}
1311
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00001312const llvm::Type*
1313X86TargetInfo::adjustInlineAsmType(std::string& Constraint,
1314 const llvm::Type* Ty,
1315 llvm::LLVMContext &Context) const {
1316 if (Constraint=="y" && Ty->isVectorTy())
1317 return llvm::Type::getX86_MMXTy(Context);
1318 return Ty;
1319}
1320
1321
Eli Friedman3fd920a2008-08-20 02:34:37 +00001322std::string
1323X86TargetInfo::convertConstraint(const char Constraint) const {
1324 switch (Constraint) {
1325 case 'a': return std::string("{ax}");
1326 case 'b': return std::string("{bx}");
1327 case 'c': return std::string("{cx}");
1328 case 'd': return std::string("{dx}");
1329 case 'S': return std::string("{si}");
1330 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00001331 case 'p': // address
1332 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00001333 case 't': // top of floating point stack.
1334 return std::string("{st}");
1335 case 'u': // second from top of floating point stack.
1336 return std::string("{st(1)}"); // second from top of floating point stack.
1337 default:
1338 return std::string(1, Constraint);
1339 }
1340}
Eli Friedman3fd920a2008-08-20 02:34:37 +00001341} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00001342
1343namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001344// X86-32 generic target
1345class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001346public:
Eli Friedman3fd920a2008-08-20 02:34:37 +00001347 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
1348 DoubleAlign = LongLongAlign = 32;
1349 LongDoubleWidth = 96;
1350 LongDoubleAlign = 32;
Eli Friedman873f65a2008-08-21 00:13:15 +00001351 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1352 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001353 "a0:0:64-f80:32:32-n8:16:32";
Eli Friedman32ca82a2009-03-29 20:31:09 +00001354 SizeType = UnsignedInt;
1355 PtrDiffType = SignedInt;
1356 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00001357 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001358
1359 // Use fpret for all types.
1360 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
1361 (1 << TargetInfo::Double) |
1362 (1 << TargetInfo::LongDouble));
Eli Friedman3fd920a2008-08-20 02:34:37 +00001363 }
1364 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001365 return "typedef char* __builtin_va_list;";
Eli Friedman3fd920a2008-08-20 02:34:37 +00001366 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001367
Chris Lattnerd545ad12009-09-23 06:06:36 +00001368 int getEHDataRegisterNumber(unsigned RegNo) const {
1369 if (RegNo == 0) return 0;
1370 if (RegNo == 1) return 2;
1371 return -1;
1372 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001373};
1374} // end anonymous namespace
1375
1376namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00001377class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
1378public:
1379 OpenBSDI386TargetInfo(const std::string& triple) :
1380 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
1381 SizeType = UnsignedLong;
1382 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00001383 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00001384 }
1385};
1386} // end anonymous namespace
1387
1388namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00001389class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001390public:
Torok Edwinb2b37c62009-06-30 17:10:35 +00001391 DarwinI386TargetInfo(const std::string& triple) :
1392 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001393 LongDoubleWidth = 128;
1394 LongDoubleAlign = 128;
Eli Friedman32ca82a2009-03-29 20:31:09 +00001395 SizeType = UnsignedLong;
1396 IntPtrType = SignedLong;
Eli Friedman873f65a2008-08-21 00:13:15 +00001397 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1398 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001399 "a0:0:64-f80:128:128-n8:16:32";
Daniel Dunbarbd606522010-05-27 00:35:16 +00001400 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00001401 }
1402
Eli Friedman3fd920a2008-08-20 02:34:37 +00001403};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00001404} // end anonymous namespace
1405
1406namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001407// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001408class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001409public:
1410 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001411 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmand88c8a12009-04-19 21:38:35 +00001412 TLSSupported = false;
Chris Lattner46be2e12009-06-24 17:12:15 +00001413 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00001414 DoubleAlign = LongLongAlign = 64;
1415 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikovd7e4a092009-12-19 02:05:07 +00001416 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
1417 "v128:128:128-a0:0:64-f80:32:32-n8:16:32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001418 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001419 virtual void getTargetDefines(const LangOptions &Opts,
1420 MacroBuilder &Builder) const {
1421 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
1422 }
1423};
1424} // end anonymous namespace
1425
1426namespace {
1427
1428// x86-32 Windows Visual Studio target
1429class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
1430public:
1431 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
1432 : WindowsX86_32TargetInfo(triple) {
1433 LongDoubleWidth = 64;
1434 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
1435 }
1436 virtual void getTargetDefines(const LangOptions &Opts,
1437 MacroBuilder &Builder) const {
1438 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
1439 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
1440 // The value of the following reflects processor type.
1441 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
1442 // We lost the original triple, so we use the default.
1443 Builder.defineMacro("_M_IX86", "600");
1444 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001445};
1446} // end anonymous namespace
1447
1448namespace {
1449// x86-32 MinGW target
1450class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
1451public:
1452 MinGWX86_32TargetInfo(const std::string& triple)
1453 : WindowsX86_32TargetInfo(triple) {
1454 }
1455 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001456 MacroBuilder &Builder) const {
1457 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001458 DefineStd(Builder, "WIN32", Opts);
1459 DefineStd(Builder, "WINNT", Opts);
1460 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001461 Builder.defineMacro("__MSVCRT__");
1462 Builder.defineMacro("__MINGW32__");
1463 Builder.defineMacro("__declspec", "__declspec");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001464 }
1465};
1466} // end anonymous namespace
1467
1468namespace {
1469// x86-32 Cygwin target
1470class CygwinX86_32TargetInfo : public X86_32TargetInfo {
1471public:
1472 CygwinX86_32TargetInfo(const std::string& triple)
1473 : X86_32TargetInfo(triple) {
1474 TLSSupported = false;
1475 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001476 DoubleAlign = LongLongAlign = 64;
1477 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1478 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001479 "a0:0:64-f80:32:32-n8:16:32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001480 }
1481 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001482 MacroBuilder &Builder) const {
1483 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1484 Builder.defineMacro("__CYGWIN__");
1485 Builder.defineMacro("__CYGWIN32__");
1486 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00001487 if (Opts.CPlusPlus)
1488 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00001489 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00001490};
1491} // end anonymous namespace
1492
1493namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00001494// x86-32 Haiku target
1495class HaikuX86_32TargetInfo : public X86_32TargetInfo {
1496public:
1497 HaikuX86_32TargetInfo(const std::string& triple)
1498 : X86_32TargetInfo(triple) {
1499 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00001500 IntPtrType = SignedLong;
1501 PtrDiffType = SignedLong;
Eli Friedman04831922010-08-22 01:00:03 +00001502 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00001503 virtual void getTargetDefines(const LangOptions &Opts,
1504 MacroBuilder &Builder) const {
1505 X86_32TargetInfo::getTargetDefines(Opts, Builder);
1506 Builder.defineMacro("__INTEL__");
1507 Builder.defineMacro("__HAIKU__");
1508 }
1509};
1510} // end anonymous namespace
1511
1512namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001513// x86-64 generic target
1514class X86_64TargetInfo : public X86TargetInfo {
1515public:
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001516 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001517 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00001518 LongDoubleWidth = 128;
1519 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00001520 LargeArrayMinWidth = 128;
1521 LargeArrayAlign = 128;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00001522 IntMaxType = SignedLong;
1523 UIntMaxType = UnsignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001524 Int64Type = SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00001525 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00001526
Eli Friedman873f65a2008-08-21 00:13:15 +00001527 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1528 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001529 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00001530
1531 // Use fpret only for long double.
1532 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Chris Lattner10a5b382007-01-29 05:24:35 +00001533 }
Anders Carlssona7408e72007-10-13 00:45:48 +00001534 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001535 return "typedef struct __va_list_tag {"
1536 " unsigned gp_offset;"
1537 " unsigned fp_offset;"
1538 " void* overflow_arg_area;"
1539 " void* reg_save_area;"
John McCall61d82582010-05-28 18:25:28 +00001540 "} __va_list_tag;"
Eli Friedmanfb36b022009-07-03 00:45:06 +00001541 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001542 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001543
Chris Lattnerd545ad12009-09-23 06:06:36 +00001544 int getEHDataRegisterNumber(unsigned RegNo) const {
1545 if (RegNo == 0) return 0;
1546 if (RegNo == 1) return 1;
1547 return -1;
1548 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00001549};
1550} // end anonymous namespace
1551
1552namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001553// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001554class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001555public:
1556 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001557 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001558 TLSSupported = false;
1559 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00001560 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00001561 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00001562 IntMaxType = SignedLongLong;
1563 UIntMaxType = UnsignedLongLong;
1564 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00001565 SizeType = UnsignedLongLong;
1566 PtrDiffType = SignedLongLong;
1567 IntPtrType = SignedLongLong;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001568 }
1569 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001570 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001571 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001572 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001573 }
1574};
1575} // end anonymous namespace
1576
1577namespace {
1578// x86-64 Windows Visual Studio target
1579class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
1580public:
1581 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
1582 : WindowsX86_64TargetInfo(triple) {
1583 }
1584 virtual void getTargetDefines(const LangOptions &Opts,
1585 MacroBuilder &Builder) const {
1586 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
1587 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001588 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00001589 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001590 }
Chris Lattner04dc9572010-08-31 16:44:54 +00001591 virtual const char *getVAListDeclaration() const {
1592 return "typedef char* __builtin_va_list;";
1593 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001594};
1595} // end anonymous namespace
1596
1597namespace {
1598// x86-64 MinGW target
1599class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
1600public:
1601 MinGWX86_64TargetInfo(const std::string& triple)
1602 : WindowsX86_64TargetInfo(triple) {
1603 }
1604 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001605 MacroBuilder &Builder) const {
1606 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00001607 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001608 Builder.defineMacro("__MSVCRT__");
1609 Builder.defineMacro("__MINGW64__");
1610 Builder.defineMacro("__declspec");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00001611 }
1612};
1613} // end anonymous namespace
1614
1615namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00001616class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
1617public:
Mike Stump11289f42009-09-09 15:08:12 +00001618 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman2857ccb2009-07-01 03:36:11 +00001619 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
1620 Int64Type = SignedLongLong;
1621 }
1622};
1623} // end anonymous namespace
1624
1625namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00001626class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
1627public:
Mike Stump11289f42009-09-09 15:08:12 +00001628 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman245f2292009-07-05 22:31:18 +00001629 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
1630 IntMaxType = SignedLongLong;
1631 UIntMaxType = UnsignedLongLong;
1632 Int64Type = SignedLongLong;
1633 }
1634};
1635} // end anonymous namespace
1636
1637namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001638class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001639 // Possible FPU choices.
1640 enum FPUMode {
1641 NoFPU,
1642 VFP2FPU,
1643 VFP3FPU,
1644 NeonFPU
1645 };
1646
1647 static bool FPUModeIsVFP(FPUMode Mode) {
1648 return Mode >= VFP2FPU && Mode <= NeonFPU;
1649 }
1650
1651 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1652 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001653
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001654 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001655
1656 unsigned FPU : 3;
1657
Daniel Dunbar893d4752009-12-19 04:15:38 +00001658 unsigned IsThumb : 1;
1659
1660 // Initialized via features.
1661 unsigned SoftFloat : 1;
1662 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001663
Chris Lattner5cc15e02010-03-03 19:03:45 +00001664 static const Builtin::Info BuiltinInfo[];
1665
Chris Lattner17df24e2008-04-21 18:56:49 +00001666public:
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001667 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001668 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001669 {
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001670 SizeType = UnsignedInt;
1671 PtrDiffType = SignedInt;
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001672
Chris Lattner1a8f3942010-04-23 16:29:58 +00001673 // {} in inline assembly are neon specifiers, not assembly variant
1674 // specifiers.
1675 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001676
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001677 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00001678 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbar03184792009-09-22 21:44:58 +00001679 if (IsThumb) {
1680 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1681 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001682 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001683 } else {
1684 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1685 "i64:64:64-f32:32:32-f64:64:64-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001686 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001687 }
John McCall86353412010-08-21 22:46:04 +00001688
1689 // ARM targets default to using the ARM C++ ABI.
1690 CXXABI = CXXABI_ARM;
Eli Friedmanb5366062008-05-20 14:21:01 +00001691 }
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001692 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001693 virtual bool setABI(const std::string &Name) {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00001694 ABI = Name;
1695
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001696 // The defaults (above) are for AAPCS, check if we need to change them.
1697 //
1698 // FIXME: We need support for -meabi... we could just mangle it into the
1699 // name.
1700 if (Name == "apcs-gnu") {
Daniel Dunbar377dc2f2010-01-27 20:23:08 +00001701 DoubleAlign = LongLongAlign = LongDoubleAlign = 32;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001702 SizeType = UnsignedLong;
1703
Daniel Dunbarf8125062010-04-22 16:14:54 +00001704 // Do not respect the alignment of bit-field types when laying out
1705 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
1706 UseBitFieldTypeAlignment = false;
1707
Daniel Dunbar03184792009-09-22 21:44:58 +00001708 if (IsThumb) {
1709 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
1710 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001711 "v64:64:64-v128:128:128-a0:0:32-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001712 } else {
1713 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1714 "i64:32:32-f32:32:32-f64:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001715 "v64:64:64-v128:128:128-a0:0:64-n32");
Daniel Dunbar03184792009-09-22 21:44:58 +00001716 }
1717
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00001718 // FIXME: Override "preferred align" for double and long long.
1719 } else if (Name == "aapcs") {
1720 // FIXME: Enumerated types are variable width in straight AAPCS.
1721 } else if (Name == "aapcs-linux") {
1722 ;
1723 } else
1724 return false;
1725
1726 return true;
1727 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00001728
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001729 void getDefaultFeatures(const std::string &CPU,
1730 llvm::StringMap<bool> &Features) const {
1731 // FIXME: This should not be here.
1732 Features["vfp2"] = false;
1733 Features["vfp3"] = false;
1734 Features["neon"] = false;
1735
1736 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
1737 Features["vfp2"] = true;
1738 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
1739 Features["neon"] = true;
1740 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001741
Daniel Dunbar893d4752009-12-19 04:15:38 +00001742 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1743 const std::string &Name,
1744 bool Enabled) const {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001745 if (Name == "soft-float" || Name == "soft-float-abi") {
1746 Features[Name] = Enabled;
1747 } else if (Name == "vfp2" || Name == "vfp3" || Name == "neon") {
1748 // These effectively are a single option, reset them when any is enabled.
1749 if (Enabled)
1750 Features["vfp2"] = Features["vfp3"] = Features["neon"] = false;
1751 Features[Name] = Enabled;
1752 } else
Daniel Dunbar893d4752009-12-19 04:15:38 +00001753 return false;
1754
Daniel Dunbar893d4752009-12-19 04:15:38 +00001755 return true;
1756 }
1757
1758 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001759 FPU = NoFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00001760 SoftFloat = SoftFloatABI = false;
1761 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
1762 if (Features[i] == "+soft-float")
1763 SoftFloat = true;
1764 else if (Features[i] == "+soft-float-abi")
1765 SoftFloatABI = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001766 else if (Features[i] == "+vfp2")
1767 FPU = VFP2FPU;
1768 else if (Features[i] == "+vfp3")
1769 FPU = VFP3FPU;
1770 else if (Features[i] == "+neon")
1771 FPU = NeonFPU;
Daniel Dunbar893d4752009-12-19 04:15:38 +00001772 }
1773
1774 // Remove front-end specific options which the backend handles differently.
1775 std::vector<std::string>::iterator it;
1776 it = std::find(Features.begin(), Features.end(), "+soft-float");
1777 if (it != Features.end())
1778 Features.erase(it);
1779 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
1780 if (it != Features.end())
1781 Features.erase(it);
1782 }
1783
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001784 static const char *getCPUDefineSuffix(llvm::StringRef Name) {
1785 return llvm::StringSwitch<const char*>(Name)
1786 .Cases("arm8", "arm810", "4")
1787 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
1788 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
1789 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
1790 .Case("ep9312", "4T")
1791 .Cases("arm10tdmi", "arm1020t", "5T")
1792 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
1793 .Case("arm926ej-s", "5TEJ")
1794 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
1795 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001796 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001797 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001798 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001799 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
1800 .Cases("cortex-a8", "cortex-a9", "7A")
1801 .Default(0);
1802 }
1803 virtual bool setCPU(const std::string &Name) {
1804 if (!getCPUDefineSuffix(Name))
1805 return false;
1806
1807 CPU = Name;
1808 return true;
1809 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001810 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001811 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001812 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001813 Builder.defineMacro("__arm");
1814 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001815
Chris Lattnerecd49032009-03-02 22:27:17 +00001816 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001817 Builder.defineMacro("__ARMEL__");
1818 Builder.defineMacro("__LITTLE_ENDIAN__");
1819 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001820
1821 llvm::StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001822 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001823
Mike Stump9d54bd72009-04-08 02:07:04 +00001824 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001825
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001826 // FIXME: It's more complicated than this and we don't really support
1827 // interworking.
1828 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001829 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001830
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001831 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001832 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001833
Daniel Dunbar893d4752009-12-19 04:15:38 +00001834 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001835 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00001836
1837 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001838 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001839
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001840 bool IsThumb2 = IsThumb && (CPUArch == "6T2" || CPUArch.startswith("7"));
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001841 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001842 Builder.defineMacro("__THUMBEL__");
1843 Builder.defineMacro("__thumb__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001844 if (IsThumb2)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001845 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00001846 }
1847
1848 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001849 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001850
1851 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001852 Builder.defineMacro("__VFP_FP__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00001853
1854 // This only gets set when Neon instructions are actually available, unlike
1855 // the VFP define, hence the soft float and arch check. This is subtly
1856 // different from gcc, we follow the intent which was that it should be set
1857 // when Neon instructions are actually available.
1858 if (FPU == NeonFPU && !SoftFloat && IsThumb2)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001859 Builder.defineMacro("__ARM_NEON__");
Chris Lattner17df24e2008-04-21 18:56:49 +00001860 }
1861 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1862 unsigned &NumRecords) const {
Chris Lattner5cc15e02010-03-03 19:03:45 +00001863 Records = BuiltinInfo;
1864 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00001865 }
1866 virtual const char *getVAListDeclaration() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001867 return "typedef char* __builtin_va_list;";
Chris Lattner17df24e2008-04-21 18:56:49 +00001868 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001869 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001870 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001871 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001872 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00001873 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00001874 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001875 // FIXME: Check if this is complete
Anders Carlsson58436352009-02-28 17:11:49 +00001876 switch (*Name) {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001877 default:
Nate Begeman2908fa02008-04-22 05:03:19 +00001878 case 'l': // r0-r7
1879 case 'h': // r8-r15
1880 case 'w': // VFP Floating point register single precision
1881 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00001882 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00001883 return true;
1884 }
Chris Lattner17df24e2008-04-21 18:56:49 +00001885 return false;
1886 }
1887 virtual const char *getClobbers() const {
Eli Friedmanf05b7722008-08-20 07:44:10 +00001888 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00001889 return "";
1890 }
1891};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001892
1893const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00001894 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001895 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00001896 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
1897
1898 // Float registers
1899 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
1900 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
1901 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00001902 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00001903
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00001904 // Double registers
1905 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
1906 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00001907 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
1908 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00001909
1910 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00001911 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
1912 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001913};
1914
1915void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00001916 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001917 Names = GCCRegNames;
1918 NumNames = llvm::array_lengthof(GCCRegNames);
1919}
1920
1921const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001922 { { "a1" }, "r0" },
1923 { { "a2" }, "r1" },
1924 { { "a3" }, "r2" },
1925 { { "a4" }, "r3" },
1926 { { "v1" }, "r4" },
1927 { { "v2" }, "r5" },
1928 { { "v3" }, "r6" },
1929 { { "v4" }, "r7" },
1930 { { "v5" }, "r8" },
1931 { { "v6", "rfp" }, "r9" },
1932 { { "sl" }, "r10" },
1933 { { "fp" }, "r11" },
1934 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00001935 { { "r13" }, "sp" },
1936 { { "r14" }, "lr" },
1937 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00001938 // The S, D and Q registers overlap, but aren't really aliases; we
1939 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001940};
1941
1942void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1943 unsigned &NumAliases) const {
1944 Aliases = GCCRegAliases;
1945 NumAliases = llvm::array_lengthof(GCCRegAliases);
1946}
Chris Lattner5cc15e02010-03-03 19:03:45 +00001947
1948const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
1949#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, false },
1950#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER, false },
1951#include "clang/Basic/BuiltinsARM.def"
1952};
Chris Lattner17df24e2008-04-21 18:56:49 +00001953} // end anonymous namespace.
1954
Eli Friedmanf05b7722008-08-20 07:44:10 +00001955
1956namespace {
Mike Stump11289f42009-09-09 15:08:12 +00001957class DarwinARMTargetInfo :
Torok Edwinb2b37c62009-06-30 17:10:35 +00001958 public DarwinTargetInfo<ARMTargetInfo> {
1959protected:
Daniel Dunbar40165182009-08-24 09:10:05 +00001960 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001961 MacroBuilder &Builder) const {
Daniel Dunbard86666f2010-01-26 01:44:04 +00001962 getDarwinDefines(Builder, Opts, Triple);
Eli Friedmand88c8a12009-04-19 21:38:35 +00001963 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00001964
Torok Edwinb2b37c62009-06-30 17:10:35 +00001965public:
Mike Stump11289f42009-09-09 15:08:12 +00001966 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00001967 : DarwinTargetInfo<ARMTargetInfo>(triple) {
1968 HasAlignMac68kSupport = true;
1969 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00001970};
1971} // end anonymous namespace.
1972
Chris Lattner5ba61f02006-10-14 07:39:34 +00001973namespace {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001974class SparcV8TargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00001975 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1976 static const char * const GCCRegNames[];
Gabor Greif49991682008-02-21 16:29:08 +00001977public:
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001978 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
1979 // FIXME: Support Sparc quad-precision long double?
Eli Friedman873f65a2008-08-21 00:13:15 +00001980 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner5c67237f2009-11-07 18:59:41 +00001981 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001982 }
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001983 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001984 MacroBuilder &Builder) const {
1985 DefineStd(Builder, "sparc", Opts);
1986 Builder.defineMacro("__sparcv8");
1987 Builder.defineMacro("__REGISTER_PREFIX__", "");
Gabor Greif49991682008-02-21 16:29:08 +00001988 }
1989 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1990 unsigned &NumRecords) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001991 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00001992 }
1993 virtual const char *getVAListDeclaration() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00001994 return "typedef void* __builtin_va_list;";
Gabor Greif49991682008-02-21 16:29:08 +00001995 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001996 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00001997 unsigned &NumNames) const;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001998 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00001999 unsigned &NumAliases) const;
Anders Carlsson58436352009-02-28 17:11:49 +00002000 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif49991682008-02-21 16:29:08 +00002001 TargetInfo::ConstraintInfo &info) const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002002 // FIXME: Implement!
2003 return false;
Gabor Greif49991682008-02-21 16:29:08 +00002004 }
2005 virtual const char *getClobbers() const {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002006 // FIXME: Implement!
2007 return "";
Gabor Greif49991682008-02-21 16:29:08 +00002008 }
2009};
2010
Chris Lattner9b415d62009-01-27 01:58:38 +00002011const char * const SparcV8TargetInfo::GCCRegNames[] = {
2012 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2013 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2014 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2015 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
2016};
2017
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002018void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattner9b415d62009-01-27 01:58:38 +00002019 unsigned &NumNames) const {
2020 Names = GCCRegNames;
2021 NumNames = llvm::array_lengthof(GCCRegNames);
2022}
2023
2024const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002025 { { "g0" }, "r0" },
2026 { { "g1" }, "r1" },
2027 { { "g2" }, "r2" },
2028 { { "g3" }, "r3" },
2029 { { "g4" }, "r4" },
2030 { { "g5" }, "r5" },
2031 { { "g6" }, "r6" },
2032 { { "g7" }, "r7" },
2033 { { "o0" }, "r8" },
2034 { { "o1" }, "r9" },
2035 { { "o2" }, "r10" },
2036 { { "o3" }, "r11" },
2037 { { "o4" }, "r12" },
2038 { { "o5" }, "r13" },
2039 { { "o6", "sp" }, "r14" },
2040 { { "o7" }, "r15" },
2041 { { "l0" }, "r16" },
2042 { { "l1" }, "r17" },
2043 { { "l2" }, "r18" },
2044 { { "l3" }, "r19" },
2045 { { "l4" }, "r20" },
2046 { { "l5" }, "r21" },
2047 { { "l6" }, "r22" },
2048 { { "l7" }, "r23" },
2049 { { "i0" }, "r24" },
2050 { { "i1" }, "r25" },
2051 { { "i2" }, "r26" },
2052 { { "i3" }, "r27" },
2053 { { "i4" }, "r28" },
2054 { { "i5" }, "r29" },
2055 { { "i6", "fp" }, "r30" },
2056 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00002057};
2058
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002059void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattner9b415d62009-01-27 01:58:38 +00002060 unsigned &NumAliases) const {
2061 Aliases = GCCRegAliases;
2062 NumAliases = llvm::array_lengthof(GCCRegAliases);
2063}
Gabor Greif49991682008-02-21 16:29:08 +00002064} // end anonymous namespace.
2065
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002066namespace {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002067class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
2068public:
2069 AuroraUXSparcV8TargetInfo(const std::string& triple) :
2070 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
2071 SizeType = UnsignedInt;
2072 PtrDiffType = SignedInt;
2073 }
2074};
Torok Edwinb2b37c62009-06-30 17:10:35 +00002075class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002076public:
2077 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwinb2b37c62009-06-30 17:10:35 +00002078 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00002079 SizeType = UnsignedInt;
2080 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00002081 }
2082};
2083} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00002084
Chris Lattnerb781dc792008-05-08 05:58:21 +00002085namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002086 class MSP430TargetInfo : public TargetInfo {
2087 static const char * const GCCRegNames[];
2088 public:
2089 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
2090 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00002091 IntWidth = 16; IntAlign = 16;
2092 LongWidth = 32; LongLongWidth = 64;
2093 LongAlign = LongLongAlign = 16;
2094 PointerWidth = 16; PointerAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002095 SizeType = UnsignedInt;
2096 IntMaxType = SignedLong;
2097 UIntMaxType = UnsignedLong;
2098 IntPtrType = SignedShort;
2099 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00002100 SigAtomicType = SignedLong;
Anton Korobeynikovd94329a2009-12-19 01:32:37 +00002101 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002102 }
2103 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002104 MacroBuilder &Builder) const {
2105 Builder.defineMacro("MSP430");
2106 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002107 // FIXME: defines for different 'flavours' of MCU
2108 }
2109 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2110 unsigned &NumRecords) const {
2111 // FIXME: Implement.
2112 Records = 0;
2113 NumRecords = 0;
2114 }
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002115 virtual void getGCCRegNames(const char * const *&Names,
2116 unsigned &NumNames) const;
2117 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2118 unsigned &NumAliases) const {
2119 // No aliases.
2120 Aliases = 0;
2121 NumAliases = 0;
2122 }
2123 virtual bool validateAsmConstraint(const char *&Name,
2124 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00002125 // No target constraints for now.
2126 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002127 }
2128 virtual const char *getClobbers() const {
2129 // FIXME: Is this really right?
2130 return "";
2131 }
2132 virtual const char *getVAListDeclaration() const {
2133 // FIXME: implement
Anton Korobeynikov2f910822009-05-08 18:24:57 +00002134 return "typedef char* __builtin_va_list;";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00002135 }
2136 };
2137
2138 const char * const MSP430TargetInfo::GCCRegNames[] = {
2139 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2140 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2141 };
2142
2143 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
2144 unsigned &NumNames) const {
2145 Names = GCCRegNames;
2146 NumNames = llvm::array_lengthof(GCCRegNames);
2147 }
2148}
2149
2150
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002151namespace {
2152 class SystemZTargetInfo : public TargetInfo {
2153 static const char * const GCCRegNames[];
2154 public:
2155 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
2156 TLSSupported = false;
2157 IntWidth = IntAlign = 32;
2158 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
2159 PointerWidth = PointerAlign = 64;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002160 DescriptionString = "E-p:64:64:64-i8:8:16-i16:16:16-i32:32:32-"
2161 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-a0:16:16-n32:64";
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002162 }
2163 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002164 MacroBuilder &Builder) const {
2165 Builder.defineMacro("__s390__");
2166 Builder.defineMacro("__s390x__");
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002167 }
2168 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2169 unsigned &NumRecords) const {
2170 // FIXME: Implement.
2171 Records = 0;
2172 NumRecords = 0;
2173 }
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002174
Anton Korobeynikovb5b703b2009-07-16 20:09:57 +00002175 virtual void getGCCRegNames(const char * const *&Names,
2176 unsigned &NumNames) const;
2177 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2178 unsigned &NumAliases) const {
2179 // No aliases.
2180 Aliases = 0;
2181 NumAliases = 0;
2182 }
2183 virtual bool validateAsmConstraint(const char *&Name,
2184 TargetInfo::ConstraintInfo &info) const {
2185 // FIXME: implement
2186 return true;
2187 }
2188 virtual const char *getClobbers() const {
2189 // FIXME: Is this really right?
2190 return "";
2191 }
2192 virtual const char *getVAListDeclaration() const {
2193 // FIXME: implement
2194 return "typedef char* __builtin_va_list;";
2195 }
2196 };
2197
2198 const char * const SystemZTargetInfo::GCCRegNames[] = {
2199 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2200 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2201 };
2202
2203 void SystemZTargetInfo::getGCCRegNames(const char * const *&Names,
2204 unsigned &NumNames) const {
2205 Names = GCCRegNames;
2206 NumNames = llvm::array_lengthof(GCCRegNames);
2207 }
2208}
2209
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002210namespace {
2211 class BlackfinTargetInfo : public TargetInfo {
2212 static const char * const GCCRegNames[];
2213 public:
2214 BlackfinTargetInfo(const std::string& triple) : TargetInfo(triple) {
2215 TLSSupported = false;
2216 DoubleAlign = 32;
2217 LongLongAlign = 32;
2218 LongDoubleAlign = 32;
Chris Lattner5c67237f2009-11-07 18:59:41 +00002219 DescriptionString = "e-p:32:32-i64:32-f64:32-n32";
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002220 }
2221
2222 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002223 MacroBuilder &Builder) const {
2224 DefineStd(Builder, "bfin", Opts);
2225 DefineStd(Builder, "BFIN", Opts);
2226 Builder.defineMacro("__ADSPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002227 // FIXME: This one is really dependent on -mcpu
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002228 Builder.defineMacro("__ADSPLPBLACKFIN__");
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002229 // FIXME: Add cpu-dependent defines and __SILICON_REVISION__
2230 }
2231
2232 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2233 unsigned &NumRecords) const {
2234 // FIXME: Implement.
2235 Records = 0;
2236 NumRecords = 0;
2237 }
2238
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002239 virtual void getGCCRegNames(const char * const *&Names,
2240 unsigned &NumNames) const;
2241
2242 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2243 unsigned &NumAliases) const {
2244 // No aliases.
2245 Aliases = 0;
2246 NumAliases = 0;
2247 }
2248
2249 virtual bool validateAsmConstraint(const char *&Name,
2250 TargetInfo::ConstraintInfo &Info) const {
2251 if (strchr("adzDWeABbvfcCtukxywZY", Name[0])) {
2252 Info.setAllowsRegister();
2253 return true;
2254 }
2255 return false;
2256 }
2257
2258 virtual const char *getClobbers() const {
2259 return "";
2260 }
2261
2262 virtual const char *getVAListDeclaration() const {
2263 return "typedef char* __builtin_va_list;";
2264 }
2265 };
2266
2267 const char * const BlackfinTargetInfo::GCCRegNames[] = {
2268 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2269 "p0", "p1", "p2", "p3", "p4", "p5", "sp", "fp",
2270 "i0", "i1", "i2", "i3", "b0", "b1", "b2", "b3",
2271 "l0", "l1", "l2", "l3", "m0", "m1", "m2", "m3",
2272 "a0", "a1", "cc",
2273 "rets", "reti", "retx", "retn", "rete", "astat", "seqstat", "usp",
2274 "argp", "lt0", "lt1", "lc0", "lc1", "lb0", "lb1"
2275 };
2276
2277 void BlackfinTargetInfo::getGCCRegNames(const char * const *&Names,
2278 unsigned &NumNames) const {
2279 Names = GCCRegNames;
2280 NumNames = llvm::array_lengthof(GCCRegNames);
2281 }
2282}
2283
Eli Friedmana9c3d712009-08-19 20:47:07 +00002284namespace {
2285
Mike Stump11289f42009-09-09 15:08:12 +00002286 // LLVM and Clang cannot be used directly to output native binaries for
2287 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00002288 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00002289 //
2290 // TCE uses the llvm bitcode as input and uses it for generating customized
2291 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00002292 // publicly available in http://tce.cs.tut.fi
2293
2294 class TCETargetInfo : public TargetInfo{
2295 public:
2296 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
2297 TLSSupported = false;
2298 IntWidth = 32;
2299 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00002300 PointerWidth = 32;
2301 IntAlign = 32;
2302 LongAlign = LongLongAlign = 32;
2303 PointerAlign = 32;
2304 SizeType = UnsignedInt;
2305 IntMaxType = SignedLong;
2306 UIntMaxType = UnsignedLong;
2307 IntPtrType = SignedInt;
2308 PtrDiffType = SignedInt;
2309 FloatWidth = 32;
2310 FloatAlign = 32;
2311 DoubleWidth = 32;
2312 DoubleAlign = 32;
2313 LongDoubleWidth = 32;
2314 LongDoubleAlign = 32;
2315 FloatFormat = &llvm::APFloat::IEEEsingle;
2316 DoubleFormat = &llvm::APFloat::IEEEsingle;
2317 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner09797542010-03-04 21:07:38 +00002318 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
2319 "i16:16:32-i32:32:32-i64:32:32-"
2320 "f32:32:32-f64:64:64-v64:64:64-"
2321 "v128:128:128-a0:0:64-n32";
Eli Friedmana9c3d712009-08-19 20:47:07 +00002322 }
2323
2324 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002325 MacroBuilder &Builder) const {
2326 DefineStd(Builder, "tce", Opts);
2327 Builder.defineMacro("__TCE__");
2328 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00002329 }
2330 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2331 unsigned &NumRecords) const {}
Daniel Dunbar576d90d2009-08-24 09:54:37 +00002332 virtual const char *getClobbers() const {
2333 return "";
2334 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00002335 virtual const char *getVAListDeclaration() const {
2336 return "typedef void* __builtin_va_list;";
2337 }
Eli Friedmana9c3d712009-08-19 20:47:07 +00002338 virtual void getGCCRegNames(const char * const *&Names,
2339 unsigned &NumNames) const {}
2340 virtual bool validateAsmConstraint(const char *&Name,
2341 TargetInfo::ConstraintInfo &info) const {
2342 return true;
2343 }
2344 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2345 unsigned &NumAliases) const {}
2346 };
2347}
2348
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002349namespace {
2350class MipsTargetInfo : public TargetInfo {
Eric Christopher0b26a612010-03-02 02:41:08 +00002351 std::string ABI, CPU;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002352 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2353 static const char * const GCCRegNames[];
2354public:
Eric Christopher0b26a612010-03-02 02:41:08 +00002355 MipsTargetInfo(const std::string& triple) : TargetInfo(triple), ABI("o32") {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002356 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2357 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2358 }
Eric Christopher0b26a612010-03-02 02:41:08 +00002359 virtual const char *getABI() const { return ABI.c_str(); }
2360 virtual bool setABI(const std::string &Name) {
2361
2362 if ((Name == "o32") || (Name == "eabi")) {
2363 ABI = Name;
2364 return true;
2365 } else
2366 return false;
2367 }
2368 virtual bool setCPU(const std::string &Name) {
2369 CPU = Name;
2370 return true;
2371 }
2372 void getDefaultFeatures(const std::string &CPU,
2373 llvm::StringMap<bool> &Features) const {
2374 Features[ABI] = true;
2375 Features[CPU] = true;
2376 }
2377 virtual void getArchDefines(const LangOptions &Opts,
2378 MacroBuilder &Builder) const {
2379 if (ABI == "o32")
2380 Builder.defineMacro("__mips_o32");
2381 else if (ABI == "eabi")
2382 Builder.defineMacro("__mips_eabi");
2383 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002384 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002385 MacroBuilder &Builder) const {
2386 DefineStd(Builder, "mips", Opts);
2387 Builder.defineMacro("_mips");
2388 DefineStd(Builder, "MIPSEB", Opts);
2389 Builder.defineMacro("_MIPSEB");
2390 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher0b26a612010-03-02 02:41:08 +00002391 getArchDefines(Opts, Builder);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002392 }
2393 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2394 unsigned &NumRecords) const {
2395 // FIXME: Implement!
2396 }
2397 virtual const char *getVAListDeclaration() const {
2398 return "typedef void* __builtin_va_list;";
2399 }
2400 virtual void getGCCRegNames(const char * const *&Names,
2401 unsigned &NumNames) const;
2402 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
2403 unsigned &NumAliases) const;
2404 virtual bool validateAsmConstraint(const char *&Name,
2405 TargetInfo::ConstraintInfo &Info) const {
2406 switch (*Name) {
2407 default:
2408 case 'r': // CPU registers.
2409 case 'd': // Equivalent to "r" unless generating MIPS16 code.
2410 case 'y': // Equivalent to "r", backwards compatibility only.
2411 case 'f': // floating-point registers.
2412 Info.setAllowsRegister();
2413 return true;
2414 }
2415 return false;
2416 }
2417
2418 virtual const char *getClobbers() const {
2419 // FIXME: Implement!
2420 return "";
2421 }
2422};
2423
2424const char * const MipsTargetInfo::GCCRegNames[] = {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002425 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002426 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
2427 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
2428 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
2429 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
2430 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
2431 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
2432 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
2433 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
2434 "$fcc5","$fcc6","$fcc7"
2435};
2436
2437void MipsTargetInfo::getGCCRegNames(const char * const *&Names,
2438 unsigned &NumNames) const {
2439 Names = GCCRegNames;
2440 NumNames = llvm::array_lengthof(GCCRegNames);
2441}
2442
2443const TargetInfo::GCCRegAlias MipsTargetInfo::GCCRegAliases[] = {
2444 { { "at" }, "$1" },
2445 { { "v0" }, "$2" },
2446 { { "v1" }, "$3" },
2447 { { "a0" }, "$4" },
2448 { { "a1" }, "$5" },
2449 { { "a2" }, "$6" },
2450 { { "a3" }, "$7" },
2451 { { "t0" }, "$8" },
2452 { { "t1" }, "$9" },
2453 { { "t2" }, "$10" },
2454 { { "t3" }, "$11" },
2455 { { "t4" }, "$12" },
2456 { { "t5" }, "$13" },
2457 { { "t6" }, "$14" },
2458 { { "t7" }, "$15" },
2459 { { "s0" }, "$16" },
2460 { { "s1" }, "$17" },
2461 { { "s2" }, "$18" },
2462 { { "s3" }, "$19" },
2463 { { "s4" }, "$20" },
2464 { { "s5" }, "$21" },
2465 { { "s6" }, "$22" },
2466 { { "s7" }, "$23" },
2467 { { "t8" }, "$24" },
2468 { { "t9" }, "$25" },
2469 { { "k0" }, "$26" },
2470 { { "k1" }, "$27" },
2471 { { "gp" }, "$28" },
2472 { { "sp" }, "$29" },
2473 { { "fp" }, "$30" },
2474 { { "ra" }, "$31" }
2475};
2476
2477void MipsTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2478 unsigned &NumAliases) const {
2479 Aliases = GCCRegAliases;
2480 NumAliases = llvm::array_lengthof(GCCRegAliases);
2481}
2482} // end anonymous namespace.
2483
2484namespace {
2485class MipselTargetInfo : public MipsTargetInfo {
2486public:
2487 MipselTargetInfo(const std::string& triple) : MipsTargetInfo(triple) {
2488 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
2489 "i64:32:64-f32:32:32-f64:64:64-v64:64:64-n32";
2490 }
2491
2492 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002493 MacroBuilder &Builder) const;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002494};
2495
2496void MipselTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002497 MacroBuilder &Builder) const {
2498 DefineStd(Builder, "mips", Opts);
2499 Builder.defineMacro("_mips");
2500 DefineStd(Builder, "MIPSEL", Opts);
2501 Builder.defineMacro("_MIPSEL");
2502 Builder.defineMacro("__REGISTER_PREFIX__", "");
Eric Christopher0b26a612010-03-02 02:41:08 +00002503 getArchDefines(Opts, Builder);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002504}
2505} // end anonymous namespace.
2506
Chris Lattner5ba61f02006-10-14 07:39:34 +00002507//===----------------------------------------------------------------------===//
2508// Driver code
2509//===----------------------------------------------------------------------===//
2510
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002511static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar52322032009-08-18 05:47:58 +00002512 llvm::Triple Triple(T);
2513 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00002514
Daniel Dunbar52322032009-08-18 05:47:58 +00002515 switch (Triple.getArch()) {
2516 default:
2517 return NULL;
Eli Friedmanb5366062008-05-20 14:21:01 +00002518
Daniel Dunbar52322032009-08-18 05:47:58 +00002519 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00002520 case llvm::Triple::thumb:
Daniel Dunbar52322032009-08-18 05:47:58 +00002521 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00002522 case llvm::Triple::Linux:
2523 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002524 case llvm::Triple::Darwin:
Eli Friedman873f65a2008-08-21 00:13:15 +00002525 return new DarwinARMTargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002526 case llvm::Triple::FreeBSD:
Torok Edwinb2b37c62009-06-30 17:10:35 +00002527 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002528 default:
2529 return new ARMTargetInfo(T);
2530 }
Eli Friedmanb5366062008-05-20 14:21:01 +00002531
Daniel Dunbar52322032009-08-18 05:47:58 +00002532 case llvm::Triple::bfin:
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00002533 return new BlackfinTargetInfo(T);
2534
Daniel Dunbar52322032009-08-18 05:47:58 +00002535 case llvm::Triple::msp430:
2536 return new MSP430TargetInfo(T);
Eli Friedmanb5366062008-05-20 14:21:01 +00002537
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00002538 case llvm::Triple::mips:
2539 if (os == llvm::Triple::Psp)
2540 return new PSPTargetInfo<MipsTargetInfo>(T);
2541 if (os == llvm::Triple::Linux)
2542 return new LinuxTargetInfo<MipsTargetInfo>(T);
2543 return new MipsTargetInfo(T);
2544
2545 case llvm::Triple::mipsel:
2546 if (os == llvm::Triple::Psp)
2547 return new PSPTargetInfo<MipselTargetInfo>(T);
2548 if (os == llvm::Triple::Linux)
2549 return new LinuxTargetInfo<MipselTargetInfo>(T);
2550 return new MipselTargetInfo(T);
2551
Daniel Dunbar52322032009-08-18 05:47:58 +00002552 case llvm::Triple::ppc:
2553 if (os == llvm::Triple::Darwin)
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00002554 return new DarwinPPCTargetInfo(T);
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00002555 else if (os == llvm::Triple::FreeBSD)
2556 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002557 return new PPC32TargetInfo(T);
2558
2559 case llvm::Triple::ppc64:
2560 if (os == llvm::Triple::Darwin)
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00002561 return new DarwinPPC64TargetInfo(T);
John Thompsone467e192009-11-19 17:18:50 +00002562 else if (os == llvm::Triple::Lv2)
2563 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00002564 else if (os == llvm::Triple::FreeBSD)
2565 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002566 return new PPC64TargetInfo(T);
2567
Chris Lattner5178f562010-03-06 21:21:27 +00002568 case llvm::Triple::mblaze:
2569 return new MBlazeTargetInfo(T);
2570
Daniel Dunbar52322032009-08-18 05:47:58 +00002571 case llvm::Triple::sparc:
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002572 if (os == llvm::Triple::AuroraUX)
2573 return new AuroraUXSparcV8TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002574 if (os == llvm::Triple::Solaris)
2575 return new SolarisSparcV8TargetInfo(T);
2576 return new SparcV8TargetInfo(T);
2577
John Thompsone467e192009-11-19 17:18:50 +00002578 // FIXME: Need a real SPU target.
2579 case llvm::Triple::cellspu:
2580 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
2581
Daniel Dunbar52322032009-08-18 05:47:58 +00002582 case llvm::Triple::systemz:
2583 return new SystemZTargetInfo(T);
2584
Eli Friedmana9c3d712009-08-19 20:47:07 +00002585 case llvm::Triple::tce:
2586 return new TCETargetInfo(T);
2587
Daniel Dunbar52322032009-08-18 05:47:58 +00002588 case llvm::Triple::x86:
2589 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002590 case llvm::Triple::AuroraUX:
2591 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002592 case llvm::Triple::Darwin:
2593 return new DarwinI386TargetInfo(T);
2594 case llvm::Triple::Linux:
2595 return new LinuxTargetInfo<X86_32TargetInfo>(T);
2596 case llvm::Triple::DragonFly:
2597 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
2598 case llvm::Triple::NetBSD:
2599 return new NetBSDTargetInfo<X86_32TargetInfo>(T);
2600 case llvm::Triple::OpenBSD:
2601 return new OpenBSDI386TargetInfo(T);
2602 case llvm::Triple::FreeBSD:
2603 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner3e2ee142010-07-07 16:01:42 +00002604 case llvm::Triple::Minix:
2605 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002606 case llvm::Triple::Solaris:
2607 return new SolarisTargetInfo<X86_32TargetInfo>(T);
2608 case llvm::Triple::Cygwin:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002609 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002610 case llvm::Triple::MinGW32:
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002611 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002612 case llvm::Triple::Win32:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002613 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattnerb986aba2010-04-11 19:29:39 +00002614 case llvm::Triple::Haiku:
2615 return new HaikuX86_32TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002616 default:
2617 return new X86_32TargetInfo(T);
2618 }
2619
2620 case llvm::Triple::x86_64:
2621 switch (os) {
Edward O'Callaghan9dda8e982009-10-18 13:33:59 +00002622 case llvm::Triple::AuroraUX:
2623 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002624 case llvm::Triple::Darwin:
2625 return new DarwinX86_64TargetInfo(T);
2626 case llvm::Triple::Linux:
2627 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner002ba6b2010-01-09 05:41:14 +00002628 case llvm::Triple::DragonFly:
2629 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002630 case llvm::Triple::NetBSD:
2631 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
2632 case llvm::Triple::OpenBSD:
2633 return new OpenBSDX86_64TargetInfo(T);
2634 case llvm::Triple::FreeBSD:
2635 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
2636 case llvm::Triple::Solaris:
2637 return new SolarisTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00002638 case llvm::Triple::MinGW64:
2639 return new MinGWX86_64TargetInfo(T);
2640 case llvm::Triple::Win32: // This is what Triple.h supports now.
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002641 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar52322032009-08-18 05:47:58 +00002642 default:
2643 return new X86_64TargetInfo(T);
2644 }
2645 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00002646}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002647
2648/// CreateTargetInfo - Return the target info object for the specified target
2649/// triple.
2650TargetInfo *TargetInfo::CreateTargetInfo(Diagnostic &Diags,
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00002651 TargetOptions &Opts) {
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002652 llvm::Triple Triple(Opts.Triple);
2653
2654 // Construct the target
2655 llvm::OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
2656 if (!Target) {
2657 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
2658 return 0;
2659 }
2660
Daniel Dunbaracde99e2009-12-18 18:42:37 +00002661 // Set the target CPU if specified.
2662 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
2663 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
2664 return 0;
2665 }
2666
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002667 // Set the target ABI if specified.
2668 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
2669 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
2670 return 0;
2671 }
2672
Charles Davis95a546e2010-06-11 01:06:47 +00002673 // Set the target C++ ABI.
John McCall86353412010-08-21 22:46:04 +00002674 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis95a546e2010-06-11 01:06:47 +00002675 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
2676 return 0;
2677 }
2678
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002679 // Compute the default target features, we need the target to handle this
2680 // because features may have dependencies on one another.
2681 llvm::StringMap<bool> Features;
2682 Target->getDefaultFeatures(Opts.CPU, Features);
2683
2684 // Apply the user specified deltas.
2685 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
2686 ie = Opts.Features.end(); it != ie; ++it) {
2687 const char *Name = it->c_str();
2688
2689 // Apply the feature via the target.
2690 if ((Name[0] != '-' && Name[0] != '+') ||
2691 !Target->setFeatureEnabled(Features, Name + 1, (Name[0] == '+'))) {
2692 Diags.Report(diag::err_target_invalid_feature) << Name;
2693 return 0;
2694 }
2695 }
2696
2697 // Add the features to the compile options.
2698 //
2699 // FIXME: If we are completely confident that we have the right set, we only
2700 // need to pass the minuses.
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00002701 Opts.Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002702 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
2703 ie = Features.end(); it != ie; ++it)
Daniel Dunbar7b245ed2009-12-19 03:30:57 +00002704 Opts.Features.push_back(std::string(it->second ? "+" : "-") + it->first());
2705 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00002706
2707 return Target.take();
2708}