blob: 85dfd78570b0e8f0886dd434a4a7f5c0cd895435 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikova7c47172009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenekbbced582007-12-12 18:05:32 +000011// target triple.
Reid Spencer5f016e22007-07-11 17:01:13 +000012//
13//===----------------------------------------------------------------------===//
14
Reid Spencer5f016e22007-07-11 17:01:13 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattner8fc4dfb2008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth103b71c2010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman25531262008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbard58c03f2009-11-15 06:48:46 +000023#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Daniel Dunbar77659342009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar29a790b2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner4c28b1c2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Dale Johannesen1e592cb2010-10-29 23:24:33 +000030#include "llvm/Type.h"
Benjamin Kramer48725082010-01-09 18:20:57 +000031#include <algorithm>
Reid Spencer5f016e22007-07-11 17:01:13 +000032using namespace clang;
33
Reid Spencer5f016e22007-07-11 17:01:13 +000034//===----------------------------------------------------------------------===//
35// Common code shared among targets.
36//===----------------------------------------------------------------------===//
37
Chris Lattnerca45cff2009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner5f9e2722011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattnerca45cff2009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000044
Chris Lattnerca45cff2009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramera9992772010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000049
Chris Lattnerca45cff2009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramera9992772010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikova7c47172009-05-03 13:42:53 +000052
Chris Lattnerca45cff2009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramera9992772010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattnerca45cff2009-03-20 16:06:38 +000055}
56
Benjamin Kramer448f68d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattnerd29b6302008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner797c3c42009-08-10 19:03:04 +000068
Torok Edwin5f6c1942009-06-30 17:10:35 +000069namespace {
Douglas Gregora3844922009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwin5f6c1942009-06-30 17:10:35 +000072protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwin5f6c1942009-06-30 17:10:35 +000075public:
Douglas Gregora3844922009-07-01 15:12:53 +000076 OSTargetInfo(const std::string& triple) : TgtInfo(triple) {}
Torok Edwin5f6c1942009-06-30 17:10:35 +000077 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +000078 MacroBuilder &Builder) const {
79 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwinb0a5b242009-06-30 17:00:25 +000081 }
Torok Edwin5f6c1942009-06-30 17:10:35 +000082
83};
Chris Lattner4c28b1c2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwinb0a5b242009-06-30 17:00:25 +000085
Chris Lattner797c3c42009-08-10 19:03:04 +000086
Daniel Dunbar21ae3192010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner5f9e2722011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Benjamin Kramera9992772010-01-09 17:55:51 +000091 Builder.defineMacro("__APPLE_CC__", "5621");
92 Builder.defineMacro("__APPLE__");
93 Builder.defineMacro("__MACH__");
94 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000095
John McCall098df7f2011-06-16 00:03:19 +000096 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +000097 // __weak is always defined, for use in blocks and with objc pointers.
98 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000099
John McCallf85e1932011-06-15 23:02:42 +0000100 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000101 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000102 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
103 else
104 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000105
John McCallf85e1932011-06-15 23:02:42 +0000106 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
107 // allow this in C, since one might have block pointers in structs that
108 // are used in pure C code and in Objective-C ARC.
109 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000110 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000111
Eli Friedman2de4fee2009-06-04 23:00:29 +0000112 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000113 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000114 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000115 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000116
117 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000119
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000120 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000121 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000122 if (Triple.isMacOSX()) {
123 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000124 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000125 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000126 Triple.getOSVersion(Maj, Min, Rev);
127 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000129
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000130 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000131 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000132 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
133 if (PlatformName == "win32") {
134 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
135 return;
136 }
137
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000138 // Set the appropriate OS version define.
Bob Wilson48b68a02012-01-31 23:52:58 +0000139 if (Triple.getOS() == llvm::Triple::IOS) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000140 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 char Str[6];
142 Str[0] = '0' + Maj;
143 Str[1] = '0' + (Min / 10);
144 Str[2] = '0' + (Min % 10);
145 Str[3] = '0' + (Rev / 10);
146 Str[4] = '0' + (Rev % 10);
147 Str[5] = '\0';
148 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
149 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000150 // Note that the Driver allows versions which aren't representable in the
151 // define (because we only get a single digit for the minor and micro
152 // revision numbers). So, we limit them to the maximum representable
153 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000154 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000155 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000156 char Str[5];
157 Str[0] = '0' + (Maj / 10);
158 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000159 Str[2] = '0' + std::min(Min, 9U);
160 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000161 Str[4] = '\0';
162 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000163 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000164
165 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000166}
Reid Spencer5f016e22007-07-11 17:01:13 +0000167
Chris Lattner797c3c42009-08-10 19:03:04 +0000168namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000169template<typename Target>
170class DarwinTargetInfo : public OSTargetInfo<Target> {
171protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000172 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000173 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000174 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000175 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000176 }
Mike Stump1eb44332009-09-09 15:08:12 +0000177
Torok Edwin5f6c1942009-06-30 17:10:35 +0000178public:
179 DarwinTargetInfo(const std::string& triple) :
180 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000181 llvm::Triple T = llvm::Triple(triple);
182 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000183 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000184 }
185
Chris Lattner5f9e2722011-07-23 10:55:15 +0000186 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000187 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000188 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000189 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000190 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000191 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000192 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000193 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000194
Anders Carlsson18af3682010-06-08 22:47:50 +0000195 virtual const char *getStaticInitSectionSpecifier() const {
196 // FIXME: We should return 0 when building kexts.
197 return "__TEXT,__StaticInit,regular,pure_instructions";
198 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000199
John McCall41887602012-01-29 01:20:30 +0000200 /// Darwin does not support protected visibility. Darwin's "default"
201 /// is very similar to ELF's "protected"; Darwin requires a "weak"
202 /// attribute on declarations that can be dynamically replaced.
203 virtual bool hasProtectedVisibility() const {
204 return false;
205 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000206};
207
Chris Lattner797c3c42009-08-10 19:03:04 +0000208
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209// DragonFlyBSD Target
210template<typename Target>
211class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
212protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000213 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000214 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000215 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000216 Builder.defineMacro("__DragonFly__");
217 Builder.defineMacro("__DragonFly_cc_version", "100001");
218 Builder.defineMacro("__ELF__");
219 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
220 Builder.defineMacro("__tune_i386__");
221 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000222 }
223public:
Mike Stump1eb44332009-09-09 15:08:12 +0000224 DragonFlyBSDTargetInfo(const std::string &triple)
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000225 : OSTargetInfo<Target>(triple) {
226 this->UserLabelPrefix = "";
227
228 llvm::Triple Triple(triple);
229 switch (Triple.getArch()) {
230 default:
231 case llvm::Triple::x86:
232 case llvm::Triple::x86_64:
233 this->MCountName = ".mcount";
234 break;
235 }
236 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000237};
238
239// FreeBSD Target
240template<typename Target>
241class FreeBSDTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000245 // FreeBSD defines; list based off of gcc output
246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 unsigned Release = Triple.getOSMajorVersion();
248 if (Release == 0U)
249 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000250
Benjamin Kramer474202f2011-10-18 10:10:08 +0000251 Builder.defineMacro("__FreeBSD__", Twine(Release));
252 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000253 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
254 DefineStd(Builder, "unix", Opts);
255 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000256 }
257public:
Mike Stump1eb44332009-09-09 15:08:12 +0000258 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000259 : OSTargetInfo<Target>(triple) {
260 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000261
262 llvm::Triple Triple(triple);
263 switch (Triple.getArch()) {
264 default:
265 case llvm::Triple::x86:
266 case llvm::Triple::x86_64:
267 this->MCountName = ".mcount";
268 break;
269 case llvm::Triple::mips:
270 case llvm::Triple::mipsel:
271 case llvm::Triple::ppc:
272 case llvm::Triple::ppc64:
273 this->MCountName = "_mcount";
274 break;
275 case llvm::Triple::arm:
276 this->MCountName = "__mcount";
277 break;
278 }
279
Duncan Sands1e90faf2009-07-08 13:55:08 +0000280 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000281};
282
Chris Lattner38e317d2010-07-07 16:01:42 +0000283// Minix Target
284template<typename Target>
285class MinixTargetInfo : public OSTargetInfo<Target> {
286protected:
287 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
288 MacroBuilder &Builder) const {
289 // Minix defines
290
291 Builder.defineMacro("__minix", "3");
292 Builder.defineMacro("_EM_WSIZE", "4");
293 Builder.defineMacro("_EM_PSIZE", "4");
294 Builder.defineMacro("_EM_SSIZE", "2");
295 Builder.defineMacro("_EM_LSIZE", "4");
296 Builder.defineMacro("_EM_FSIZE", "4");
297 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000298 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000299 DefineStd(Builder, "unix", Opts);
300 }
301public:
302 MinixTargetInfo(const std::string &triple)
303 : OSTargetInfo<Target>(triple) {
304 this->UserLabelPrefix = "";
305 }
306};
307
Torok Edwin5f6c1942009-06-30 17:10:35 +0000308// Linux target
309template<typename Target>
310class LinuxTargetInfo : public OSTargetInfo<Target> {
311protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000312 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000313 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000314 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000315 DefineStd(Builder, "unix", Opts);
316 DefineStd(Builder, "linux", Opts);
317 Builder.defineMacro("__gnu_linux__");
318 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000319 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000320 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000321 if (Opts.CPlusPlus)
322 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000323 }
324public:
Mike Stump1eb44332009-09-09 15:08:12 +0000325 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000326 : OSTargetInfo<Target>(triple) {
327 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000328 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000329 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000330
331 virtual const char *getStaticInitSectionSpecifier() const {
332 return ".text.startup";
333 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000334};
335
Chris Lattnerb62bb282009-07-13 20:29:08 +0000336// NetBSD Target
337template<typename Target>
338class NetBSDTargetInfo : public OSTargetInfo<Target> {
339protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000340 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000341 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000342 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000343 Builder.defineMacro("__NetBSD__");
344 Builder.defineMacro("__unix__");
345 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000346 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000347 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000348 }
349public:
Mike Stump1eb44332009-09-09 15:08:12 +0000350 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000351 : OSTargetInfo<Target>(triple) {
352 this->UserLabelPrefix = "";
353 }
354};
355
Torok Edwin5f6c1942009-06-30 17:10:35 +0000356// OpenBSD Target
357template<typename Target>
358class OpenBSDTargetInfo : public OSTargetInfo<Target> {
359protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000360 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000361 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000362 // OpenBSD defines; list based off of gcc output
363
Benjamin Kramera9992772010-01-09 17:55:51 +0000364 Builder.defineMacro("__OpenBSD__");
365 DefineStd(Builder, "unix", Opts);
366 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000367 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000368 Builder.defineMacro("_POSIX_THREADS");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000369 }
370public:
Mike Stump1eb44332009-09-09 15:08:12 +0000371 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000372 : OSTargetInfo<Target>(triple) {
373 this->UserLabelPrefix = "";
374
375 llvm::Triple Triple(triple);
376 switch (Triple.getArch()) {
377 default:
378 case llvm::Triple::x86:
379 case llvm::Triple::x86_64:
380 case llvm::Triple::arm:
381 case llvm::Triple::sparc:
382 this->MCountName = "__mcount";
383 break;
384 case llvm::Triple::mips64:
385 case llvm::Triple::mips64el:
386 case llvm::Triple::ppc:
387 case llvm::Triple::sparcv9:
388 this->MCountName = "_mcount";
389 break;
390 }
391 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000392};
393
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000394// PSP Target
395template<typename Target>
396class PSPTargetInfo : public OSTargetInfo<Target> {
397protected:
398 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000399 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000400 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000401 Builder.defineMacro("PSP");
402 Builder.defineMacro("_PSP");
403 Builder.defineMacro("__psp__");
404 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000405 }
406public:
407 PSPTargetInfo(const std::string& triple)
408 : OSTargetInfo<Target>(triple) {
409 this->UserLabelPrefix = "";
410 }
411};
412
John Thompson3f6918a2009-11-19 17:18:50 +0000413// PS3 PPU Target
414template<typename Target>
415class PS3PPUTargetInfo : public OSTargetInfo<Target> {
416protected:
417 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000418 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000419 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000420 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000421 Builder.defineMacro("__PPU__");
422 Builder.defineMacro("__CELLOS_LV2__");
423 Builder.defineMacro("__ELF__");
424 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000425 Builder.defineMacro("_ARCH_PPC64");
426 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000427 }
428public:
429 PS3PPUTargetInfo(const std::string& triple)
430 : OSTargetInfo<Target>(triple) {
431 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000432 this->LongWidth = this->LongAlign = 32;
433 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000434 this->IntMaxType = TargetInfo::SignedLongLong;
435 this->UIntMaxType = TargetInfo::UnsignedLongLong;
436 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000437 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000438 this->DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Nick Lewycky99520702011-12-16 22:32:39 +0000439 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000440 }
441};
442
443// FIXME: Need a real SPU target.
444// PS3 SPU Target
445template<typename Target>
446class PS3SPUTargetInfo : public OSTargetInfo<Target> {
447protected:
448 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000449 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000450 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000451 Builder.defineMacro("__SPU__");
452 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000453 }
454public:
455 PS3SPUTargetInfo(const std::string& triple)
456 : OSTargetInfo<Target>(triple) {
457 this->UserLabelPrefix = "";
458 }
459};
460
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000461// AuroraUX target
462template<typename Target>
463class AuroraUXTargetInfo : public OSTargetInfo<Target> {
464protected:
465 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000466 MacroBuilder &Builder) const {
467 DefineStd(Builder, "sun", Opts);
468 DefineStd(Builder, "unix", Opts);
469 Builder.defineMacro("__ELF__");
470 Builder.defineMacro("__svr4__");
471 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000472 }
473public:
474 AuroraUXTargetInfo(const std::string& triple)
475 : OSTargetInfo<Target>(triple) {
476 this->UserLabelPrefix = "";
477 this->WCharType = this->SignedLong;
478 // FIXME: WIntType should be SignedLong
479 }
480};
481
Torok Edwin5f6c1942009-06-30 17:10:35 +0000482// Solaris target
483template<typename Target>
484class SolarisTargetInfo : public OSTargetInfo<Target> {
485protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000486 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000487 MacroBuilder &Builder) const {
488 DefineStd(Builder, "sun", Opts);
489 DefineStd(Builder, "unix", Opts);
490 Builder.defineMacro("__ELF__");
491 Builder.defineMacro("__svr4__");
492 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000493 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
494 // newer, but to 500 for everything else. feature_test.h has a check to
495 // ensure that you are not using C99 with an old version of X/Open or C89
496 // with a new version.
497 if (Opts.C99 || Opts.C11)
498 Builder.defineMacro("_XOPEN_SOURCE", "600");
499 else
500 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000501 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000502 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000503 Builder.defineMacro("_LARGEFILE_SOURCE");
504 Builder.defineMacro("_LARGEFILE64_SOURCE");
505 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000506 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000507 }
508public:
Mike Stump1eb44332009-09-09 15:08:12 +0000509 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000510 : OSTargetInfo<Target>(triple) {
511 this->UserLabelPrefix = "";
512 this->WCharType = this->SignedLong;
513 // FIXME: WIntType should be SignedLong
514 }
515};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000516
517// Windows target
518template<typename Target>
519class WindowsTargetInfo : public OSTargetInfo<Target> {
520protected:
521 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
522 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000523 Builder.defineMacro("_WIN32");
524 }
525 void getVisualStudioDefines(const LangOptions &Opts,
526 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000527 if (Opts.CPlusPlus) {
528 if (Opts.RTTI)
529 Builder.defineMacro("_CPPRTTI");
530
531 if (Opts.Exceptions)
532 Builder.defineMacro("_CPPUNWIND");
533 }
534
535 if (!Opts.CharIsSigned)
536 Builder.defineMacro("_CHAR_UNSIGNED");
537
538 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
539 // but it works for now.
540 if (Opts.POSIXThreads)
541 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000542
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000543 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000544 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545
Francois Pichet62ec1f22011-09-17 17:15:52 +0000546 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000547 Builder.defineMacro("_MSC_EXTENSIONS");
548
549 if (Opts.CPlusPlus0x) {
550 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
551 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
552 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
553 }
554 }
555
556 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000557 }
558
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000559public:
560 WindowsTargetInfo(const std::string &triple)
561 : OSTargetInfo<Target>(triple) {}
562};
563
Mike Stump1eb44332009-09-09 15:08:12 +0000564} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000565
Chris Lattnerd29b6302008-10-05 21:50:58 +0000566//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000567// Specific target implementations.
568//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000569
Eli Friedmane4277982008-08-20 23:11:40 +0000570namespace {
571// PPC abstract base class
572class PPCTargetInfo : public TargetInfo {
573 static const Builtin::Info BuiltinInfo[];
574 static const char * const GCCRegNames[];
575 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Eli Friedmane4277982008-08-20 23:11:40 +0000576public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000577 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
578 LongDoubleWidth = LongDoubleAlign = 128;
579 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
580 }
Eli Friedman15b91762009-06-05 07:05:05 +0000581
Eli Friedmane4277982008-08-20 23:11:40 +0000582 virtual void getTargetBuiltins(const Builtin::Info *&Records,
583 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000584 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000585 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000586 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000587
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000588 virtual bool isCLZForZeroUndef() const { return false; }
589
Chris Lattner33328642009-03-20 15:52:06 +0000590 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000591 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000592
Douglas Gregore727d212012-01-30 06:38:25 +0000593 virtual bool hasFeature(StringRef Feature) const;
594
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000595 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000596 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000597 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000598 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000599 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000600 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000601 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000602 default: return false;
603 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000604 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000605 case 'b': // Base register
606 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000607 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000608 break;
609 // FIXME: The following are added to allow parsing.
610 // I just took a guess at what the actions should be.
611 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000612 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000613 case 'v': // Altivec vector register
614 Info.setAllowsRegister();
615 break;
616 case 'w':
617 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000618 case 'd':// VSX vector register to hold vector double data
619 case 'f':// VSX vector register to hold vector float data
620 case 's':// VSX vector register to hold scalar float data
621 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000622 break;
623 default:
624 return false;
625 }
626 Info.setAllowsRegister();
627 Name++; // Skip over 'w'.
628 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000629 case 'h': // `MQ', `CTR', or `LINK' register
630 case 'q': // `MQ' register
631 case 'c': // `CTR' register
632 case 'l': // `LINK' register
633 case 'x': // `CR' register (condition register) number 0
634 case 'y': // `CR' register (condition register)
635 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000636 Info.setAllowsRegister();
637 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000638 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000639 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000640 // (use `L' instead for SImode constants)
641 case 'K': // Unsigned 16-bit constant
642 case 'L': // Signed 16-bit constant shifted left 16 bits
643 case 'M': // Constant larger than 31
644 case 'N': // Exact power of 2
645 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000646 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000647 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000648 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000649 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000650 break;
651 case 'm': // Memory operand. Note that on PowerPC targets, m can
652 // include addresses that update the base register. It
653 // is therefore only safe to use `m' in an asm statement
654 // if that asm statement accesses the operand exactly once.
655 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000656 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000657 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000658 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000659 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000660 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
661 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000662 // register to be updated.
663 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000664 if (Name[1] != 's')
665 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000666 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000667 // include any automodification of the base register. Unlike
668 // `m', this constraint can be used in asm statements that
669 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000670 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000671 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000672 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000673 break;
674 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000675 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000676 case 'Z': // Memory operand that is an indexed or indirect from a
677 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000678 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000679 Info.setAllowsMemory();
680 Info.setAllowsRegister();
681 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000682 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000683 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000684 // register (`p' is preferable for asm statements)
685 case 'S': // Constant suitable as a 64-bit mask operand
686 case 'T': // Constant suitable as a 32-bit mask operand
687 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000688 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000689 // instructions
690 case 'W': // Vector constant that does not require memory
691 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000692 break;
693 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000694 }
John Thompson8e6065a2010-06-24 22:44:13 +0000695 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000696 }
Eli Friedmane4277982008-08-20 23:11:40 +0000697 virtual const char *getClobbers() const {
698 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000699 }
Eli Friedmane4277982008-08-20 23:11:40 +0000700};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000701
Eli Friedmane4277982008-08-20 23:11:40 +0000702const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000703#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000704#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000705 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000706#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000707};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000708
709
Chris Lattnerc0f59212009-03-02 22:27:17 +0000710/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
711/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000712void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000713 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000714 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000715 Builder.defineMacro("__ppc__");
716 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000717 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000718 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000719 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000720 Builder.defineMacro("_ARCH_PPC64");
721 Builder.defineMacro("_LP64");
722 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000723 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000724 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000725 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000726 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000727 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000728
Chris Lattnerc0f59212009-03-02 22:27:17 +0000729 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000730 if (getTriple().getOS() != llvm::Triple::NetBSD)
731 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000732 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000733
Chris Lattnerc0f59212009-03-02 22:27:17 +0000734 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000735 Builder.defineMacro("__NATURAL_ALIGNMENT__");
736 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000737
Chris Lattnerc0f59212009-03-02 22:27:17 +0000738 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000739 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000740
John Thompson3f6918a2009-11-19 17:18:50 +0000741 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000742 Builder.defineMacro("__VEC__", "10206");
743 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000744 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000745}
746
Douglas Gregore727d212012-01-30 06:38:25 +0000747bool PPCTargetInfo::hasFeature(StringRef Feature) const {
748 return Feature == "powerpc";
749}
Chris Lattner393ff042008-04-21 18:56:49 +0000750
Douglas Gregore727d212012-01-30 06:38:25 +0000751
Eli Friedmane4277982008-08-20 23:11:40 +0000752const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000753 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
754 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
755 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
756 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
757 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
758 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
759 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
760 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000761 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000762 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000763 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000764 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
765 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
766 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
767 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000768 "vrsave", "vscr",
769 "spe_acc", "spefscr",
770 "sfp"
771};
Reid Spencer5f016e22007-07-11 17:01:13 +0000772
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000773void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000774 unsigned &NumNames) const {
775 Names = GCCRegNames;
776 NumNames = llvm::array_lengthof(GCCRegNames);
777}
Reid Spencer5f016e22007-07-11 17:01:13 +0000778
Eli Friedmane4277982008-08-20 23:11:40 +0000779const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
780 // While some of these aliases do map to different registers
781 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000782 { { "0" }, "r0" },
783 { { "1"}, "r1" },
784 { { "2" }, "r2" },
785 { { "3" }, "r3" },
786 { { "4" }, "r4" },
787 { { "5" }, "r5" },
788 { { "6" }, "r6" },
789 { { "7" }, "r7" },
790 { { "8" }, "r8" },
791 { { "9" }, "r9" },
792 { { "10" }, "r10" },
793 { { "11" }, "r11" },
794 { { "12" }, "r12" },
795 { { "13" }, "r13" },
796 { { "14" }, "r14" },
797 { { "15" }, "r15" },
798 { { "16" }, "r16" },
799 { { "17" }, "r17" },
800 { { "18" }, "r18" },
801 { { "19" }, "r19" },
802 { { "20" }, "r20" },
803 { { "21" }, "r21" },
804 { { "22" }, "r22" },
805 { { "23" }, "r23" },
806 { { "24" }, "r24" },
807 { { "25" }, "r25" },
808 { { "26" }, "r26" },
809 { { "27" }, "r27" },
810 { { "28" }, "r28" },
811 { { "29" }, "r29" },
812 { { "30" }, "r30" },
813 { { "31" }, "r31" },
814 { { "fr0" }, "f0" },
815 { { "fr1" }, "f1" },
816 { { "fr2" }, "f2" },
817 { { "fr3" }, "f3" },
818 { { "fr4" }, "f4" },
819 { { "fr5" }, "f5" },
820 { { "fr6" }, "f6" },
821 { { "fr7" }, "f7" },
822 { { "fr8" }, "f8" },
823 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000824 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000825 { { "fr11" }, "f11" },
826 { { "fr12" }, "f12" },
827 { { "fr13" }, "f13" },
828 { { "fr14" }, "f14" },
829 { { "fr15" }, "f15" },
830 { { "fr16" }, "f16" },
831 { { "fr17" }, "f17" },
832 { { "fr18" }, "f18" },
833 { { "fr19" }, "f19" },
834 { { "fr20" }, "f20" },
835 { { "fr21" }, "f21" },
836 { { "fr22" }, "f22" },
837 { { "fr23" }, "f23" },
838 { { "fr24" }, "f24" },
839 { { "fr25" }, "f25" },
840 { { "fr26" }, "f26" },
841 { { "fr27" }, "f27" },
842 { { "fr28" }, "f28" },
843 { { "fr29" }, "f29" },
844 { { "fr30" }, "f30" },
845 { { "fr31" }, "f31" },
846 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000847};
848
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000849void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000850 unsigned &NumAliases) const {
851 Aliases = GCCRegAliases;
852 NumAliases = llvm::array_lengthof(GCCRegAliases);
853}
854} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000855
856namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000857class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000858public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000859 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000860 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000861 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000862
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000863 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000864 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000865 case llvm::Triple::FreeBSD:
866 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000867 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +0000868 PtrDiffType = SignedInt;
869 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000870 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000871 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000872 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000873 }
Roman Divackye3d175d2012-03-13 16:53:54 +0000874
875 if (getTriple().getOS() == llvm::Triple::FreeBSD)
876 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000877 }
878
879 virtual const char *getVAListDeclaration() const {
880 // This is the ELF definition, and is overridden by the Darwin sub-target
881 return "typedef struct __va_list_tag {"
882 " unsigned char gpr;"
883 " unsigned char fpr;"
884 " unsigned short reserved;"
885 " void* overflow_arg_area;"
886 " void* reg_save_area;"
887 "} __builtin_va_list[1];";
Eli Friedmaned855cb2008-08-21 00:13:15 +0000888 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000889};
890} // end anonymous namespace.
891
892namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000893class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000894public:
Eli Friedmane4277982008-08-20 23:11:40 +0000895 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000896 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000897 IntMaxType = SignedLong;
898 UIntMaxType = UnsignedLong;
899 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000900 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +0000901 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Roman Divackye3d175d2012-03-13 16:53:54 +0000902
903 if (getTriple().getOS() == llvm::Triple::FreeBSD)
904 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Chris Lattnerf291b102008-05-09 06:17:04 +0000905 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000906 virtual const char *getVAListDeclaration() const {
907 return "typedef char* __builtin_va_list;";
908 }
Eli Friedmane4277982008-08-20 23:11:40 +0000909};
910} // end anonymous namespace.
911
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000912
913namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000914class DarwinPPC32TargetInfo :
915 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000916public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000917 DarwinPPC32TargetInfo(const std::string& triple)
918 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000919 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000920 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000921 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000922 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000923 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
924 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +0000925 }
926 virtual const char *getVAListDeclaration() const {
927 return "typedef char* __builtin_va_list;";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000928 }
929};
930
931class DarwinPPC64TargetInfo :
932 public DarwinTargetInfo<PPC64TargetInfo> {
933public:
934 DarwinPPC64TargetInfo(const std::string& triple)
935 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
936 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000937 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000938 }
939};
940} // end anonymous namespace.
941
Reid Spencer5f016e22007-07-11 17:01:13 +0000942namespace {
Justin Holewinski25bedca2011-10-03 17:28:37 +0000943 static const unsigned PTXAddrSpaceMap[] = {
944 0, // opencl_global
945 4, // opencl_local
946 1 // opencl_constant
947 };
Justin Holewinski285dc652011-04-20 19:34:15 +0000948 class PTXTargetInfo : public TargetInfo {
949 static const char * const GCCRegNames[];
950 static const Builtin::Info BuiltinInfo[];
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000951 std::vector<llvm::StringRef> AvailableFeatures;
Justin Holewinski285dc652011-04-20 19:34:15 +0000952 public:
953 PTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +0000954 BigEndian = false;
Justin Holewinski285dc652011-04-20 19:34:15 +0000955 TLSSupported = false;
956 LongWidth = LongAlign = 64;
Justin Holewinski25bedca2011-10-03 17:28:37 +0000957 AddrSpaceMap = &PTXAddrSpaceMap;
Justin Holewinskid8e0fe62011-09-22 17:57:40 +0000958 // Define available target features
959 // These must be defined in sorted order!
960 AvailableFeatures.push_back("compute10");
961 AvailableFeatures.push_back("compute11");
962 AvailableFeatures.push_back("compute12");
963 AvailableFeatures.push_back("compute13");
964 AvailableFeatures.push_back("compute20");
965 AvailableFeatures.push_back("double");
966 AvailableFeatures.push_back("no-fma");
967 AvailableFeatures.push_back("ptx20");
968 AvailableFeatures.push_back("ptx21");
969 AvailableFeatures.push_back("ptx22");
970 AvailableFeatures.push_back("ptx23");
971 AvailableFeatures.push_back("sm10");
972 AvailableFeatures.push_back("sm11");
973 AvailableFeatures.push_back("sm12");
974 AvailableFeatures.push_back("sm13");
975 AvailableFeatures.push_back("sm20");
976 AvailableFeatures.push_back("sm21");
977 AvailableFeatures.push_back("sm22");
978 AvailableFeatures.push_back("sm23");
Justin Holewinski285dc652011-04-20 19:34:15 +0000979 }
980 virtual void getTargetDefines(const LangOptions &Opts,
981 MacroBuilder &Builder) const {
982 Builder.defineMacro("__PTX__");
983 }
984 virtual void getTargetBuiltins(const Builtin::Info *&Records,
985 unsigned &NumRecords) const {
986 Records = BuiltinInfo;
987 NumRecords = clang::PTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
988 }
Douglas Gregore727d212012-01-30 06:38:25 +0000989 virtual bool hasFeature(StringRef Feature) const {
990 return Feature == "ptx";
991 }
992
Justin Holewinski285dc652011-04-20 19:34:15 +0000993 virtual void getGCCRegNames(const char * const *&Names,
994 unsigned &NumNames) const;
995 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
996 unsigned &NumAliases) const {
997 // No aliases.
998 Aliases = 0;
999 NumAliases = 0;
1000 }
1001 virtual bool validateAsmConstraint(const char *&Name,
1002 TargetInfo::ConstraintInfo &info) const {
1003 // FIXME: implement
1004 return true;
1005 }
1006 virtual const char *getClobbers() const {
1007 // FIXME: Is this really right?
1008 return "";
1009 }
1010 virtual const char *getVAListDeclaration() const {
1011 // FIXME: implement
1012 return "typedef char* __builtin_va_list;";
1013 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001014
1015 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001016 StringRef Name,
Justin Holewinski808ef662011-09-15 12:13:38 +00001017 bool Enabled) const;
Justin Holewinski285dc652011-04-20 19:34:15 +00001018 };
1019
1020 const Builtin::Info PTXTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001021#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +00001022#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001023 ALL_LANGUAGES },
Justin Holewinski285dc652011-04-20 19:34:15 +00001024#include "clang/Basic/BuiltinsPTX.def"
1025 };
1026
1027 const char * const PTXTargetInfo::GCCRegNames[] = {
1028 "r0"
1029 };
1030
1031 void PTXTargetInfo::getGCCRegNames(const char * const *&Names,
1032 unsigned &NumNames) const {
1033 Names = GCCRegNames;
1034 NumNames = llvm::array_lengthof(GCCRegNames);
1035 }
1036
Justin Holewinski808ef662011-09-15 12:13:38 +00001037 bool PTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001038 StringRef Name,
Justin Holewinski808ef662011-09-15 12:13:38 +00001039 bool Enabled) const {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001040 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1041 Name)) {
1042 Features[Name] = Enabled;
1043 return true;
Justin Holewinski808ef662011-09-15 12:13:38 +00001044 } else {
Justin Holewinskid8e0fe62011-09-22 17:57:40 +00001045 return false;
Justin Holewinski808ef662011-09-15 12:13:38 +00001046 }
Justin Holewinski808ef662011-09-15 12:13:38 +00001047 }
Justin Holewinski285dc652011-04-20 19:34:15 +00001048
1049 class PTX32TargetInfo : public PTXTargetInfo {
1050 public:
1051 PTX32TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1052 PointerWidth = PointerAlign = 32;
1053 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
1054 DescriptionString
1055 = "e-p:32:32-i64:64:64-f64:64:64-n1:8:16:32:64";
1056 }
1057 };
1058
1059 class PTX64TargetInfo : public PTXTargetInfo {
1060 public:
1061 PTX64TargetInfo(const std::string& triple) : PTXTargetInfo(triple) {
1062 PointerWidth = PointerAlign = 64;
1063 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
1064 DescriptionString
1065 = "e-p:64:64-i64:64:64-f64:64:64-n1:8:16:32:64";
1066 }
1067 };
1068}
1069
1070namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001071// MBlaze abstract base class
1072class MBlazeTargetInfo : public TargetInfo {
1073 static const char * const GCCRegNames[];
1074 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1075
1076public:
1077 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001078 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001079 }
1080
1081 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1082 unsigned &NumRecords) const {
1083 // FIXME: Implement.
1084 Records = 0;
1085 NumRecords = 0;
1086 }
1087
1088 virtual void getTargetDefines(const LangOptions &Opts,
1089 MacroBuilder &Builder) const;
1090
Douglas Gregore727d212012-01-30 06:38:25 +00001091 virtual bool hasFeature(StringRef Feature) const {
1092 return Feature == "mblaze";
1093 }
1094
Chris Lattner9cbeb632010-03-06 21:21:27 +00001095 virtual const char *getVAListDeclaration() const {
1096 return "typedef char* __builtin_va_list;";
1097 }
1098 virtual const char *getTargetPrefix() const {
1099 return "mblaze";
1100 }
1101 virtual void getGCCRegNames(const char * const *&Names,
1102 unsigned &NumNames) const;
1103 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1104 unsigned &NumAliases) const;
1105 virtual bool validateAsmConstraint(const char *&Name,
1106 TargetInfo::ConstraintInfo &Info) const {
1107 switch (*Name) {
1108 default: return false;
1109 case 'O': // Zero
1110 return true;
1111 case 'b': // Base register
1112 case 'f': // Floating point register
1113 Info.setAllowsRegister();
1114 return true;
1115 }
1116 }
1117 virtual const char *getClobbers() const {
1118 return "";
1119 }
1120};
1121
1122/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1123/// #defines that are not tied to a specific subtarget.
1124void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1125 MacroBuilder &Builder) const {
1126 // Target identification.
1127 Builder.defineMacro("__microblaze__");
1128 Builder.defineMacro("_ARCH_MICROBLAZE");
1129 Builder.defineMacro("__MICROBLAZE__");
1130
1131 // Target properties.
1132 Builder.defineMacro("_BIG_ENDIAN");
1133 Builder.defineMacro("__BIG_ENDIAN__");
1134
1135 // Subtarget options.
1136 Builder.defineMacro("__REGISTER_PREFIX__", "");
1137}
1138
1139
1140const char * const MBlazeTargetInfo::GCCRegNames[] = {
1141 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1142 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1143 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1144 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1145 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1146 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1147 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1148 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1149 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1150 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1151};
1152
1153void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1154 unsigned &NumNames) const {
1155 Names = GCCRegNames;
1156 NumNames = llvm::array_lengthof(GCCRegNames);
1157}
1158
1159const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1160 { {"f0"}, "r0" },
1161 { {"f1"}, "r1" },
1162 { {"f2"}, "r2" },
1163 { {"f3"}, "r3" },
1164 { {"f4"}, "r4" },
1165 { {"f5"}, "r5" },
1166 { {"f6"}, "r6" },
1167 { {"f7"}, "r7" },
1168 { {"f8"}, "r8" },
1169 { {"f9"}, "r9" },
1170 { {"f10"}, "r10" },
1171 { {"f11"}, "r11" },
1172 { {"f12"}, "r12" },
1173 { {"f13"}, "r13" },
1174 { {"f14"}, "r14" },
1175 { {"f15"}, "r15" },
1176 { {"f16"}, "r16" },
1177 { {"f17"}, "r17" },
1178 { {"f18"}, "r18" },
1179 { {"f19"}, "r19" },
1180 { {"f20"}, "r20" },
1181 { {"f21"}, "r21" },
1182 { {"f22"}, "r22" },
1183 { {"f23"}, "r23" },
1184 { {"f24"}, "r24" },
1185 { {"f25"}, "r25" },
1186 { {"f26"}, "r26" },
1187 { {"f27"}, "r27" },
1188 { {"f28"}, "r28" },
1189 { {"f29"}, "r29" },
1190 { {"f30"}, "r30" },
1191 { {"f31"}, "r31" },
1192};
1193
1194void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1195 unsigned &NumAliases) const {
1196 Aliases = GCCRegAliases;
1197 NumAliases = llvm::array_lengthof(GCCRegAliases);
1198}
1199} // end anonymous namespace.
1200
1201namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001202// Namespace for x86 abstract base class
1203const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001204#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001205#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001206 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001207#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001208};
Eli Friedman61538a72008-05-20 14:21:01 +00001209
Nuno Lopes2550d702009-12-23 17:49:57 +00001210static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001211 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1212 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001213 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001214 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1215 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1216 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001217 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001218 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1219 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001220};
1221
Eric Christophercfd323d2011-06-21 00:05:20 +00001222const TargetInfo::AddlRegName AddlRegNames[] = {
1223 { { "al", "ah", "eax", "rax" }, 0 },
1224 { { "bl", "bh", "ebx", "rbx" }, 3 },
1225 { { "cl", "ch", "ecx", "rcx" }, 2 },
1226 { { "dl", "dh", "edx", "rdx" }, 1 },
1227 { { "esi", "rsi" }, 4 },
1228 { { "edi", "rdi" }, 5 },
1229 { { "esp", "rsp" }, 7 },
1230 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001231};
1232
1233// X86 target abstract base class; x86-32 and x86-64 are very close, so
1234// most of the implementation can be shared.
1235class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001236 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001237 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001238 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001239 enum MMX3DNowEnum {
1240 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1241 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001242
Eric Christophereea12d12010-04-02 23:50:19 +00001243 bool HasAES;
Craig Topper31ceea02011-12-25 05:06:45 +00001244 bool HasLZCNT;
1245 bool HasBMI;
1246 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001247 bool HasPOPCNT;
Craig Topper6a511e12011-12-30 07:33:42 +00001248 bool HasFMA4;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001249
Chandler Carruth499d9722011-09-28 08:55:34 +00001250 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1251 ///
1252 /// Each enumeration represents a particular CPU supported by Clang. These
1253 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1254 enum CPUKind {
1255 CK_Generic,
1256
1257 /// \name i386
1258 /// i386-generation processors.
1259 //@{
1260 CK_i386,
1261 //@}
1262
1263 /// \name i486
1264 /// i486-generation processors.
1265 //@{
1266 CK_i486,
1267 CK_WinChipC6,
1268 CK_WinChip2,
1269 CK_C3,
1270 //@}
1271
1272 /// \name i586
1273 /// i586-generation processors, P5 microarchitecture based.
1274 //@{
1275 CK_i586,
1276 CK_Pentium,
1277 CK_PentiumMMX,
1278 //@}
1279
1280 /// \name i686
1281 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1282 //@{
1283 CK_i686,
1284 CK_PentiumPro,
1285 CK_Pentium2,
1286 CK_Pentium3,
1287 CK_Pentium3M,
1288 CK_PentiumM,
1289 CK_C3_2,
1290
1291 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1292 /// Clang however has some logic to suport this.
1293 // FIXME: Warn, deprecate, and potentially remove this.
1294 CK_Yonah,
1295 //@}
1296
1297 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001298 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001299 //@{
1300 CK_Pentium4,
1301 CK_Pentium4M,
1302 CK_Prescott,
1303 CK_Nocona,
1304 //@}
1305
1306 /// \name Core
1307 /// Core microarchitecture based processors.
1308 //@{
1309 CK_Core2,
1310
1311 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1312 /// codename which GCC no longer accepts as an option to -march, but Clang
1313 /// has some logic for recognizing it.
1314 // FIXME: Warn, deprecate, and potentially remove this.
1315 CK_Penryn,
1316 //@}
1317
1318 /// \name Atom
1319 /// Atom processors
1320 //@{
1321 CK_Atom,
1322 //@}
1323
1324 /// \name Nehalem
1325 /// Nehalem microarchitecture based processors.
1326 //@{
1327 CK_Corei7,
1328 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001329 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001330 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001331 //@}
1332
1333 /// \name K6
1334 /// K6 architecture processors.
1335 //@{
1336 CK_K6,
1337 CK_K6_2,
1338 CK_K6_3,
1339 //@}
1340
1341 /// \name K7
1342 /// K7 architecture processors.
1343 //@{
1344 CK_Athlon,
1345 CK_AthlonThunderbird,
1346 CK_Athlon4,
1347 CK_AthlonXP,
1348 CK_AthlonMP,
1349 //@}
1350
1351 /// \name K8
1352 /// K8 architecture processors.
1353 //@{
1354 CK_Athlon64,
1355 CK_Athlon64SSE3,
1356 CK_AthlonFX,
1357 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001358 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001359 CK_Opteron,
1360 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001361 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001362 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001363
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001364 /// \name Bobcat
1365 /// Bobcat architecture processors.
1366 //@{
1367 CK_BTVER1,
1368 //@}
1369
1370 /// \name Bulldozer
1371 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001372 //@{
1373 CK_BDVER1,
1374 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001375 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001376
Chandler Carruth499d9722011-09-28 08:55:34 +00001377 /// This specification is deprecated and will be removed in the future.
1378 /// Users should prefer \see CK_K8.
1379 // FIXME: Warn on this when the CPU is set to it.
1380 CK_x86_64,
1381 //@}
1382
1383 /// \name Geode
1384 /// Geode processors.
1385 //@{
1386 CK_Geode
1387 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001388 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001389
Eli Friedman618234a2008-08-20 02:34:37 +00001390public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001391 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001392 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper05fe4b52012-01-09 09:19:09 +00001393 HasAES(false), HasLZCNT(false), HasBMI(false), HasBMI2(false),
1394 HasPOPCNT(false), HasFMA4(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001395 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001396 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001397 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001398 virtual unsigned getFloatEvalMethod() const {
1399 // X87 evaluates with 80 bits "long double" precision.
1400 return SSELevel == NoSSE ? 2 : 0;
1401 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001402 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1403 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001404 Records = BuiltinInfo;
1405 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001406 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001407 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001408 unsigned &NumNames) const {
1409 Names = GCCRegNames;
1410 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001411 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001412 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001413 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001414 Aliases = 0;
1415 NumAliases = 0;
1416 }
1417 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1418 unsigned &NumNames) const {
1419 Names = AddlRegNames;
1420 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001421 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001422 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001423 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001424 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001425 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001426 return "~{dirflag},~{fpsr},~{flags}";
1427 }
Chris Lattner33328642009-03-20 15:52:06 +00001428 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001429 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001430 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001431 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001432 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001433 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001434 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001435 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001436 virtual const char* getABI() const {
Craig Topper05fe4b52012-01-09 09:19:09 +00001437 if (PointerWidth == 64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001438 return "avx";
1439 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1440 return "no-mmx";
1441 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001442 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001443 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001444 CPU = llvm::StringSwitch<CPUKind>(Name)
1445 .Case("i386", CK_i386)
1446 .Case("i486", CK_i486)
1447 .Case("winchip-c6", CK_WinChipC6)
1448 .Case("winchip2", CK_WinChip2)
1449 .Case("c3", CK_C3)
1450 .Case("i586", CK_i586)
1451 .Case("pentium", CK_Pentium)
1452 .Case("pentium-mmx", CK_PentiumMMX)
1453 .Case("i686", CK_i686)
1454 .Case("pentiumpro", CK_PentiumPro)
1455 .Case("pentium2", CK_Pentium2)
1456 .Case("pentium3", CK_Pentium3)
1457 .Case("pentium3m", CK_Pentium3M)
1458 .Case("pentium-m", CK_PentiumM)
1459 .Case("c3-2", CK_C3_2)
1460 .Case("yonah", CK_Yonah)
1461 .Case("pentium4", CK_Pentium4)
1462 .Case("pentium4m", CK_Pentium4M)
1463 .Case("prescott", CK_Prescott)
1464 .Case("nocona", CK_Nocona)
1465 .Case("core2", CK_Core2)
1466 .Case("penryn", CK_Penryn)
1467 .Case("atom", CK_Atom)
1468 .Case("corei7", CK_Corei7)
1469 .Case("corei7-avx", CK_Corei7AVX)
1470 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001471 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001472 .Case("k6", CK_K6)
1473 .Case("k6-2", CK_K6_2)
1474 .Case("k6-3", CK_K6_3)
1475 .Case("athlon", CK_Athlon)
1476 .Case("athlon-tbird", CK_AthlonThunderbird)
1477 .Case("athlon-4", CK_Athlon4)
1478 .Case("athlon-xp", CK_AthlonXP)
1479 .Case("athlon-mp", CK_AthlonMP)
1480 .Case("athlon64", CK_Athlon64)
1481 .Case("athlon64-sse3", CK_Athlon64SSE3)
1482 .Case("athlon-fx", CK_AthlonFX)
1483 .Case("k8", CK_K8)
1484 .Case("k8-sse3", CK_K8SSE3)
1485 .Case("opteron", CK_Opteron)
1486 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001487 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001488 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001489 .Case("bdver1", CK_BDVER1)
1490 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001491 .Case("x86-64", CK_x86_64)
1492 .Case("geode", CK_Geode)
1493 .Default(CK_Generic);
1494
Chandler Carruth26a39142011-09-28 09:45:08 +00001495 // Perform any per-CPU checks necessary to determine if this CPU is
1496 // acceptable.
1497 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1498 // invalid without explaining *why*.
1499 switch (CPU) {
1500 case CK_Generic:
1501 // No processor selected!
1502 return false;
1503
1504 case CK_i386:
1505 case CK_i486:
1506 case CK_WinChipC6:
1507 case CK_WinChip2:
1508 case CK_C3:
1509 case CK_i586:
1510 case CK_Pentium:
1511 case CK_PentiumMMX:
1512 case CK_i686:
1513 case CK_PentiumPro:
1514 case CK_Pentium2:
1515 case CK_Pentium3:
1516 case CK_Pentium3M:
1517 case CK_PentiumM:
1518 case CK_Yonah:
1519 case CK_C3_2:
1520 case CK_Pentium4:
1521 case CK_Pentium4M:
1522 case CK_Prescott:
1523 case CK_K6:
1524 case CK_K6_2:
1525 case CK_K6_3:
1526 case CK_Athlon:
1527 case CK_AthlonThunderbird:
1528 case CK_Athlon4:
1529 case CK_AthlonXP:
1530 case CK_AthlonMP:
1531 case CK_Geode:
1532 // Only accept certain architectures when compiling in 32-bit mode.
1533 if (PointerWidth != 32)
1534 return false;
1535
1536 // Fallthrough
1537 case CK_Nocona:
1538 case CK_Core2:
1539 case CK_Penryn:
1540 case CK_Atom:
1541 case CK_Corei7:
1542 case CK_Corei7AVX:
1543 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001544 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001545 case CK_Athlon64:
1546 case CK_Athlon64SSE3:
1547 case CK_AthlonFX:
1548 case CK_K8:
1549 case CK_K8SSE3:
1550 case CK_Opteron:
1551 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001552 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001553 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001554 case CK_BDVER1:
1555 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001556 case CK_x86_64:
1557 return true;
1558 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001559 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001560 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001561};
Chris Lattner3daed522009-03-02 22:20:04 +00001562
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001563void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001564 // FIXME: This should not be here.
1565 Features["3dnow"] = false;
1566 Features["3dnowa"] = false;
1567 Features["mmx"] = false;
1568 Features["sse"] = false;
1569 Features["sse2"] = false;
1570 Features["sse3"] = false;
1571 Features["ssse3"] = false;
1572 Features["sse41"] = false;
1573 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001574 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001575 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001576 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001577 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001578 Features["lzcnt"] = false;
1579 Features["bmi"] = false;
1580 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001581 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001582 Features["fma4"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001583
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001584 // FIXME: This *really* should not be here.
1585
1586 // X86_64 always has SSE2.
1587 if (PointerWidth == 64)
1588 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1589
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001590 switch (CPU) {
1591 case CK_Generic:
1592 case CK_i386:
1593 case CK_i486:
1594 case CK_i586:
1595 case CK_Pentium:
1596 case CK_i686:
1597 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001598 break;
1599 case CK_PentiumMMX:
1600 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001601 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001602 break;
1603 case CK_Pentium3:
1604 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001605 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001606 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001607 break;
1608 case CK_PentiumM:
1609 case CK_Pentium4:
1610 case CK_Pentium4M:
1611 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001612 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001613 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001614 break;
1615 case CK_Yonah:
1616 case CK_Prescott:
1617 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001618 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001619 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001620 break;
1621 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001622 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001623 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001624 break;
1625 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001626 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001627 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001628 break;
1629 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001630 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001631 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001632 break;
1633 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001634 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001635 setFeatureEnabled(Features, "sse4", true);
Eric Christophereea12d12010-04-02 23:50:19 +00001636 setFeatureEnabled(Features, "aes", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001637 break;
1638 case CK_Corei7AVX:
1639 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001640 setFeatureEnabled(Features, "mmx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001641 setFeatureEnabled(Features, "sse4", true);
1642 setFeatureEnabled(Features, "aes", true);
Bruno Cardoso Lopese02d3912011-07-11 23:33:46 +00001643 //setFeatureEnabled(Features, "avx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001644 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001645 case CK_CoreAVX2:
1646 setFeatureEnabled(Features, "mmx", true);
1647 setFeatureEnabled(Features, "sse4", true);
1648 setFeatureEnabled(Features, "aes", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001649 setFeatureEnabled(Features, "lzcnt", true);
1650 setFeatureEnabled(Features, "bmi", true);
1651 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001652 //setFeatureEnabled(Features, "avx2", true);
1653 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001654 case CK_K6:
1655 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001656 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001657 break;
1658 case CK_K6_2:
1659 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001660 case CK_WinChip2:
1661 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001662 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001663 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001664 case CK_Athlon:
1665 case CK_AthlonThunderbird:
1666 case CK_Geode:
1667 setFeatureEnabled(Features, "3dnowa", true);
1668 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001669 case CK_Athlon4:
1670 case CK_AthlonXP:
1671 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001672 setFeatureEnabled(Features, "sse", true);
1673 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001674 break;
1675 case CK_K8:
1676 case CK_Opteron:
1677 case CK_Athlon64:
1678 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001679 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001680 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001681 break;
1682 case CK_K8SSE3:
1683 case CK_OpteronSSE3:
1684 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001685 setFeatureEnabled(Features, "sse3", true);
1686 setFeatureEnabled(Features, "3dnowa", true);
1687 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001688 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001689 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001690 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001691 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001692 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001693 case CK_BTVER1:
1694 setFeatureEnabled(Features, "ssse3", true);
1695 setFeatureEnabled(Features, "sse4a", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001696 case CK_BDVER1:
1697 case CK_BDVER2:
1698 setFeatureEnabled(Features, "sse4", true);
1699 setFeatureEnabled(Features, "sse4a", true);
1700 setFeatureEnabled(Features, "aes", true);
1701 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001702 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001703 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001704 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001705 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001706 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001707}
1708
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001709bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001710 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001711 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001712 // FIXME: This *really* should not be here. We need some way of translating
1713 // options into llvm subtarget features.
1714 if (!Features.count(Name) &&
1715 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001716 return false;
1717
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001718 // FIXME: this should probably use a switch with fall through.
1719
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001720 if (Enabled) {
1721 if (Name == "mmx")
1722 Features["mmx"] = true;
1723 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001724 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001725 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001726 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001727 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001728 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1729 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001730 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001731 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001732 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001733 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001734 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001735 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1736 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001737 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001738 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001739 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001740 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001741 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001742 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001743 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001744 else if (Name == "aes")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001745 Features["aes"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001746 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001747 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1748 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001749 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001750 else if (Name == "avx2")
1751 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1752 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001753 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001754 else if (Name == "fma4")
1755 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1756 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1757 Features["popcnt"] = Features["avx"] = Features["fma4"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001758 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001759 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Benjamin Kramer5c65e4f2012-01-10 11:50:13 +00001760 Features["lzcnt"] = Features["popcnt"] = Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001761 else if (Name == "lzcnt")
1762 Features["lzcnt"] = true;
1763 else if (Name == "bmi")
1764 Features["bmi"] = true;
1765 else if (Name == "bmi2")
1766 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001767 else if (Name == "popcnt")
1768 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001769 } else {
1770 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001771 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001772 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001773 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001774 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1775 Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001776 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001777 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001778 Features["sse41"] = Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001779 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001780 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001781 Features["sse42"] = Features["sse4a"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001782 else if (Name == "ssse3")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001783 Features["ssse3"] = Features["sse41"] = Features["sse42"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001784 else if (Name == "sse4" || Name == "sse4.1")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001785 Features["sse41"] = Features["sse42"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001786 else if (Name == "sse4.2")
Daniel Dunbarcb65de12011-05-03 15:34:01 +00001787 Features["sse42"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001788 else if (Name == "3dnow")
1789 Features["3dnow"] = Features["3dnowa"] = false;
1790 else if (Name == "3dnowa")
1791 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001792 else if (Name == "aes")
1793 Features["aes"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001794 else if (Name == "avx")
Craig Topper6a511e12011-12-30 07:33:42 +00001795 Features["avx"] = Features["avx2"] = Features["fma4"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001796 else if (Name == "avx2")
1797 Features["avx2"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001798 else if (Name == "sse4a")
1799 Features["sse4a"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001800 else if (Name == "lzcnt")
1801 Features["lzcnt"] = false;
1802 else if (Name == "bmi")
1803 Features["bmi"] = false;
1804 else if (Name == "bmi2")
1805 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001806 else if (Name == "popcnt")
1807 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001808 else if (Name == "fma4")
1809 Features["fma4"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001810 }
1811
1812 return true;
1813}
1814
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001815/// HandleTargetOptions - Perform initialization based on the user
1816/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001817void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001818 // Remember the maximum enabled sselevel.
1819 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1820 // Ignore disabled features.
1821 if (Features[i][0] == '-')
1822 continue;
1823
Benjamin Kramer713575a2012-03-05 15:10:44 +00001824 StringRef Feature = StringRef(Features[i]).substr(1);
1825
1826 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00001827 HasAES = true;
1828 continue;
1829 }
1830
Benjamin Kramer713575a2012-03-05 15:10:44 +00001831 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00001832 HasLZCNT = true;
1833 continue;
1834 }
1835
Benjamin Kramer713575a2012-03-05 15:10:44 +00001836 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00001837 HasBMI = true;
1838 continue;
1839 }
1840
Benjamin Kramer713575a2012-03-05 15:10:44 +00001841 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00001842 HasBMI2 = true;
1843 continue;
1844 }
1845
Benjamin Kramer713575a2012-03-05 15:10:44 +00001846 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00001847 HasPOPCNT = true;
1848 continue;
1849 }
1850
Benjamin Kramer713575a2012-03-05 15:10:44 +00001851 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00001852 HasFMA4 = true;
1853 continue;
1854 }
1855
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001856 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00001857 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00001858 .Case("avx2", AVX2)
1859 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001860 .Case("sse42", SSE42)
1861 .Case("sse41", SSE41)
1862 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001863 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001864 .Case("sse2", SSE2)
1865 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001866 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001867 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001868
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001869 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00001870 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001871 .Case("3dnowa", AMD3DNowAthlon)
1872 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001873 .Case("mmx", MMX)
1874 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001875
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001876 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001877 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001878
1879 // Don't tell the backend if we're turning off mmx; it will end up disabling
1880 // SSE, which we don't want.
1881 std::vector<std::string>::iterator it;
1882 it = std::find(Features.begin(), Features.end(), "-mmx");
1883 if (it != Features.end())
1884 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001885}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001886
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001887/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1888/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001889void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001890 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001891 // Target identification.
1892 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00001893 Builder.defineMacro("_LP64");
1894 Builder.defineMacro("__LP64__");
1895 Builder.defineMacro("__amd64__");
1896 Builder.defineMacro("__amd64");
1897 Builder.defineMacro("__x86_64");
1898 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00001899 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00001900 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00001901 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001902
Chris Lattnerc0f59212009-03-02 22:27:17 +00001903 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001904 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
1905 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001906 switch (CPU) {
1907 case CK_Generic:
1908 break;
1909 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001910 // The rest are coming from the i386 define above.
1911 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001912 break;
1913 case CK_i486:
1914 case CK_WinChipC6:
1915 case CK_WinChip2:
1916 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001917 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001918 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00001919 case CK_PentiumMMX:
1920 Builder.defineMacro("__pentium_mmx__");
1921 Builder.defineMacro("__tune_pentium_mmx__");
1922 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001923 case CK_i586:
1924 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001925 defineCPUMacros(Builder, "i586");
1926 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001927 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001928 case CK_Pentium3:
1929 case CK_Pentium3M:
1930 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001931 Builder.defineMacro("__tune_pentium3__");
1932 // Fallthrough
1933 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001934 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001935 Builder.defineMacro("__tune_pentium2__");
1936 // Fallthrough
1937 case CK_PentiumPro:
1938 Builder.defineMacro("__tune_i686__");
1939 Builder.defineMacro("__tune_pentiumpro__");
1940 // Fallthrough
1941 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001942 Builder.defineMacro("__i686");
1943 Builder.defineMacro("__i686__");
1944 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
1945 Builder.defineMacro("__pentiumpro");
1946 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001947 break;
1948 case CK_Pentium4:
1949 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001950 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001951 break;
1952 case CK_Yonah:
1953 case CK_Prescott:
1954 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001955 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001956 break;
1957 case CK_Core2:
1958 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001959 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001960 break;
1961 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001962 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001963 break;
1964 case CK_Corei7:
1965 case CK_Corei7AVX:
1966 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001967 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001968 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001969 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001970 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001971 Builder.defineMacro("__k6_2__");
1972 Builder.defineMacro("__tune_k6_2__");
1973 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001974 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00001975 if (CPU != CK_K6_2) { // In case of fallthrough
1976 // FIXME: GCC may be enabling these in cases where some other k6
1977 // architecture is specified but -m3dnow is explicitly provided. The
1978 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001979 Builder.defineMacro("__k6_3__");
1980 Builder.defineMacro("__tune_k6_3__");
1981 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00001982 // Fallthrough
1983 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001984 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001985 break;
1986 case CK_Athlon:
1987 case CK_AthlonThunderbird:
1988 case CK_Athlon4:
1989 case CK_AthlonXP:
1990 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00001991 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001992 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001993 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00001994 Builder.defineMacro("__tune_athlon_sse__");
1995 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001996 break;
1997 case CK_K8:
1998 case CK_K8SSE3:
1999 case CK_x86_64:
2000 case CK_Opteron:
2001 case CK_OpteronSSE3:
2002 case CK_Athlon64:
2003 case CK_Athlon64SSE3:
2004 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002005 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002006 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002007 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002008 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002009 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002010 case CK_BTVER1:
2011 defineCPUMacros(Builder, "btver1");
2012 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002013 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002014 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002015 break;
2016 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002017 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002018 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002019 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002020 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002021 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002022 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002023
Chandler Carruth88c75b02011-09-28 09:54:07 +00002024 // Target properties.
2025 Builder.defineMacro("__LITTLE_ENDIAN__");
2026 Builder.defineMacro("__REGISTER_PREFIX__", "");
2027
Chris Lattner54175442009-04-19 17:32:33 +00002028 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2029 // functions in glibc header files that use FP Stack inline asm which the
2030 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002031 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002032
Chandler Carruth88c75b02011-09-28 09:54:07 +00002033 if (HasAES)
2034 Builder.defineMacro("__AES__");
2035
Craig Topper31ceea02011-12-25 05:06:45 +00002036 if (HasLZCNT)
2037 Builder.defineMacro("__LZCNT__");
2038
2039 if (HasBMI)
2040 Builder.defineMacro("__BMI__");
2041
2042 if (HasBMI2)
2043 Builder.defineMacro("__BMI2__");
2044
Craig Toppere14e08b2011-12-29 16:10:46 +00002045 if (HasPOPCNT)
2046 Builder.defineMacro("__POPCNT__");
2047
Craig Topper6a511e12011-12-30 07:33:42 +00002048 if (HasFMA4)
2049 Builder.defineMacro("__FMA4__");
2050
Chris Lattner84f0ea82009-03-02 22:40:39 +00002051 // Each case falls through to the previous one here.
2052 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002053 case AVX2:
2054 Builder.defineMacro("__AVX2__");
2055 case AVX:
2056 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002057 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002058 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002059 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002060 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002061 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002062 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002063 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002064 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002065 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002066 Builder.defineMacro("__SSE2__");
2067 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002068 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002069 Builder.defineMacro("__SSE__");
2070 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002071 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002072 break;
2073 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002074
Francois Pichet62ec1f22011-09-17 17:15:52 +00002075 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002076 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002077 case AVX2:
2078 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002079 case SSE42:
2080 case SSE41:
2081 case SSSE3:
2082 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002083 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002084 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002085 break;
2086 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002087 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002088 break;
2089 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002090 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002091 }
2092 }
2093
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002094 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002095 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002096 case AMD3DNowAthlon:
2097 Builder.defineMacro("__3dNOW_A__");
2098 case AMD3DNow:
2099 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002100 case MMX:
2101 Builder.defineMacro("__MMX__");
2102 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002103 break;
2104 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002105}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002106
Douglas Gregore727d212012-01-30 06:38:25 +00002107bool X86TargetInfo::hasFeature(StringRef Feature) const {
2108 return llvm::StringSwitch<bool>(Feature)
2109 .Case("aes", HasAES)
2110 .Case("avx", SSELevel >= AVX)
2111 .Case("avx2", SSELevel >= AVX2)
2112 .Case("bmi", HasBMI)
2113 .Case("bmi2", HasBMI2)
2114 .Case("fma4", HasFMA4)
2115 .Case("lzcnt", HasLZCNT)
2116 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2117 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2118 .Case("mmx", MMX3DNowLevel >= MMX)
2119 .Case("popcnt", HasPOPCNT)
2120 .Case("sse", SSELevel >= SSE1)
2121 .Case("sse2", SSELevel >= SSE2)
2122 .Case("sse3", SSELevel >= SSE3)
2123 .Case("ssse3", SSELevel >= SSSE3)
2124 .Case("sse41", SSELevel >= SSE41)
2125 .Case("sse42", SSELevel >= SSE42)
2126 .Case("x86", true)
2127 .Case("x86_32", PointerWidth == 32)
2128 .Case("x86_64", PointerWidth == 64)
2129 .Default(false);
2130}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002131
Eli Friedman618234a2008-08-20 02:34:37 +00002132bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002133X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002134 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002135 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002136 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002137 case 'Y': // first letter of a pair:
2138 switch (*(Name+1)) {
2139 default: return false;
2140 case '0': // First SSE register.
2141 case 't': // Any SSE register, when SSE2 is enabled.
2142 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2143 case 'm': // any MMX register, when inter-unit moves enabled.
2144 break; // falls through to setAllowsRegister.
2145 }
Eli Friedman618234a2008-08-20 02:34:37 +00002146 case 'a': // eax.
2147 case 'b': // ebx.
2148 case 'c': // ecx.
2149 case 'd': // edx.
2150 case 'S': // esi.
2151 case 'D': // edi.
2152 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002153 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002154 case 't': // top of floating point stack.
2155 case 'u': // second from top of floating point stack.
2156 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002157 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002158 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002159 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002160 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2161 case 'l': // "Index" registers: any general register that can be used as an
2162 // index in a base+index memory access.
2163 Info.setAllowsRegister();
2164 return true;
2165 case 'C': // SSE floating point constant.
2166 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002167 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002168 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002169 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002170 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002171 return true;
2172 }
2173}
2174
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002175
Eli Friedman618234a2008-08-20 02:34:37 +00002176std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002177X86TargetInfo::convertConstraint(const char *&Constraint) const {
2178 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002179 case 'a': return std::string("{ax}");
2180 case 'b': return std::string("{bx}");
2181 case 'c': return std::string("{cx}");
2182 case 'd': return std::string("{dx}");
2183 case 'S': return std::string("{si}");
2184 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002185 case 'p': // address
2186 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002187 case 't': // top of floating point stack.
2188 return std::string("{st}");
2189 case 'u': // second from top of floating point stack.
2190 return std::string("{st(1)}"); // second from top of floating point stack.
2191 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002192 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002193 }
2194}
Eli Friedman618234a2008-08-20 02:34:37 +00002195} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002196
2197namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002198// X86-32 generic target
2199class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002200public:
Eli Friedman618234a2008-08-20 02:34:37 +00002201 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2202 DoubleAlign = LongLongAlign = 32;
2203 LongDoubleWidth = 96;
2204 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002205 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002206 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2207 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002208 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002209 SizeType = UnsignedInt;
2210 PtrDiffType = SignedInt;
2211 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002212 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002213
2214 // Use fpret for all types.
2215 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2216 (1 << TargetInfo::Double) |
2217 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002218
2219 // x86-32 has atomics up to 8 bytes
2220 // FIXME: Check that we actually have cmpxchg8b before setting
2221 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2222 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002223 }
2224 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002225 return "typedef char* __builtin_va_list;";
Eli Friedman618234a2008-08-20 02:34:37 +00002226 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002227
Chris Lattner21fb98e2009-09-23 06:06:36 +00002228 int getEHDataRegisterNumber(unsigned RegNo) const {
2229 if (RegNo == 0) return 0;
2230 if (RegNo == 1) return 2;
2231 return -1;
2232 }
Eli Friedman618234a2008-08-20 02:34:37 +00002233};
2234} // end anonymous namespace
2235
2236namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002237class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2238public:
2239 NetBSDI386TargetInfo(const std::string &triple) :
2240 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2241 }
2242
2243 virtual unsigned getFloatEvalMethod() const {
2244 // NetBSD defaults to "double" rounding
2245 return 1;
2246 }
2247};
2248} // end anonymous namespace
2249
2250namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002251class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2252public:
2253 OpenBSDI386TargetInfo(const std::string& triple) :
2254 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2255 SizeType = UnsignedLong;
2256 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002257 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002258 }
2259};
2260} // end anonymous namespace
2261
2262namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002263class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002264public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002265 DarwinI386TargetInfo(const std::string& triple) :
2266 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002267 LongDoubleWidth = 128;
2268 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002269 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002270 SizeType = UnsignedLong;
2271 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002272 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2273 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002274 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002275 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002276 }
2277
Eli Friedman618234a2008-08-20 02:34:37 +00002278};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002279} // end anonymous namespace
2280
2281namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002282// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002283class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002284public:
2285 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002286 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002287 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002288 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002289 DoubleAlign = LongLongAlign = 64;
2290 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Anton Korobeynikovb3814412009-12-19 02:05:07 +00002291 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002292 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002293 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002294 virtual void getTargetDefines(const LangOptions &Opts,
2295 MacroBuilder &Builder) const {
2296 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2297 }
2298};
2299} // end anonymous namespace
2300
2301namespace {
2302
2303// x86-32 Windows Visual Studio target
2304class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2305public:
2306 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2307 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002308 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002309 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2310 }
2311 virtual void getTargetDefines(const LangOptions &Opts,
2312 MacroBuilder &Builder) const {
2313 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2314 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2315 // The value of the following reflects processor type.
2316 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2317 // We lost the original triple, so we use the default.
2318 Builder.defineMacro("_M_IX86", "600");
2319 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002320};
2321} // end anonymous namespace
2322
2323namespace {
2324// x86-32 MinGW target
2325class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2326public:
2327 MinGWX86_32TargetInfo(const std::string& triple)
2328 : WindowsX86_32TargetInfo(triple) {
2329 }
2330 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002331 MacroBuilder &Builder) const {
2332 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002333 DefineStd(Builder, "WIN32", Opts);
2334 DefineStd(Builder, "WINNT", Opts);
2335 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002336 Builder.defineMacro("__MSVCRT__");
2337 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002338
2339 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2340 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002341 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002342 // Provide "as-is" __declspec.
2343 Builder.defineMacro("__declspec", "__declspec");
2344 else
2345 // Provide alias of __attribute__ like mingw32-gcc.
2346 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002347 }
2348};
2349} // end anonymous namespace
2350
2351namespace {
2352// x86-32 Cygwin target
2353class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2354public:
2355 CygwinX86_32TargetInfo(const std::string& triple)
2356 : X86_32TargetInfo(triple) {
2357 TLSSupported = false;
2358 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002359 DoubleAlign = LongLongAlign = 64;
2360 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2361 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002362 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002363 }
2364 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002365 MacroBuilder &Builder) const {
2366 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2367 Builder.defineMacro("__CYGWIN__");
2368 Builder.defineMacro("__CYGWIN32__");
2369 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002370 if (Opts.CPlusPlus)
2371 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002372 }
Eli Friedman29a30502008-08-21 01:40:19 +00002373};
2374} // end anonymous namespace
2375
2376namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002377// x86-32 Haiku target
2378class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2379public:
2380 HaikuX86_32TargetInfo(const std::string& triple)
2381 : X86_32TargetInfo(triple) {
2382 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002383 IntPtrType = SignedLong;
2384 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002385 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002386 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002387 virtual void getTargetDefines(const LangOptions &Opts,
2388 MacroBuilder &Builder) const {
2389 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2390 Builder.defineMacro("__INTEL__");
2391 Builder.defineMacro("__HAIKU__");
2392 }
2393};
2394} // end anonymous namespace
2395
Douglas Gregordca52262011-07-01 22:41:14 +00002396// RTEMS Target
2397template<typename Target>
2398class RTEMSTargetInfo : public OSTargetInfo<Target> {
2399protected:
2400 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2401 MacroBuilder &Builder) const {
2402 // RTEMS defines; list based off of gcc output
2403
Douglas Gregordca52262011-07-01 22:41:14 +00002404 Builder.defineMacro("__rtems__");
2405 Builder.defineMacro("__ELF__");
2406 }
2407public:
2408 RTEMSTargetInfo(const std::string &triple)
2409 : OSTargetInfo<Target>(triple) {
2410 this->UserLabelPrefix = "";
2411
2412 llvm::Triple Triple(triple);
2413 switch (Triple.getArch()) {
2414 default:
2415 case llvm::Triple::x86:
2416 // this->MCountName = ".mcount";
2417 break;
2418 case llvm::Triple::mips:
2419 case llvm::Triple::mipsel:
2420 case llvm::Triple::ppc:
2421 case llvm::Triple::ppc64:
2422 // this->MCountName = "_mcount";
2423 break;
2424 case llvm::Triple::arm:
2425 // this->MCountName = "__mcount";
2426 break;
2427 }
2428
2429 }
2430};
2431
2432namespace {
2433// x86-32 RTEMS target
2434class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2435public:
2436 RTEMSX86_32TargetInfo(const std::string& triple)
2437 : X86_32TargetInfo(triple) {
2438 SizeType = UnsignedLong;
2439 IntPtrType = SignedLong;
2440 PtrDiffType = SignedLong;
2441 this->UserLabelPrefix = "";
2442 }
2443 virtual void getTargetDefines(const LangOptions &Opts,
2444 MacroBuilder &Builder) const {
2445 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2446 Builder.defineMacro("__INTEL__");
2447 Builder.defineMacro("__rtems__");
2448 }
2449};
2450} // end anonymous namespace
2451
Chris Lattner86ed3a32010-04-11 19:29:39 +00002452namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002453// x86-64 generic target
2454class X86_64TargetInfo : public X86TargetInfo {
2455public:
Chris Lattner33328642009-03-20 15:52:06 +00002456 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002457 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002458 LongDoubleWidth = 128;
2459 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002460 LargeArrayMinWidth = 128;
2461 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002462 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002463 IntMaxType = SignedLong;
2464 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002465 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002466 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002467
Eli Friedmaned855cb2008-08-21 00:13:15 +00002468 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2469 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002470 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002471
2472 // Use fpret only for long double.
2473 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002474
Anders Carlssoneea64802011-10-31 16:27:11 +00002475 // Use fp2ret for _Complex long double.
2476 ComplexLongDoubleUsesFP2Ret = true;
2477
Eli Friedman2be46072011-10-14 20:59:01 +00002478 // x86-64 has atomics up to 16 bytes.
2479 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2480 // on CPUs with cmpxchg16b
2481 MaxAtomicPromoteWidth = 128;
2482 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002483 }
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00002484 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00002485 return "typedef struct __va_list_tag {"
2486 " unsigned gp_offset;"
2487 " unsigned fp_offset;"
2488 " void* overflow_arg_area;"
2489 " void* reg_save_area;"
John McCall2b7baf02010-05-28 18:25:28 +00002490 "} __va_list_tag;"
Eli Friedmandc043162009-07-03 00:45:06 +00002491 "typedef __va_list_tag __builtin_va_list[1];";
Anders Carlsson3346ae62007-11-24 23:38:12 +00002492 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002493
Chris Lattner21fb98e2009-09-23 06:06:36 +00002494 int getEHDataRegisterNumber(unsigned RegNo) const {
2495 if (RegNo == 0) return 0;
2496 if (RegNo == 1) return 1;
2497 return -1;
2498 }
Eli Friedman618234a2008-08-20 02:34:37 +00002499};
2500} // end anonymous namespace
2501
2502namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002503// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002504class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002505public:
2506 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002507 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002508 TLSSupported = false;
2509 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002510 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002511 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002512 IntMaxType = SignedLongLong;
2513 UIntMaxType = UnsignedLongLong;
2514 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002515 SizeType = UnsignedLongLong;
2516 PtrDiffType = SignedLongLong;
2517 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002518 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002519 }
2520 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002521 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002522 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002523 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002524 }
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002525 virtual const char *getVAListDeclaration() const {
2526 return "typedef char* __builtin_va_list;";
2527 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002528};
2529} // end anonymous namespace
2530
2531namespace {
2532// x86-64 Windows Visual Studio target
2533class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2534public:
2535 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2536 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002537 LongDoubleWidth = LongDoubleAlign = 64;
2538 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002539 }
2540 virtual void getTargetDefines(const LangOptions &Opts,
2541 MacroBuilder &Builder) const {
2542 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2543 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002544 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002545 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002546 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002547};
2548} // end anonymous namespace
2549
2550namespace {
2551// x86-64 MinGW target
2552class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2553public:
2554 MinGWX86_64TargetInfo(const std::string& triple)
2555 : WindowsX86_64TargetInfo(triple) {
2556 }
2557 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002558 MacroBuilder &Builder) const {
2559 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002560 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002561 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002562 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002563 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002564
2565 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2566 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002567 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002568 // Provide "as-is" __declspec.
2569 Builder.defineMacro("__declspec", "__declspec");
2570 else
2571 // Provide alias of __attribute__ like mingw32-gcc.
2572 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002573 }
2574};
2575} // end anonymous namespace
2576
2577namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002578class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2579public:
Mike Stump1eb44332009-09-09 15:08:12 +00002580 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002581 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2582 Int64Type = SignedLongLong;
2583 }
2584};
2585} // end anonymous namespace
2586
2587namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002588class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2589public:
Mike Stump1eb44332009-09-09 15:08:12 +00002590 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002591 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2592 IntMaxType = SignedLongLong;
2593 UIntMaxType = UnsignedLongLong;
2594 Int64Type = SignedLongLong;
2595 }
2596};
2597} // end anonymous namespace
2598
2599namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002600class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002601 // Possible FPU choices.
2602 enum FPUMode {
2603 NoFPU,
2604 VFP2FPU,
2605 VFP3FPU,
2606 NeonFPU
2607 };
2608
2609 static bool FPUModeIsVFP(FPUMode Mode) {
2610 return Mode >= VFP2FPU && Mode <= NeonFPU;
2611 }
2612
2613 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2614 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002615
Daniel Dunbareac7c532009-12-18 18:42:37 +00002616 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002617
2618 unsigned FPU : 3;
2619
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002620 unsigned IsThumb : 1;
2621
2622 // Initialized via features.
2623 unsigned SoftFloat : 1;
2624 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002625
Chris Lattner2752c012010-03-03 19:03:45 +00002626 static const Builtin::Info BuiltinInfo[];
2627
Chris Lattner393ff042008-04-21 18:56:49 +00002628public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002629 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002630 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002631 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002632 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002633 SizeType = UnsignedInt;
2634 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002635 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2636 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002637
Chris Lattner9bffb072010-04-23 16:29:58 +00002638 // {} in inline assembly are neon specifiers, not assembly variant
2639 // specifiers.
2640 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002641
Daniel Dunbareac7c532009-12-18 18:42:37 +00002642 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002643 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002644 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002645 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2646 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002647 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2648 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002649 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002650 } else {
2651 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2652 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002653 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002654 }
John McCallee79a4c2010-08-21 22:46:04 +00002655
2656 // ARM targets default to using the ARM C++ ABI.
2657 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002658
2659 // ARM has atomics up to 8 bytes
2660 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2661 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00002662
2663 // Do force alignment of members that follow zero length bitfields. If
2664 // the alignment of the zero-length bitfield is greater than the member
2665 // that follows it, `bar', `bar' will be aligned as the type of the
2666 // zero length bitfield.
2667 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00002668 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002669 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002670 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002671 ABI = Name;
2672
Daniel Dunbara2a41612009-09-14 00:02:24 +00002673 // The defaults (above) are for AAPCS, check if we need to change them.
2674 //
2675 // FIXME: We need support for -meabi... we could just mangle it into the
2676 // name.
2677 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002678 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002679 SizeType = UnsignedLong;
2680
James Molloya6d81f92011-11-23 13:35:08 +00002681 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2682 WCharType = SignedInt;
2683
Daniel Dunbar684de632010-04-22 16:14:54 +00002684 // Do not respect the alignment of bit-field types when laying out
2685 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2686 UseBitFieldTypeAlignment = false;
2687
Chad Rosier61a62212011-08-04 01:21:14 +00002688 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002689 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2690 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002691 ZeroLengthBitfieldBoundary = 32;
2692
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002693 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002694 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2695 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002696 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
Bob Wilson949fd1a2011-06-29 16:09:20 +00002697 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002698 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002699 } else {
2700 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bob Wilsoncd5ce092011-04-04 16:53:11 +00002701 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002702 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002703 }
2704
Chad Rosier9f1210c2011-07-26 07:03:04 +00002705 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002706 } else if (Name == "aapcs") {
2707 // FIXME: Enumerated types are variable width in straight AAPCS.
2708 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002709 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002710 } else
2711 return false;
2712
2713 return true;
2714 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002715
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002716 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002717 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2718 Features["vfp2"] = true;
2719 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2720 Features["neon"] = true;
2721 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002722
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002723 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002724 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002725 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002726 if (Name == "soft-float" || Name == "soft-float-abi" ||
Evgeniy Stepanov35dd7322012-01-11 11:21:31 +00002727 Name == "vfp2" || Name == "vfp3" || Name == "neon" || Name == "d16") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002728 Features[Name] = Enabled;
2729 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002730 return false;
2731
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002732 return true;
2733 }
2734
2735 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002736 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002737 SoftFloat = SoftFloatABI = false;
2738 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2739 if (Features[i] == "+soft-float")
2740 SoftFloat = true;
2741 else if (Features[i] == "+soft-float-abi")
2742 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002743 else if (Features[i] == "+vfp2")
2744 FPU = VFP2FPU;
2745 else if (Features[i] == "+vfp3")
2746 FPU = VFP3FPU;
2747 else if (Features[i] == "+neon")
2748 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002749 }
2750
2751 // Remove front-end specific options which the backend handles differently.
2752 std::vector<std::string>::iterator it;
2753 it = std::find(Features.begin(), Features.end(), "+soft-float");
2754 if (it != Features.end())
2755 Features.erase(it);
2756 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2757 if (it != Features.end())
2758 Features.erase(it);
2759 }
2760
Douglas Gregore727d212012-01-30 06:38:25 +00002761 virtual bool hasFeature(StringRef Feature) const {
2762 return llvm::StringSwitch<bool>(Feature)
2763 .Case("arm", true)
2764 .Case("softfloat", SoftFloat)
2765 .Case("thumb", IsThumb)
2766 .Case("neon", FPU == NeonFPU && !SoftFloat &&
2767 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
2768 .Default(false);
2769 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002770 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002771 return llvm::StringSwitch<const char*>(Name)
2772 .Cases("arm8", "arm810", "4")
2773 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2774 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2775 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2776 .Case("ep9312", "4T")
2777 .Cases("arm10tdmi", "arm1020t", "5T")
2778 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2779 .Case("arm926ej-s", "5TEJ")
2780 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2781 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002782 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002783 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002784 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002785 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2786 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002787 .Case("cortex-m3", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002788 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002789 .Default(0);
2790 }
2791 virtual bool setCPU(const std::string &Name) {
2792 if (!getCPUDefineSuffix(Name))
2793 return false;
2794
2795 CPU = Name;
2796 return true;
2797 }
Chris Lattner33328642009-03-20 15:52:06 +00002798 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002799 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002800 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002801 Builder.defineMacro("__arm");
2802 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002803
Chris Lattnerc0f59212009-03-02 22:27:17 +00002804 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002805 Builder.defineMacro("__ARMEL__");
2806 Builder.defineMacro("__LITTLE_ENDIAN__");
2807 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002808
Chris Lattner5f9e2722011-07-23 10:55:15 +00002809 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002810 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002811
Mike Stump437bb4b2009-04-08 02:07:04 +00002812 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002813
Daniel Dunbareac7c532009-12-18 18:42:37 +00002814 // FIXME: It's more complicated than this and we don't really support
2815 // interworking.
2816 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002817 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002818
Daniel Dunbareac7c532009-12-18 18:42:37 +00002819 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002820 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002821
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002822 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002823 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002824
2825 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002826 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002827
Bob Wilson84f95cf2011-05-13 18:56:03 +00002828 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002829 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002830 Builder.defineMacro("__THUMBEL__");
2831 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002832 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002833 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002834 }
2835
2836 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002837 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002838
2839 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002840 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002841
2842 // This only gets set when Neon instructions are actually available, unlike
2843 // the VFP define, hence the soft float and arch check. This is subtly
2844 // different from gcc, we follow the intent which was that it should be set
2845 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002846 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002847 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002848 }
2849 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2850 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002851 Records = BuiltinInfo;
2852 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002853 }
Bob Wilson8b30a932012-01-26 22:14:27 +00002854 virtual bool isCLZForZeroUndef() const { return false; }
Chris Lattner393ff042008-04-21 18:56:49 +00002855 virtual const char *getVAListDeclaration() const {
John McCall0e9972c2011-05-09 02:19:37 +00002856 return "typedef void* __builtin_va_list;";
Chris Lattner393ff042008-04-21 18:56:49 +00002857 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002858 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002859 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002860 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002861 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002862 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002863 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002864 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002865 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002866 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002867 case 'l': // r0-r7
2868 case 'h': // r8-r15
2869 case 'w': // VFP Floating point register single precision
2870 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002871 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002872 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002873 case 'Q': // A memory address that is a single base register.
2874 Info.setAllowsMemory();
2875 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002876 case 'U': // a memory reference...
2877 switch (Name[1]) {
2878 case 'q': // ...ARMV4 ldrsb
2879 case 'v': // ...VFP load/store (reg+constant offset)
2880 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002881 case 't': // address valid for load/store opaque types wider
2882 // than 128-bits
2883 case 'n': // valid address for Neon doubleword vector load/store
2884 case 'm': // valid address for Neon element and structure load/store
2885 case 's': // valid address for non-offset loads/stores of quad-word
2886 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00002887 Info.setAllowsMemory();
2888 Name++;
2889 return true;
2890 }
Nate Begemanad487f42008-04-22 05:03:19 +00002891 }
Chris Lattner393ff042008-04-21 18:56:49 +00002892 return false;
2893 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00002894 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00002895 std::string R;
2896 switch (*Constraint) {
2897 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00002898 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00002899 Constraint++;
2900 break;
Eric Christopher283f4472011-06-17 00:40:18 +00002901 case 'p': // 'p' should be translated to 'r' by default.
2902 R = std::string("r");
2903 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00002904 default:
2905 return std::string(1, *Constraint);
2906 }
2907 return R;
2908 }
Chris Lattner393ff042008-04-21 18:56:49 +00002909 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002910 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00002911 return "";
2912 }
2913};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002914
2915const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002916 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002917 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002918 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
2919
2920 // Float registers
2921 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2922 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2923 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002924 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00002925
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002926 // Double registers
2927 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
2928 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00002929 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
2930 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002931
2932 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00002933 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
2934 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002935};
2936
2937void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002938 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002939 Names = GCCRegNames;
2940 NumNames = llvm::array_lengthof(GCCRegNames);
2941}
2942
2943const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002944 { { "a1" }, "r0" },
2945 { { "a2" }, "r1" },
2946 { { "a3" }, "r2" },
2947 { { "a4" }, "r3" },
2948 { { "v1" }, "r4" },
2949 { { "v2" }, "r5" },
2950 { { "v3" }, "r6" },
2951 { { "v4" }, "r7" },
2952 { { "v5" }, "r8" },
2953 { { "v6", "rfp" }, "r9" },
2954 { { "sl" }, "r10" },
2955 { { "fp" }, "r11" },
2956 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00002957 { { "r13" }, "sp" },
2958 { { "r14" }, "lr" },
2959 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00002960 // The S, D and Q registers overlap, but aren't really aliases; we
2961 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002962};
2963
2964void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
2965 unsigned &NumAliases) const {
2966 Aliases = GCCRegAliases;
2967 NumAliases = llvm::array_lengthof(GCCRegAliases);
2968}
Chris Lattner2752c012010-03-03 19:03:45 +00002969
2970const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00002971#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00002972#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00002973 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00002974#include "clang/Basic/BuiltinsARM.def"
2975};
Chris Lattner393ff042008-04-21 18:56:49 +00002976} // end anonymous namespace.
2977
Eli Friedmana9f54962008-08-20 07:44:10 +00002978namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00002979class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00002980 public DarwinTargetInfo<ARMTargetInfo> {
2981protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00002982 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00002983 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002984 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00002985 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002986
Torok Edwin5f6c1942009-06-30 17:10:35 +00002987public:
Mike Stump1eb44332009-09-09 15:08:12 +00002988 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002989 : DarwinTargetInfo<ARMTargetInfo>(triple) {
2990 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00002991 // iOS always has 64-bit atomic instructions.
2992 // FIXME: This should be based off of the target features in ARMTargetInfo.
2993 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00002994 }
Eli Friedmana9f54962008-08-20 07:44:10 +00002995};
2996} // end anonymous namespace.
2997
Tony Linthicum96319392011-12-12 21:14:55 +00002998
2999namespace {
3000// Hexagon abstract base class
3001class HexagonTargetInfo : public TargetInfo {
3002 static const Builtin::Info BuiltinInfo[];
3003 static const char * const GCCRegNames[];
3004 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3005 std::string CPU;
3006public:
3007 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003008 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003009 DescriptionString = ("e-p:32:32:32-"
3010 "i64:64:64-i32:32:32-"
3011 "i16:16:16-i1:32:32-a:0:0");
3012
3013 // {} in inline assembly are packet specifiers, not assembly variant
3014 // specifiers.
3015 NoAsmVariants = true;
3016 }
3017
3018 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3019 unsigned &NumRecords) const {
3020 Records = BuiltinInfo;
3021 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3022 }
3023
3024 virtual bool validateAsmConstraint(const char *&Name,
3025 TargetInfo::ConstraintInfo &Info) const {
3026 return true;
3027 }
3028
3029 virtual void getTargetDefines(const LangOptions &Opts,
3030 MacroBuilder &Builder) const;
3031
Douglas Gregore727d212012-01-30 06:38:25 +00003032 virtual bool hasFeature(StringRef Feature) const {
3033 return Feature == "hexagon";
3034 }
3035
Tony Linthicum96319392011-12-12 21:14:55 +00003036 virtual const char *getVAListDeclaration() const {
3037 return "typedef char* __builtin_va_list;";
3038 }
3039 virtual void getGCCRegNames(const char * const *&Names,
3040 unsigned &NumNames) const;
3041 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3042 unsigned &NumAliases) const;
3043 virtual const char *getClobbers() const {
3044 return "";
3045 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003046
3047 static const char *getHexagonCPUSuffix(StringRef Name) {
3048 return llvm::StringSwitch<const char*>(Name)
3049 .Case("hexagonv2", "2")
3050 .Case("hexagonv3", "3")
3051 .Case("hexagonv4", "4")
3052 .Default(0);
3053 }
3054
Tony Linthicum96319392011-12-12 21:14:55 +00003055 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003056 if (!getHexagonCPUSuffix(Name))
3057 return false;
3058
Tony Linthicum96319392011-12-12 21:14:55 +00003059 CPU = Name;
3060 return true;
3061 }
3062};
3063
3064void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3065 MacroBuilder &Builder) const {
3066 Builder.defineMacro("qdsp6");
3067 Builder.defineMacro("__qdsp6", "1");
3068 Builder.defineMacro("__qdsp6__", "1");
3069
3070 Builder.defineMacro("hexagon");
3071 Builder.defineMacro("__hexagon", "1");
3072 Builder.defineMacro("__hexagon__", "1");
3073
3074 if(CPU == "hexagonv1") {
3075 Builder.defineMacro("__HEXAGON_V1__");
3076 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3077 if(Opts.HexagonQdsp6Compat) {
3078 Builder.defineMacro("__QDSP6_V1__");
3079 Builder.defineMacro("__QDSP6_ARCH__", "1");
3080 }
3081 }
3082 else if(CPU == "hexagonv2") {
3083 Builder.defineMacro("__HEXAGON_V2__");
3084 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3085 if(Opts.HexagonQdsp6Compat) {
3086 Builder.defineMacro("__QDSP6_V2__");
3087 Builder.defineMacro("__QDSP6_ARCH__", "2");
3088 }
3089 }
3090 else if(CPU == "hexagonv3") {
3091 Builder.defineMacro("__HEXAGON_V3__");
3092 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3093 if(Opts.HexagonQdsp6Compat) {
3094 Builder.defineMacro("__QDSP6_V3__");
3095 Builder.defineMacro("__QDSP6_ARCH__", "3");
3096 }
3097 }
3098 else if(CPU == "hexagonv4") {
3099 Builder.defineMacro("__HEXAGON_V4__");
3100 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3101 if(Opts.HexagonQdsp6Compat) {
3102 Builder.defineMacro("__QDSP6_V4__");
3103 Builder.defineMacro("__QDSP6_ARCH__", "4");
3104 }
3105 }
3106}
3107
3108const char * const HexagonTargetInfo::GCCRegNames[] = {
3109 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3110 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3111 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3112 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3113 "p0", "p1", "p2", "p3",
3114 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3115};
3116
3117void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3118 unsigned &NumNames) const {
3119 Names = GCCRegNames;
3120 NumNames = llvm::array_lengthof(GCCRegNames);
3121}
3122
3123
3124const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3125 { { "sp" }, "r29" },
3126 { { "fp" }, "r30" },
3127 { { "lr" }, "r31" },
3128 };
3129
3130void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3131 unsigned &NumAliases) const {
3132 Aliases = GCCRegAliases;
3133 NumAliases = llvm::array_lengthof(GCCRegAliases);
3134}
3135
3136
3137const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3138#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3139#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3140 ALL_LANGUAGES },
3141#include "clang/Basic/BuiltinsHexagon.def"
3142};
3143}
3144
3145
Reid Spencer5f016e22007-07-11 17:01:13 +00003146namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003147class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003148 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3149 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003150 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003151public:
Eli Friedman01b86682008-08-20 07:28:14 +00003152 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3153 // FIXME: Support Sparc quad-precision long double?
Eli Friedmane6a24e82011-12-22 03:51:45 +00003154 BigEndian = false;
Eli Friedmaned855cb2008-08-21 00:13:15 +00003155 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Chris Lattner1932e122009-11-07 18:59:41 +00003156 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003157 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003158 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003159 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003160 bool Enabled) const {
3161 if (Name == "soft-float")
3162 Features[Name] = Enabled;
3163 else
3164 return false;
3165
3166 return true;
3167 }
3168 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3169 SoftFloat = false;
3170 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3171 if (Features[i] == "+soft-float")
3172 SoftFloat = true;
3173 }
Chris Lattner33328642009-03-20 15:52:06 +00003174 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003175 MacroBuilder &Builder) const {
3176 DefineStd(Builder, "sparc", Opts);
3177 Builder.defineMacro("__sparcv8");
3178 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003179
3180 if (SoftFloat)
3181 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003182 }
Douglas Gregore727d212012-01-30 06:38:25 +00003183
3184 virtual bool hasFeature(StringRef Feature) const {
3185 return llvm::StringSwitch<bool>(Feature)
3186 .Case("softfloat", SoftFloat)
3187 .Case("sparc", true)
3188 .Default(false);
3189 }
3190
Gabor Greif26658672008-02-21 16:29:08 +00003191 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3192 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003193 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003194 }
3195 virtual const char *getVAListDeclaration() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003196 return "typedef void* __builtin_va_list;";
Gabor Greif26658672008-02-21 16:29:08 +00003197 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003198 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003199 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003200 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003201 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003202 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003203 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003204 // FIXME: Implement!
3205 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003206 }
3207 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003208 // FIXME: Implement!
3209 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003210 }
3211};
3212
Chris Lattnere957f532009-01-27 01:58:38 +00003213const char * const SparcV8TargetInfo::GCCRegNames[] = {
3214 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3215 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3216 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3217 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3218};
3219
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003220void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003221 unsigned &NumNames) const {
3222 Names = GCCRegNames;
3223 NumNames = llvm::array_lengthof(GCCRegNames);
3224}
3225
3226const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003227 { { "g0" }, "r0" },
3228 { { "g1" }, "r1" },
3229 { { "g2" }, "r2" },
3230 { { "g3" }, "r3" },
3231 { { "g4" }, "r4" },
3232 { { "g5" }, "r5" },
3233 { { "g6" }, "r6" },
3234 { { "g7" }, "r7" },
3235 { { "o0" }, "r8" },
3236 { { "o1" }, "r9" },
3237 { { "o2" }, "r10" },
3238 { { "o3" }, "r11" },
3239 { { "o4" }, "r12" },
3240 { { "o5" }, "r13" },
3241 { { "o6", "sp" }, "r14" },
3242 { { "o7" }, "r15" },
3243 { { "l0" }, "r16" },
3244 { { "l1" }, "r17" },
3245 { { "l2" }, "r18" },
3246 { { "l3" }, "r19" },
3247 { { "l4" }, "r20" },
3248 { { "l5" }, "r21" },
3249 { { "l6" }, "r22" },
3250 { { "l7" }, "r23" },
3251 { { "i0" }, "r24" },
3252 { { "i1" }, "r25" },
3253 { { "i2" }, "r26" },
3254 { { "i3" }, "r27" },
3255 { { "i4" }, "r28" },
3256 { { "i5" }, "r29" },
3257 { { "i6", "fp" }, "r30" },
3258 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003259};
3260
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003261void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003262 unsigned &NumAliases) const {
3263 Aliases = GCCRegAliases;
3264 NumAliases = llvm::array_lengthof(GCCRegAliases);
3265}
Gabor Greif26658672008-02-21 16:29:08 +00003266} // end anonymous namespace.
3267
Eli Friedman01b86682008-08-20 07:28:14 +00003268namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003269class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3270public:
3271 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3272 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3273 SizeType = UnsignedInt;
3274 PtrDiffType = SignedInt;
3275 }
3276};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003277class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003278public:
3279 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003280 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003281 SizeType = UnsignedInt;
3282 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003283 }
3284};
3285} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003286
Chris Lattner2621fd12008-05-08 05:58:21 +00003287namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003288 class MSP430TargetInfo : public TargetInfo {
3289 static const char * const GCCRegNames[];
3290 public:
3291 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003292 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003293 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003294 IntWidth = 16; IntAlign = 16;
3295 LongWidth = 32; LongLongWidth = 64;
3296 LongAlign = LongLongAlign = 16;
3297 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003298 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003299 SizeType = UnsignedInt;
3300 IntMaxType = SignedLong;
3301 UIntMaxType = UnsignedLong;
3302 IntPtrType = SignedShort;
3303 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003304 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003305 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003306 }
3307 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003308 MacroBuilder &Builder) const {
3309 Builder.defineMacro("MSP430");
3310 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003311 // FIXME: defines for different 'flavours' of MCU
3312 }
3313 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3314 unsigned &NumRecords) const {
3315 // FIXME: Implement.
3316 Records = 0;
3317 NumRecords = 0;
3318 }
Douglas Gregore727d212012-01-30 06:38:25 +00003319 virtual bool hasFeature(StringRef Feature) const {
3320 return Feature == "msp430";
3321 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003322 virtual void getGCCRegNames(const char * const *&Names,
3323 unsigned &NumNames) const;
3324 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3325 unsigned &NumAliases) const {
3326 // No aliases.
3327 Aliases = 0;
3328 NumAliases = 0;
3329 }
3330 virtual bool validateAsmConstraint(const char *&Name,
3331 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003332 // No target constraints for now.
3333 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003334 }
3335 virtual const char *getClobbers() const {
3336 // FIXME: Is this really right?
3337 return "";
3338 }
3339 virtual const char *getVAListDeclaration() const {
3340 // FIXME: implement
Anton Korobeynikoveb716852009-05-08 18:24:57 +00003341 return "typedef char* __builtin_va_list;";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003342 }
3343 };
3344
3345 const char * const MSP430TargetInfo::GCCRegNames[] = {
3346 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3347 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3348 };
3349
3350 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3351 unsigned &NumNames) const {
3352 Names = GCCRegNames;
3353 NumNames = llvm::array_lengthof(GCCRegNames);
3354 }
3355}
3356
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003357namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003358
Mike Stump1eb44332009-09-09 15:08:12 +00003359 // LLVM and Clang cannot be used directly to output native binaries for
3360 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003361 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003362 //
3363 // TCE uses the llvm bitcode as input and uses it for generating customized
3364 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003365 // publicly available in http://tce.cs.tut.fi
3366
Eli Friedman209f5bb2011-10-07 19:51:42 +00003367 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3368 3, // opencl_global
3369 4, // opencl_local
3370 5 // opencl_constant
3371 };
3372
Eli Friedmanb63decf2009-08-19 20:47:07 +00003373 class TCETargetInfo : public TargetInfo{
3374 public:
3375 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3376 TLSSupported = false;
3377 IntWidth = 32;
3378 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003379 PointerWidth = 32;
3380 IntAlign = 32;
3381 LongAlign = LongLongAlign = 32;
3382 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003383 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003384 SizeType = UnsignedInt;
3385 IntMaxType = SignedLong;
3386 UIntMaxType = UnsignedLong;
3387 IntPtrType = SignedInt;
3388 PtrDiffType = SignedInt;
3389 FloatWidth = 32;
3390 FloatAlign = 32;
3391 DoubleWidth = 32;
3392 DoubleAlign = 32;
3393 LongDoubleWidth = 32;
3394 LongDoubleAlign = 32;
3395 FloatFormat = &llvm::APFloat::IEEEsingle;
3396 DoubleFormat = &llvm::APFloat::IEEEsingle;
3397 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003398 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3399 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003400 "f32:32:32-f64:32:32-v64:32:32-"
3401 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003402 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003403 }
3404
3405 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003406 MacroBuilder &Builder) const {
3407 DefineStd(Builder, "tce", Opts);
3408 Builder.defineMacro("__TCE__");
3409 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003410 }
Douglas Gregore727d212012-01-30 06:38:25 +00003411 virtual bool hasFeature(StringRef Feature) const {
3412 return Feature == "tce";
3413 }
3414
Eli Friedmanb63decf2009-08-19 20:47:07 +00003415 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3416 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003417 virtual const char *getClobbers() const {
3418 return "";
3419 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003420 virtual const char *getVAListDeclaration() const {
3421 return "typedef void* __builtin_va_list;";
3422 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003423 virtual void getGCCRegNames(const char * const *&Names,
3424 unsigned &NumNames) const {}
3425 virtual bool validateAsmConstraint(const char *&Name,
3426 TargetInfo::ConstraintInfo &info) const {
3427 return true;
3428 }
3429 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3430 unsigned &NumAliases) const {}
3431 };
3432}
3433
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003434namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003435class MipsTargetInfoBase : public TargetInfo {
3436 std::string CPU;
3437protected:
3438 std::string ABI;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003439public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003440 MipsTargetInfoBase(const std::string& triple, const std::string& ABIStr)
Akira Hatanaka148735e2011-11-05 01:48:34 +00003441 : TargetInfo(triple), ABI(ABIStr) {}
Eric Christophered734732010-03-02 02:41:08 +00003442 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003443 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003444 virtual bool setCPU(const std::string &Name) {
3445 CPU = Name;
3446 return true;
3447 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003448 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003449 Features[ABI] = true;
3450 Features[CPU] = true;
3451 }
3452 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003453 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003454 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003455 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003456 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3457 unsigned &NumRecords) const {
3458 // FIXME: Implement!
3459 }
Douglas Gregore727d212012-01-30 06:38:25 +00003460 virtual bool hasFeature(StringRef Feature) const {
3461 return Feature == "mips";
3462 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003463 virtual const char *getVAListDeclaration() const {
3464 return "typedef void* __builtin_va_list;";
3465 }
3466 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003467 unsigned &NumNames) const {
3468 static const char * const GCCRegNames[] = {
3469 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3470 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3471 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
3472 "$24", "$25", "$26", "$27", "$28", "$sp", "$fp", "$31",
3473 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3474 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3475 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3476 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
3477 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3478 "$fcc5","$fcc6","$fcc7"
3479 };
3480 Names = GCCRegNames;
3481 NumNames = llvm::array_lengthof(GCCRegNames);
3482 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003483 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003484 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003485 virtual bool validateAsmConstraint(const char *&Name,
3486 TargetInfo::ConstraintInfo &Info) const {
3487 switch (*Name) {
3488 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003489 return false;
3490
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003491 case 'r': // CPU registers.
3492 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3493 case 'y': // Equivalent to "r", backwards compatibility only.
3494 case 'f': // floating-point registers.
3495 Info.setAllowsRegister();
3496 return true;
3497 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003498 }
3499
3500 virtual const char *getClobbers() const {
3501 // FIXME: Implement!
3502 return "";
3503 }
3504};
3505
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003506class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003507public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003508 Mips32TargetInfoBase(const std::string& triple) :
Akira Hatanaka148735e2011-11-05 01:48:34 +00003509 MipsTargetInfoBase(triple, "o32") {
3510 SizeType = UnsignedInt;
3511 PtrDiffType = SignedInt;
3512 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003513 virtual bool setABI(const std::string &Name) {
3514 if ((Name == "o32") || (Name == "eabi")) {
3515 ABI = Name;
3516 return true;
3517 } else
3518 return false;
3519 }
3520 virtual void getArchDefines(const LangOptions &Opts,
3521 MacroBuilder &Builder) const {
Douglas Gregorc9a23712011-11-09 15:17:16 +00003522 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3523 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3524 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
3525
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003526 if (ABI == "o32") {
3527 Builder.defineMacro("__mips_o32");
3528 Builder.defineMacro("_ABIO32", "1");
3529 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3530 }
3531 else if (ABI == "eabi")
3532 Builder.defineMacro("__mips_eabi");
3533 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003534 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003535 }
3536 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3537 unsigned &NumAliases) const {
3538 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3539 { { "at" }, "$1" },
3540 { { "v0" }, "$2" },
3541 { { "v1" }, "$3" },
3542 { { "a0" }, "$4" },
3543 { { "a1" }, "$5" },
3544 { { "a2" }, "$6" },
3545 { { "a3" }, "$7" },
3546 { { "t0" }, "$8" },
3547 { { "t1" }, "$9" },
3548 { { "t2" }, "$10" },
3549 { { "t3" }, "$11" },
3550 { { "t4" }, "$12" },
3551 { { "t5" }, "$13" },
3552 { { "t6" }, "$14" },
3553 { { "t7" }, "$15" },
3554 { { "s0" }, "$16" },
3555 { { "s1" }, "$17" },
3556 { { "s2" }, "$18" },
3557 { { "s3" }, "$19" },
3558 { { "s4" }, "$20" },
3559 { { "s5" }, "$21" },
3560 { { "s6" }, "$22" },
3561 { { "s7" }, "$23" },
3562 { { "t8" }, "$24" },
3563 { { "t9" }, "$25" },
3564 { { "k0" }, "$26" },
3565 { { "k1" }, "$27" },
3566 { { "gp" }, "$28" },
3567 { { "sp" }, "$29" },
3568 { { "fp" }, "$30" },
3569 { { "ra" }, "$31" }
3570 };
3571 Aliases = GCCRegAliases;
3572 NumAliases = llvm::array_lengthof(GCCRegAliases);
3573 }
3574};
3575
3576class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3577public:
3578 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3579 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3580 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3581 }
3582 virtual void getTargetDefines(const LangOptions &Opts,
3583 MacroBuilder &Builder) const {
3584 DefineStd(Builder, "mips", Opts);
3585 Builder.defineMacro("_mips");
3586 DefineStd(Builder, "MIPSEB", Opts);
3587 Builder.defineMacro("_MIPSEB");
3588 Builder.defineMacro("__REGISTER_PREFIX__", "");
3589 getArchDefines(Opts, Builder);
3590 }
3591};
3592
3593class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3594public:
3595 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003596 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003597 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka619e8872011-06-02 00:09:17 +00003598 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003599 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003600 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003601 MacroBuilder &Builder) const {
3602 DefineStd(Builder, "mips", Opts);
3603 Builder.defineMacro("_mips");
3604 DefineStd(Builder, "MIPSEL", Opts);
3605 Builder.defineMacro("_MIPSEL");
3606 Builder.defineMacro("__REGISTER_PREFIX__", "");
3607 getArchDefines(Opts, Builder);
3608 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003609};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003610
3611class Mips64TargetInfoBase : public MipsTargetInfoBase {
3612 virtual void SetDescriptionString(const std::string &Name) = 0;
3613public:
3614 Mips64TargetInfoBase(const std::string& triple) :
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003615 MipsTargetInfoBase(triple, "n64") {
3616 LongWidth = LongAlign = 64;
3617 PointerWidth = PointerAlign = 64;
3618 LongDoubleWidth = LongDoubleAlign = 128;
3619 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003620 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003621 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003622 virtual bool setABI(const std::string &Name) {
3623 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003624
3625 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003626 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003627
3628 ABI = Name;
3629
3630 if (Name == "n32") {
3631 LongWidth = LongAlign = 32;
3632 PointerWidth = PointerAlign = 32;
3633 }
3634
3635 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003636 }
3637 virtual void getArchDefines(const LangOptions &Opts,
3638 MacroBuilder &Builder) const {
3639 if (ABI == "n32") {
3640 Builder.defineMacro("__mips_n32");
3641 Builder.defineMacro("_ABIN32", "2");
3642 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3643 }
3644 else if (ABI == "n64") {
3645 Builder.defineMacro("__mips_n64");
3646 Builder.defineMacro("_ABI64", "3");
3647 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3648 }
3649 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003650 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003651 }
3652 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3653 unsigned &NumAliases) const {
3654 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3655 { { "at" }, "$1" },
3656 { { "v0" }, "$2" },
3657 { { "v1" }, "$3" },
3658 { { "a0" }, "$4" },
3659 { { "a1" }, "$5" },
3660 { { "a2" }, "$6" },
3661 { { "a3" }, "$7" },
3662 { { "a4" }, "$8" },
3663 { { "a5" }, "$9" },
3664 { { "a6" }, "$10" },
3665 { { "a7" }, "$11" },
3666 { { "t0" }, "$12" },
3667 { { "t1" }, "$13" },
3668 { { "t2" }, "$14" },
3669 { { "t3" }, "$15" },
3670 { { "s0" }, "$16" },
3671 { { "s1" }, "$17" },
3672 { { "s2" }, "$18" },
3673 { { "s3" }, "$19" },
3674 { { "s4" }, "$20" },
3675 { { "s5" }, "$21" },
3676 { { "s6" }, "$22" },
3677 { { "s7" }, "$23" },
3678 { { "t8" }, "$24" },
3679 { { "t9" }, "$25" },
3680 { { "k0" }, "$26" },
3681 { { "k1" }, "$27" },
3682 { { "gp" }, "$28" },
3683 { { "sp" }, "$29" },
3684 { { "fp" }, "$30" },
3685 { { "ra" }, "$31" }
3686 };
3687 Aliases = GCCRegAliases;
3688 NumAliases = llvm::array_lengthof(GCCRegAliases);
3689 }
3690};
3691
3692class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3693 virtual void SetDescriptionString(const std::string &Name) {
3694 // Change DescriptionString only if ABI is n32.
3695 if (Name == "n32")
3696 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003697 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3698 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003699 }
3700public:
3701 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3702 // Default ABI is n64.
3703 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003704 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3705 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003706 }
3707 virtual void getTargetDefines(const LangOptions &Opts,
3708 MacroBuilder &Builder) const {
3709 DefineStd(Builder, "mips", Opts);
3710 Builder.defineMacro("_mips");
3711 DefineStd(Builder, "MIPSEB", Opts);
3712 Builder.defineMacro("_MIPSEB");
3713 Builder.defineMacro("__REGISTER_PREFIX__", "");
3714 getArchDefines(Opts, Builder);
3715 }
3716};
3717
3718class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3719 virtual void SetDescriptionString(const std::string &Name) {
3720 // Change DescriptionString only if ABI is n32.
3721 if (Name == "n32")
3722 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003723 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3724 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003725 }
3726public:
3727 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003728 // Default ABI is n64.
3729 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003730 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003731 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3732 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003733 }
3734 virtual void getTargetDefines(const LangOptions &Opts,
3735 MacroBuilder &Builder) const {
3736 DefineStd(Builder, "mips", Opts);
3737 Builder.defineMacro("_mips");
3738 DefineStd(Builder, "MIPSEL", Opts);
3739 Builder.defineMacro("_MIPSEL");
3740 Builder.defineMacro("__REGISTER_PREFIX__", "");
3741 getArchDefines(Opts, Builder);
3742 }
3743};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003744} // end anonymous namespace.
3745
Ivan Krasinef05abd2011-08-24 20:22:22 +00003746namespace {
3747class PNaClTargetInfo : public TargetInfo {
3748public:
3749 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003750 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003751 this->UserLabelPrefix = "";
3752 this->LongAlign = 32;
3753 this->LongWidth = 32;
3754 this->PointerAlign = 32;
3755 this->PointerWidth = 32;
3756 this->IntMaxType = TargetInfo::SignedLongLong;
3757 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3758 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003759 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003760 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003761 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003762 this->SizeType = TargetInfo::UnsignedInt;
3763 this->PtrDiffType = TargetInfo::SignedInt;
3764 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003765 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003766 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3767 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3768 }
3769
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003770 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003771 }
3772 virtual void getArchDefines(const LangOptions &Opts,
3773 MacroBuilder &Builder) const {
3774 Builder.defineMacro("__le32__");
3775 Builder.defineMacro("__pnacl__");
3776 }
3777 virtual void getTargetDefines(const LangOptions &Opts,
3778 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003779 DefineStd(Builder, "unix", Opts);
3780 Builder.defineMacro("__ELF__");
3781 if (Opts.POSIXThreads)
3782 Builder.defineMacro("_REENTRANT");
3783 if (Opts.CPlusPlus)
3784 Builder.defineMacro("_GNU_SOURCE");
3785
Ivan Krasinef05abd2011-08-24 20:22:22 +00003786 Builder.defineMacro("__native_client__");
3787 getArchDefines(Opts, Builder);
3788 }
Douglas Gregore727d212012-01-30 06:38:25 +00003789 virtual bool hasFeature(StringRef Feature) const {
3790 return Feature == "pnacl";
3791 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00003792 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3793 unsigned &NumRecords) const {
3794 }
3795 virtual const char *getVAListDeclaration() const {
Ivan Krasin68018db2011-09-20 14:56:54 +00003796 return "typedef int __builtin_va_list[4];";
Ivan Krasinef05abd2011-08-24 20:22:22 +00003797 }
3798 virtual void getGCCRegNames(const char * const *&Names,
3799 unsigned &NumNames) const;
3800 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3801 unsigned &NumAliases) const;
3802 virtual bool validateAsmConstraint(const char *&Name,
3803 TargetInfo::ConstraintInfo &Info) const {
3804 return false;
3805 }
3806
3807 virtual const char *getClobbers() const {
3808 return "";
3809 }
3810};
3811
3812void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
3813 unsigned &NumNames) const {
3814 Names = NULL;
3815 NumNames = 0;
3816}
3817
3818void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3819 unsigned &NumAliases) const {
3820 Aliases = NULL;
3821 NumAliases = 0;
3822}
3823} // end anonymous namespace.
3824
3825
Reid Spencer5f016e22007-07-11 17:01:13 +00003826//===----------------------------------------------------------------------===//
3827// Driver code
3828//===----------------------------------------------------------------------===//
3829
Daniel Dunbard58c03f2009-11-15 06:48:46 +00003830static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003831 llvm::Triple Triple(T);
3832 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00003833
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003834 switch (Triple.getArch()) {
3835 default:
3836 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00003837
Tony Linthicum96319392011-12-12 21:14:55 +00003838 case llvm::Triple::hexagon:
3839 return new HexagonTargetInfo(T);
3840
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003841 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00003842 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003843 if (Triple.isOSDarwin())
3844 return new DarwinARMTargetInfo(T);
3845
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003846 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00003847 case llvm::Triple::Linux:
3848 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003849 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00003850 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003851 case llvm::Triple::NetBSD:
3852 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00003853 case llvm::Triple::RTEMS:
3854 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003855 default:
3856 return new ARMTargetInfo(T);
3857 }
Eli Friedman61538a72008-05-20 14:21:01 +00003858
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003859 case llvm::Triple::msp430:
3860 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00003861
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003862 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003863 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003864 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003865 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003866 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003867 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003868 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003869 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003870 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003871 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003872 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003873 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00003874 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003875
3876 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003877 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003878 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003879 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003880 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003881 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003882 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003883 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003884 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003885 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003886 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003887 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00003888 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003889
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003890 case llvm::Triple::mips64:
3891 switch (os) {
3892 case llvm::Triple::Linux:
3893 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
3894 case llvm::Triple::RTEMS:
3895 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
3896 case llvm::Triple::FreeBSD:
3897 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
3898 case llvm::Triple::NetBSD:
3899 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
3900 default:
3901 return new Mips64EBTargetInfo(T);
3902 }
3903
3904 case llvm::Triple::mips64el:
3905 switch (os) {
3906 case llvm::Triple::Linux:
3907 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
3908 case llvm::Triple::RTEMS:
3909 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
3910 case llvm::Triple::FreeBSD:
3911 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
3912 case llvm::Triple::NetBSD:
3913 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
3914 default:
3915 return new Mips64ELTargetInfo(T);
3916 }
3917
Ivan Krasinef05abd2011-08-24 20:22:22 +00003918 case llvm::Triple::le32:
3919 switch (os) {
3920 case llvm::Triple::NativeClient:
3921 return new PNaClTargetInfo(T);
3922 default:
3923 return NULL;
3924 }
3925
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003926 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003927 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00003928 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003929 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003930 case llvm::Triple::Linux:
3931 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003932 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003933 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003934 case llvm::Triple::NetBSD:
3935 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
3936 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003937 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003938 default:
3939 return new PPC32TargetInfo(T);
3940 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003941
3942 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003943 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00003944 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003945 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003946 case llvm::Triple::Linux:
3947 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003948 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00003949 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003950 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00003951 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003952 case llvm::Triple::NetBSD:
3953 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
3954 default:
3955 return new PPC64TargetInfo(T);
3956 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003957
Justin Holewinski285dc652011-04-20 19:34:15 +00003958 case llvm::Triple::ptx32:
3959 return new PTX32TargetInfo(T);
3960 case llvm::Triple::ptx64:
3961 return new PTX64TargetInfo(T);
3962
Chris Lattner9cbeb632010-03-06 21:21:27 +00003963 case llvm::Triple::mblaze:
3964 return new MBlazeTargetInfo(T);
3965
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003966 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003967 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00003968 case llvm::Triple::Linux:
3969 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003970 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003971 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003972 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003973 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003974 case llvm::Triple::NetBSD:
3975 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
3976 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00003977 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00003978 default:
3979 return new SparcV8TargetInfo(T);
3980 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003981
John Thompson3f6918a2009-11-19 17:18:50 +00003982 // FIXME: Need a real SPU target.
3983 case llvm::Triple::cellspu:
3984 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
3985
Eli Friedmanb63decf2009-08-19 20:47:07 +00003986 case llvm::Triple::tce:
3987 return new TCETargetInfo(T);
3988
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003989 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00003990 if (Triple.isOSDarwin())
3991 return new DarwinI386TargetInfo(T);
3992
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003993 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003994 case llvm::Triple::AuroraUX:
3995 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00003996 case llvm::Triple::Linux:
3997 return new LinuxTargetInfo<X86_32TargetInfo>(T);
3998 case llvm::Triple::DragonFly:
3999 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4000 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004001 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004002 case llvm::Triple::OpenBSD:
4003 return new OpenBSDI386TargetInfo(T);
4004 case llvm::Triple::FreeBSD:
4005 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004006 case llvm::Triple::Minix:
4007 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004008 case llvm::Triple::Solaris:
4009 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4010 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004011 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004012 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004013 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004014 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004015 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004016 case llvm::Triple::Haiku:
4017 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004018 case llvm::Triple::RTEMS:
4019 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004020 default:
4021 return new X86_32TargetInfo(T);
4022 }
4023
4024 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004025 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4026 return new DarwinX86_64TargetInfo(T);
4027
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004028 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004029 case llvm::Triple::AuroraUX:
4030 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004031 case llvm::Triple::Linux:
4032 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004033 case llvm::Triple::DragonFly:
4034 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004035 case llvm::Triple::NetBSD:
4036 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4037 case llvm::Triple::OpenBSD:
4038 return new OpenBSDX86_64TargetInfo(T);
4039 case llvm::Triple::FreeBSD:
4040 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4041 case llvm::Triple::Solaris:
4042 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004043 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004044 return new MinGWX86_64TargetInfo(T);
4045 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004046 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004047 default:
4048 return new X86_64TargetInfo(T);
4049 }
4050 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004051}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004052
4053/// CreateTargetInfo - Return the target info object for the specified target
4054/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004055TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004056 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004057 llvm::Triple Triple(Opts.Triple);
4058
4059 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004060 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004061 if (!Target) {
4062 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4063 return 0;
4064 }
4065
Daniel Dunbareac7c532009-12-18 18:42:37 +00004066 // Set the target CPU if specified.
4067 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
4068 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
4069 return 0;
4070 }
4071
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004072 // Set the target ABI if specified.
4073 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
4074 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
4075 return 0;
4076 }
4077
Charles Davis98b7c5c2010-06-11 01:06:47 +00004078 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00004079 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00004080 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
4081 return 0;
4082 }
4083
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004084 // Compute the default target features, we need the target to handle this
4085 // because features may have dependencies on one another.
4086 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004087 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004088
4089 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004090 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004091 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4092 ie = Opts.Features.end(); it != ie; ++it) {
4093 const char *Name = it->c_str();
4094
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004095 if (Name[0] != '+')
4096 continue;
4097
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004098 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004099 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4100 Diags.Report(diag::err_target_invalid_feature) << Name;
4101 return 0;
4102 }
4103 }
4104
4105 // Then the disables.
4106 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4107 ie = Opts.Features.end(); it != ie; ++it) {
4108 const char *Name = it->c_str();
4109
4110 if (Name[0] == '+')
4111 continue;
4112
4113 // Apply the feature via the target.
4114 if (Name[0] != '-' ||
4115 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004116 Diags.Report(diag::err_target_invalid_feature) << Name;
4117 return 0;
4118 }
4119 }
4120
4121 // Add the features to the compile options.
4122 //
4123 // FIXME: If we are completely confident that we have the right set, we only
4124 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004125 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004126 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4127 ie = Features.end(); it != ie; ++it)
Benjamin Kramer713575a2012-03-05 15:10:44 +00004128 Opts.Features.push_back((it->second ? "+" : "-") + it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004129 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004130
4131 return Target.take();
4132}