blob: 036514800d662c9c47e5174d7df559aa77324d45 [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__");
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000319 if (Triple.getEnvironment() == llvm::Triple::ANDROIDEABI)
320 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000321 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000322 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000323 if (Opts.CPlusPlus)
324 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 }
326public:
Mike Stump1eb44332009-09-09 15:08:12 +0000327 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 : OSTargetInfo<Target>(triple) {
329 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000330 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000332
333 virtual const char *getStaticInitSectionSpecifier() const {
334 return ".text.startup";
335 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000336};
337
Chris Lattnerb62bb282009-07-13 20:29:08 +0000338// NetBSD Target
339template<typename Target>
340class NetBSDTargetInfo : public OSTargetInfo<Target> {
341protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000342 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000343 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000344 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000345 Builder.defineMacro("__NetBSD__");
346 Builder.defineMacro("__unix__");
347 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000348 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000349 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000350 }
351public:
Mike Stump1eb44332009-09-09 15:08:12 +0000352 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 : OSTargetInfo<Target>(triple) {
354 this->UserLabelPrefix = "";
355 }
356};
357
Torok Edwin5f6c1942009-06-30 17:10:35 +0000358// OpenBSD Target
359template<typename Target>
360class OpenBSDTargetInfo : public OSTargetInfo<Target> {
361protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000362 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000363 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000364 // OpenBSD defines; list based off of gcc output
365
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 Builder.defineMacro("__OpenBSD__");
367 DefineStd(Builder, "unix", Opts);
368 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000369 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000370 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000371 }
372public:
Mike Stump1eb44332009-09-09 15:08:12 +0000373 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000374 : OSTargetInfo<Target>(triple) {
375 this->UserLabelPrefix = "";
376
377 llvm::Triple Triple(triple);
378 switch (Triple.getArch()) {
379 default:
380 case llvm::Triple::x86:
381 case llvm::Triple::x86_64:
382 case llvm::Triple::arm:
383 case llvm::Triple::sparc:
384 this->MCountName = "__mcount";
385 break;
386 case llvm::Triple::mips64:
387 case llvm::Triple::mips64el:
388 case llvm::Triple::ppc:
389 case llvm::Triple::sparcv9:
390 this->MCountName = "_mcount";
391 break;
392 }
393 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000394};
395
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000396// PSP Target
397template<typename Target>
398class PSPTargetInfo : public OSTargetInfo<Target> {
399protected:
400 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000401 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000402 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000403 Builder.defineMacro("PSP");
404 Builder.defineMacro("_PSP");
405 Builder.defineMacro("__psp__");
406 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000407 }
408public:
409 PSPTargetInfo(const std::string& triple)
410 : OSTargetInfo<Target>(triple) {
411 this->UserLabelPrefix = "";
412 }
413};
414
John Thompson3f6918a2009-11-19 17:18:50 +0000415// PS3 PPU Target
416template<typename Target>
417class PS3PPUTargetInfo : public OSTargetInfo<Target> {
418protected:
419 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000420 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000421 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000422 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000423 Builder.defineMacro("__PPU__");
424 Builder.defineMacro("__CELLOS_LV2__");
425 Builder.defineMacro("__ELF__");
426 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000427 Builder.defineMacro("_ARCH_PPC64");
428 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000429 }
430public:
431 PS3PPUTargetInfo(const std::string& triple)
432 : OSTargetInfo<Target>(triple) {
433 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000434 this->LongWidth = this->LongAlign = 32;
435 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000436 this->IntMaxType = TargetInfo::SignedLongLong;
437 this->UIntMaxType = TargetInfo::UnsignedLongLong;
438 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000439 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000440 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 +0000441 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000442 }
443};
444
445// FIXME: Need a real SPU target.
446// PS3 SPU Target
447template<typename Target>
448class PS3SPUTargetInfo : public OSTargetInfo<Target> {
449protected:
450 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000451 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000452 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000453 Builder.defineMacro("__SPU__");
454 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000455 }
456public:
457 PS3SPUTargetInfo(const std::string& triple)
458 : OSTargetInfo<Target>(triple) {
459 this->UserLabelPrefix = "";
460 }
461};
462
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000463// AuroraUX target
464template<typename Target>
465class AuroraUXTargetInfo : public OSTargetInfo<Target> {
466protected:
467 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000468 MacroBuilder &Builder) const {
469 DefineStd(Builder, "sun", Opts);
470 DefineStd(Builder, "unix", Opts);
471 Builder.defineMacro("__ELF__");
472 Builder.defineMacro("__svr4__");
473 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000474 }
475public:
476 AuroraUXTargetInfo(const std::string& triple)
477 : OSTargetInfo<Target>(triple) {
478 this->UserLabelPrefix = "";
479 this->WCharType = this->SignedLong;
480 // FIXME: WIntType should be SignedLong
481 }
482};
483
Torok Edwin5f6c1942009-06-30 17:10:35 +0000484// Solaris target
485template<typename Target>
486class SolarisTargetInfo : public OSTargetInfo<Target> {
487protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000488 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000489 MacroBuilder &Builder) const {
490 DefineStd(Builder, "sun", Opts);
491 DefineStd(Builder, "unix", Opts);
492 Builder.defineMacro("__ELF__");
493 Builder.defineMacro("__svr4__");
494 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000495 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
496 // newer, but to 500 for everything else. feature_test.h has a check to
497 // ensure that you are not using C99 with an old version of X/Open or C89
498 // with a new version.
499 if (Opts.C99 || Opts.C11)
500 Builder.defineMacro("_XOPEN_SOURCE", "600");
501 else
502 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000503 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000504 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000505 Builder.defineMacro("_LARGEFILE_SOURCE");
506 Builder.defineMacro("_LARGEFILE64_SOURCE");
507 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000508 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000509 }
510public:
Mike Stump1eb44332009-09-09 15:08:12 +0000511 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000512 : OSTargetInfo<Target>(triple) {
513 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000514 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000515 // FIXME: WIntType should be SignedLong
516 }
517};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000518
519// Windows target
520template<typename Target>
521class WindowsTargetInfo : public OSTargetInfo<Target> {
522protected:
523 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
524 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000525 Builder.defineMacro("_WIN32");
526 }
527 void getVisualStudioDefines(const LangOptions &Opts,
528 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000529 if (Opts.CPlusPlus) {
530 if (Opts.RTTI)
531 Builder.defineMacro("_CPPRTTI");
532
533 if (Opts.Exceptions)
534 Builder.defineMacro("_CPPUNWIND");
535 }
536
537 if (!Opts.CharIsSigned)
538 Builder.defineMacro("_CHAR_UNSIGNED");
539
540 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
541 // but it works for now.
542 if (Opts.POSIXThreads)
543 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000544
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000546 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000547
Francois Pichet62ec1f22011-09-17 17:15:52 +0000548 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000549 Builder.defineMacro("_MSC_EXTENSIONS");
550
551 if (Opts.CPlusPlus0x) {
552 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
553 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
554 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
555 }
556 }
557
558 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000559 }
560
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000561public:
562 WindowsTargetInfo(const std::string &triple)
563 : OSTargetInfo<Target>(triple) {}
564};
565
Mike Stump1eb44332009-09-09 15:08:12 +0000566} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000567
Chris Lattnerd29b6302008-10-05 21:50:58 +0000568//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000569// Specific target implementations.
570//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000571
Eli Friedmane4277982008-08-20 23:11:40 +0000572namespace {
573// PPC abstract base class
574class PPCTargetInfo : public TargetInfo {
575 static const Builtin::Info BuiltinInfo[];
576 static const char * const GCCRegNames[];
577 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000578 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000579public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000580 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
581 LongDoubleWidth = LongDoubleAlign = 128;
582 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
583 }
Eli Friedman15b91762009-06-05 07:05:05 +0000584
Hal Finkel02a84272012-06-11 22:35:19 +0000585 virtual bool setCPU(const std::string &Name) {
586 bool CPUKnown = llvm::StringSwitch<bool>(Name)
587 .Case("generic", true)
588 .Case("440", true)
589 .Case("450", true)
590 .Case("601", true)
591 .Case("602", true)
592 .Case("603", true)
593 .Case("603e", true)
594 .Case("603ev", true)
595 .Case("604", true)
596 .Case("604e", true)
597 .Case("620", true)
598 .Case("g3", true)
599 .Case("7400", true)
600 .Case("g4", true)
601 .Case("7450", true)
602 .Case("g4+", true)
603 .Case("750", true)
604 .Case("970", true)
605 .Case("g5", true)
606 .Case("a2", true)
607 .Case("pwr6", true)
608 .Case("pwr7", true)
609 .Case("ppc", true)
610 .Case("ppc64", true)
611 .Default(false);
612
613 if (CPUKnown)
614 CPU = Name;
615
616 return CPUKnown;
617 }
618
Eli Friedmane4277982008-08-20 23:11:40 +0000619 virtual void getTargetBuiltins(const Builtin::Info *&Records,
620 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000621 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000622 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000623 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000624
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000625 virtual bool isCLZForZeroUndef() const { return false; }
626
Chris Lattner33328642009-03-20 15:52:06 +0000627 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000628 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000629
Douglas Gregore727d212012-01-30 06:38:25 +0000630 virtual bool hasFeature(StringRef Feature) const;
631
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000632 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000633 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000634 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000635 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000636 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000637 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000638 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000639 default: return false;
640 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000641 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000642 case 'b': // Base register
643 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000644 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000645 break;
646 // FIXME: The following are added to allow parsing.
647 // I just took a guess at what the actions should be.
648 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000649 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000650 case 'v': // Altivec vector register
651 Info.setAllowsRegister();
652 break;
653 case 'w':
654 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000655 case 'd':// VSX vector register to hold vector double data
656 case 'f':// VSX vector register to hold vector float data
657 case 's':// VSX vector register to hold scalar float data
658 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000659 break;
660 default:
661 return false;
662 }
663 Info.setAllowsRegister();
664 Name++; // Skip over 'w'.
665 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000666 case 'h': // `MQ', `CTR', or `LINK' register
667 case 'q': // `MQ' register
668 case 'c': // `CTR' register
669 case 'l': // `LINK' register
670 case 'x': // `CR' register (condition register) number 0
671 case 'y': // `CR' register (condition register)
672 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000673 Info.setAllowsRegister();
674 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000675 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000676 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000677 // (use `L' instead for SImode constants)
678 case 'K': // Unsigned 16-bit constant
679 case 'L': // Signed 16-bit constant shifted left 16 bits
680 case 'M': // Constant larger than 31
681 case 'N': // Exact power of 2
682 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000683 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000684 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000685 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000686 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000687 break;
688 case 'm': // Memory operand. Note that on PowerPC targets, m can
689 // include addresses that update the base register. It
690 // is therefore only safe to use `m' in an asm statement
691 // if that asm statement accesses the operand exactly once.
692 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000693 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000694 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000695 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000696 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000697 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
698 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000699 // register to be updated.
700 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000701 if (Name[1] != 's')
702 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000703 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000704 // include any automodification of the base register. Unlike
705 // `m', this constraint can be used in asm statements that
706 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000707 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000708 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000709 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000710 break;
711 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000712 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000713 case 'Z': // Memory operand that is an indexed or indirect from a
714 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000715 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000716 Info.setAllowsMemory();
717 Info.setAllowsRegister();
718 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000719 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000720 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000721 // register (`p' is preferable for asm statements)
722 case 'S': // Constant suitable as a 64-bit mask operand
723 case 'T': // Constant suitable as a 32-bit mask operand
724 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000725 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000726 // instructions
727 case 'W': // Vector constant that does not require memory
728 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000729 break;
730 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000731 }
John Thompson8e6065a2010-06-24 22:44:13 +0000732 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000733 }
Eli Friedmane4277982008-08-20 23:11:40 +0000734 virtual const char *getClobbers() const {
735 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000736 }
Eli Friedmane4277982008-08-20 23:11:40 +0000737};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000738
Eli Friedmane4277982008-08-20 23:11:40 +0000739const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000740#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000741#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000742 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000743#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000744};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000745
746
Chris Lattnerc0f59212009-03-02 22:27:17 +0000747/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
748/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000749void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000750 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000751 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000752 Builder.defineMacro("__ppc__");
753 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000754 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000755 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000756 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000757 Builder.defineMacro("_ARCH_PPC64");
758 Builder.defineMacro("_LP64");
759 Builder.defineMacro("__LP64__");
Chris Lattnere03ae302010-02-16 18:14:57 +0000760 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000761 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000762 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000763 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000764 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000765
Chris Lattnerc0f59212009-03-02 22:27:17 +0000766 // Target properties.
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000767 if (getTriple().getOS() != llvm::Triple::NetBSD)
768 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000769 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000770
Chris Lattnerc0f59212009-03-02 22:27:17 +0000771 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000772 Builder.defineMacro("__NATURAL_ALIGNMENT__");
773 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000774
Chris Lattnerc0f59212009-03-02 22:27:17 +0000775 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000776 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000777
John Thompson3f6918a2009-11-19 17:18:50 +0000778 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000779 Builder.defineMacro("__VEC__", "10206");
780 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000781 }
Hal Finkel02a84272012-06-11 22:35:19 +0000782
783 // CPU identification.
784 if (CPU == "440") {
785 Builder.defineMacro("_ARCH_440");
786 } else if (CPU == "450") {
787 Builder.defineMacro("_ARCH_440");
788 Builder.defineMacro("_ARCH_450");
789 } else if (CPU == "970") {
790 Builder.defineMacro("_ARCH_970");
791 } else if (CPU == "pwr6") {
792 Builder.defineMacro("_ARCH_PWR6");
793 } else if (CPU == "pwr7") {
794 Builder.defineMacro("_ARCH_PWR7");
795 }
Chris Lattnerc0f59212009-03-02 22:27:17 +0000796}
797
Douglas Gregore727d212012-01-30 06:38:25 +0000798bool PPCTargetInfo::hasFeature(StringRef Feature) const {
799 return Feature == "powerpc";
800}
Chris Lattner393ff042008-04-21 18:56:49 +0000801
Douglas Gregore727d212012-01-30 06:38:25 +0000802
Eli Friedmane4277982008-08-20 23:11:40 +0000803const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +0000804 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
805 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
806 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
807 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
808 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
809 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
810 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
811 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +0000812 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000813 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +0000814 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +0000815 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
816 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
817 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
818 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +0000819 "vrsave", "vscr",
820 "spe_acc", "spefscr",
821 "sfp"
822};
Reid Spencer5f016e22007-07-11 17:01:13 +0000823
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000824void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000825 unsigned &NumNames) const {
826 Names = GCCRegNames;
827 NumNames = llvm::array_lengthof(GCCRegNames);
828}
Reid Spencer5f016e22007-07-11 17:01:13 +0000829
Eli Friedmane4277982008-08-20 23:11:40 +0000830const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
831 // While some of these aliases do map to different registers
832 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000833 { { "0" }, "r0" },
834 { { "1"}, "r1" },
835 { { "2" }, "r2" },
836 { { "3" }, "r3" },
837 { { "4" }, "r4" },
838 { { "5" }, "r5" },
839 { { "6" }, "r6" },
840 { { "7" }, "r7" },
841 { { "8" }, "r8" },
842 { { "9" }, "r9" },
843 { { "10" }, "r10" },
844 { { "11" }, "r11" },
845 { { "12" }, "r12" },
846 { { "13" }, "r13" },
847 { { "14" }, "r14" },
848 { { "15" }, "r15" },
849 { { "16" }, "r16" },
850 { { "17" }, "r17" },
851 { { "18" }, "r18" },
852 { { "19" }, "r19" },
853 { { "20" }, "r20" },
854 { { "21" }, "r21" },
855 { { "22" }, "r22" },
856 { { "23" }, "r23" },
857 { { "24" }, "r24" },
858 { { "25" }, "r25" },
859 { { "26" }, "r26" },
860 { { "27" }, "r27" },
861 { { "28" }, "r28" },
862 { { "29" }, "r29" },
863 { { "30" }, "r30" },
864 { { "31" }, "r31" },
865 { { "fr0" }, "f0" },
866 { { "fr1" }, "f1" },
867 { { "fr2" }, "f2" },
868 { { "fr3" }, "f3" },
869 { { "fr4" }, "f4" },
870 { { "fr5" }, "f5" },
871 { { "fr6" }, "f6" },
872 { { "fr7" }, "f7" },
873 { { "fr8" }, "f8" },
874 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +0000875 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +0000876 { { "fr11" }, "f11" },
877 { { "fr12" }, "f12" },
878 { { "fr13" }, "f13" },
879 { { "fr14" }, "f14" },
880 { { "fr15" }, "f15" },
881 { { "fr16" }, "f16" },
882 { { "fr17" }, "f17" },
883 { { "fr18" }, "f18" },
884 { { "fr19" }, "f19" },
885 { { "fr20" }, "f20" },
886 { { "fr21" }, "f21" },
887 { { "fr22" }, "f22" },
888 { { "fr23" }, "f23" },
889 { { "fr24" }, "f24" },
890 { { "fr25" }, "f25" },
891 { { "fr26" }, "f26" },
892 { { "fr27" }, "f27" },
893 { { "fr28" }, "f28" },
894 { { "fr29" }, "f29" },
895 { { "fr30" }, "f30" },
896 { { "fr31" }, "f31" },
897 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +0000898};
899
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000900void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000901 unsigned &NumAliases) const {
902 Aliases = GCCRegAliases;
903 NumAliases = llvm::array_lengthof(GCCRegAliases);
904}
905} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +0000906
907namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000908class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000909public:
Chris Lattnere03ae302010-02-16 18:14:57 +0000910 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +0000911 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 +0000912 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +0000913
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000914 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000915 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000916 case llvm::Triple::FreeBSD:
917 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000918 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +0000919 PtrDiffType = SignedInt;
920 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000921 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +0000922 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +0000923 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +0000924 }
Roman Divackye3d175d2012-03-13 16:53:54 +0000925
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000926 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
927 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +0000928 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000929 }
Roman Divackyc81f2a22011-01-06 08:27:10 +0000930 }
931
Meador Ingec5613b22012-06-16 03:34:49 +0000932 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000933 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +0000934 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000935 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000936};
937} // end anonymous namespace.
938
939namespace {
Eli Friedmane4277982008-08-20 23:11:40 +0000940class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +0000941public:
Eli Friedmane4277982008-08-20 23:11:40 +0000942 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +0000943 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +0000944 IntMaxType = SignedLong;
945 UIntMaxType = UnsignedLong;
946 Int64Type = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +0000947 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 +0000948 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Roman Divackye3d175d2012-03-13 16:53:54 +0000949
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000950 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
951 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +0000952 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +0000953 }
Chris Lattnerf291b102008-05-09 06:17:04 +0000954 }
Meador Ingec5613b22012-06-16 03:34:49 +0000955 virtual BuiltinVaListKind getBuiltinVaListKind() const {
956 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000957 }
Eli Friedmane4277982008-08-20 23:11:40 +0000958};
959} // end anonymous namespace.
960
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000961
962namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +0000963class DarwinPPC32TargetInfo :
964 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000965public:
Roman Divackyc81f2a22011-01-06 08:27:10 +0000966 DarwinPPC32TargetInfo(const std::string& triple)
967 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000968 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +0000969 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000970 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000971 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +0000972 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
973 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +0000974 }
Meador Ingec5613b22012-06-16 03:34:49 +0000975 virtual BuiltinVaListKind getBuiltinVaListKind() const {
976 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000977 }
978};
979
980class DarwinPPC64TargetInfo :
981 public DarwinTargetInfo<PPC64TargetInfo> {
982public:
983 DarwinPPC64TargetInfo(const std::string& triple)
984 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
985 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +0000986 SuitableAlign = 128;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +0000987 }
988};
989} // end anonymous namespace.
990
Reid Spencer5f016e22007-07-11 17:01:13 +0000991namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +0000992 static const unsigned NVPTXAddrSpaceMap[] = {
993 1, // opencl_global
994 3, // opencl_local
995 4, // opencl_constant
996 1, // cuda_device
997 4, // cuda_constant
998 3, // cuda_shared
999 };
1000 class NVPTXTargetInfo : public TargetInfo {
1001 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001002 static const Builtin::Info BuiltinInfo[];
1003 std::vector<llvm::StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001004 public:
1005 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1006 BigEndian = false;
1007 TLSSupported = false;
1008 LongWidth = LongAlign = 64;
1009 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001010 // Define available target features
1011 // These must be defined in sorted order!
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001012 }
1013 virtual void getTargetDefines(const LangOptions &Opts,
1014 MacroBuilder &Builder) const {
1015 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001016 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001017 }
1018 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1019 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001020 Records = BuiltinInfo;
1021 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001022 }
1023 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001024 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001025 }
1026
1027 virtual void getGCCRegNames(const char * const *&Names,
1028 unsigned &NumNames) const;
1029 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1030 unsigned &NumAliases) const {
1031 // No aliases.
1032 Aliases = 0;
1033 NumAliases = 0;
1034 }
1035 virtual bool validateAsmConstraint(const char *&Name,
1036 TargetInfo::ConstraintInfo &info) const {
1037 // FIXME: implement
1038 return true;
1039 }
1040 virtual const char *getClobbers() const {
1041 // FIXME: Is this really right?
1042 return "";
1043 }
Meador Ingec5613b22012-06-16 03:34:49 +00001044 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001045 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001046 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001047 }
1048 virtual bool setCPU(const std::string &Name) {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001049 return Name == "sm_10" || Name == "sm_13" || Name == "sm_20";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001050 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001051 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1052 StringRef Name,
1053 bool Enabled) const;
1054 };
1055
1056 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1057#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1058#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1059 ALL_LANGUAGES },
1060#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001061 };
1062
1063 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1064 "r0"
1065 };
1066
1067 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1068 unsigned &NumNames) const {
1069 Names = GCCRegNames;
1070 NumNames = llvm::array_lengthof(GCCRegNames);
1071 }
1072
Justin Holewinski2c585b92012-05-24 17:43:12 +00001073 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1074 StringRef Name,
1075 bool Enabled) const {
1076 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1077 Name)) {
1078 Features[Name] = Enabled;
1079 return true;
1080 } else {
1081 return false;
1082 }
1083 }
1084
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001085 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1086 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001087 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001088 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001089 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001090 DescriptionString
1091 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1092 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1093 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001094 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001095 };
1096
1097 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1098 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001099 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001100 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001101 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001102 DescriptionString
1103 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1104 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1105 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001106 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001107 };
1108}
1109
1110namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001111// MBlaze abstract base class
1112class MBlazeTargetInfo : public TargetInfo {
1113 static const char * const GCCRegNames[];
1114 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1115
1116public:
1117 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001118 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001119 }
1120
1121 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1122 unsigned &NumRecords) const {
1123 // FIXME: Implement.
1124 Records = 0;
1125 NumRecords = 0;
1126 }
1127
1128 virtual void getTargetDefines(const LangOptions &Opts,
1129 MacroBuilder &Builder) const;
1130
Douglas Gregore727d212012-01-30 06:38:25 +00001131 virtual bool hasFeature(StringRef Feature) const {
1132 return Feature == "mblaze";
1133 }
1134
Meador Ingec5613b22012-06-16 03:34:49 +00001135 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1136 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001137 }
1138 virtual const char *getTargetPrefix() const {
1139 return "mblaze";
1140 }
1141 virtual void getGCCRegNames(const char * const *&Names,
1142 unsigned &NumNames) const;
1143 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1144 unsigned &NumAliases) const;
1145 virtual bool validateAsmConstraint(const char *&Name,
1146 TargetInfo::ConstraintInfo &Info) const {
1147 switch (*Name) {
1148 default: return false;
1149 case 'O': // Zero
1150 return true;
1151 case 'b': // Base register
1152 case 'f': // Floating point register
1153 Info.setAllowsRegister();
1154 return true;
1155 }
1156 }
1157 virtual const char *getClobbers() const {
1158 return "";
1159 }
1160};
1161
1162/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1163/// #defines that are not tied to a specific subtarget.
1164void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1165 MacroBuilder &Builder) const {
1166 // Target identification.
1167 Builder.defineMacro("__microblaze__");
1168 Builder.defineMacro("_ARCH_MICROBLAZE");
1169 Builder.defineMacro("__MICROBLAZE__");
1170
1171 // Target properties.
1172 Builder.defineMacro("_BIG_ENDIAN");
1173 Builder.defineMacro("__BIG_ENDIAN__");
1174
1175 // Subtarget options.
1176 Builder.defineMacro("__REGISTER_PREFIX__", "");
1177}
1178
1179
1180const char * const MBlazeTargetInfo::GCCRegNames[] = {
1181 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1182 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1183 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1184 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1185 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1186 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1187 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1188 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1189 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1190 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1191};
1192
1193void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1194 unsigned &NumNames) const {
1195 Names = GCCRegNames;
1196 NumNames = llvm::array_lengthof(GCCRegNames);
1197}
1198
1199const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1200 { {"f0"}, "r0" },
1201 { {"f1"}, "r1" },
1202 { {"f2"}, "r2" },
1203 { {"f3"}, "r3" },
1204 { {"f4"}, "r4" },
1205 { {"f5"}, "r5" },
1206 { {"f6"}, "r6" },
1207 { {"f7"}, "r7" },
1208 { {"f8"}, "r8" },
1209 { {"f9"}, "r9" },
1210 { {"f10"}, "r10" },
1211 { {"f11"}, "r11" },
1212 { {"f12"}, "r12" },
1213 { {"f13"}, "r13" },
1214 { {"f14"}, "r14" },
1215 { {"f15"}, "r15" },
1216 { {"f16"}, "r16" },
1217 { {"f17"}, "r17" },
1218 { {"f18"}, "r18" },
1219 { {"f19"}, "r19" },
1220 { {"f20"}, "r20" },
1221 { {"f21"}, "r21" },
1222 { {"f22"}, "r22" },
1223 { {"f23"}, "r23" },
1224 { {"f24"}, "r24" },
1225 { {"f25"}, "r25" },
1226 { {"f26"}, "r26" },
1227 { {"f27"}, "r27" },
1228 { {"f28"}, "r28" },
1229 { {"f29"}, "r29" },
1230 { {"f30"}, "r30" },
1231 { {"f31"}, "r31" },
1232};
1233
1234void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1235 unsigned &NumAliases) const {
1236 Aliases = GCCRegAliases;
1237 NumAliases = llvm::array_lengthof(GCCRegAliases);
1238}
1239} // end anonymous namespace.
1240
1241namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001242// Namespace for x86 abstract base class
1243const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001244#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001245#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001246 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001247#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001248};
Eli Friedman61538a72008-05-20 14:21:01 +00001249
Nuno Lopes2550d702009-12-23 17:49:57 +00001250static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001251 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1252 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001253 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001254 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1255 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1256 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001257 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001258 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1259 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001260};
1261
Eric Christophercfd323d2011-06-21 00:05:20 +00001262const TargetInfo::AddlRegName AddlRegNames[] = {
1263 { { "al", "ah", "eax", "rax" }, 0 },
1264 { { "bl", "bh", "ebx", "rbx" }, 3 },
1265 { { "cl", "ch", "ecx", "rcx" }, 2 },
1266 { { "dl", "dh", "edx", "rdx" }, 1 },
1267 { { "esi", "rsi" }, 4 },
1268 { { "edi", "rdi" }, 5 },
1269 { { "esp", "rsp" }, 7 },
1270 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001271};
1272
1273// X86 target abstract base class; x86-32 and x86-64 are very close, so
1274// most of the implementation can be shared.
1275class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001276 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001277 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001278 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001279 enum MMX3DNowEnum {
1280 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1281 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001282
Eric Christophereea12d12010-04-02 23:50:19 +00001283 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001284 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001285 bool HasLZCNT;
1286 bool HasBMI;
1287 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001288 bool HasPOPCNT;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001289 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001290 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001291 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001292 bool HasXOP;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001293
Chandler Carruth499d9722011-09-28 08:55:34 +00001294 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1295 ///
1296 /// Each enumeration represents a particular CPU supported by Clang. These
1297 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1298 enum CPUKind {
1299 CK_Generic,
1300
1301 /// \name i386
1302 /// i386-generation processors.
1303 //@{
1304 CK_i386,
1305 //@}
1306
1307 /// \name i486
1308 /// i486-generation processors.
1309 //@{
1310 CK_i486,
1311 CK_WinChipC6,
1312 CK_WinChip2,
1313 CK_C3,
1314 //@}
1315
1316 /// \name i586
1317 /// i586-generation processors, P5 microarchitecture based.
1318 //@{
1319 CK_i586,
1320 CK_Pentium,
1321 CK_PentiumMMX,
1322 //@}
1323
1324 /// \name i686
1325 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1326 //@{
1327 CK_i686,
1328 CK_PentiumPro,
1329 CK_Pentium2,
1330 CK_Pentium3,
1331 CK_Pentium3M,
1332 CK_PentiumM,
1333 CK_C3_2,
1334
1335 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1336 /// Clang however has some logic to suport this.
1337 // FIXME: Warn, deprecate, and potentially remove this.
1338 CK_Yonah,
1339 //@}
1340
1341 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001342 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001343 //@{
1344 CK_Pentium4,
1345 CK_Pentium4M,
1346 CK_Prescott,
1347 CK_Nocona,
1348 //@}
1349
1350 /// \name Core
1351 /// Core microarchitecture based processors.
1352 //@{
1353 CK_Core2,
1354
1355 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1356 /// codename which GCC no longer accepts as an option to -march, but Clang
1357 /// has some logic for recognizing it.
1358 // FIXME: Warn, deprecate, and potentially remove this.
1359 CK_Penryn,
1360 //@}
1361
1362 /// \name Atom
1363 /// Atom processors
1364 //@{
1365 CK_Atom,
1366 //@}
1367
1368 /// \name Nehalem
1369 /// Nehalem microarchitecture based processors.
1370 //@{
1371 CK_Corei7,
1372 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001373 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001374 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001375 //@}
1376
1377 /// \name K6
1378 /// K6 architecture processors.
1379 //@{
1380 CK_K6,
1381 CK_K6_2,
1382 CK_K6_3,
1383 //@}
1384
1385 /// \name K7
1386 /// K7 architecture processors.
1387 //@{
1388 CK_Athlon,
1389 CK_AthlonThunderbird,
1390 CK_Athlon4,
1391 CK_AthlonXP,
1392 CK_AthlonMP,
1393 //@}
1394
1395 /// \name K8
1396 /// K8 architecture processors.
1397 //@{
1398 CK_Athlon64,
1399 CK_Athlon64SSE3,
1400 CK_AthlonFX,
1401 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001402 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001403 CK_Opteron,
1404 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001405 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001406 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001407
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001408 /// \name Bobcat
1409 /// Bobcat architecture processors.
1410 //@{
1411 CK_BTVER1,
1412 //@}
1413
1414 /// \name Bulldozer
1415 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001416 //@{
1417 CK_BDVER1,
1418 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001419 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001420
Chandler Carruth499d9722011-09-28 08:55:34 +00001421 /// This specification is deprecated and will be removed in the future.
1422 /// Users should prefer \see CK_K8.
1423 // FIXME: Warn on this when the CPU is set to it.
1424 CK_x86_64,
1425 //@}
1426
1427 /// \name Geode
1428 /// Geode processors.
1429 //@{
1430 CK_Geode
1431 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001432 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001433
Eli Friedman618234a2008-08-20 02:34:37 +00001434public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001435 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001436 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Craig Topper3c0bc152012-05-31 05:18:48 +00001437 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasBMI(false),
1438 HasBMI2(false), HasPOPCNT(false), HasSSE4a(false), HasFMA4(false),
Craig Topperb6af69e2012-06-09 22:24:14 +00001439 HasFMA(false), HasXOP(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001440 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001441 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001442 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001443 virtual unsigned getFloatEvalMethod() const {
1444 // X87 evaluates with 80 bits "long double" precision.
1445 return SSELevel == NoSSE ? 2 : 0;
1446 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001447 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1448 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001449 Records = BuiltinInfo;
1450 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001451 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001452 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001453 unsigned &NumNames) const {
1454 Names = GCCRegNames;
1455 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001456 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001457 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001458 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001459 Aliases = 0;
1460 NumAliases = 0;
1461 }
1462 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
1463 unsigned &NumNames) const {
1464 Names = AddlRegNames;
1465 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001466 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001467 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001468 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001469 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001470 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001471 return "~{dirflag},~{fpsr},~{flags}";
1472 }
Chris Lattner33328642009-03-20 15:52:06 +00001473 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001474 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001475 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001476 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001477 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001478 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001479 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001480 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001481 virtual const char* getABI() const {
Craig Topper05fe4b52012-01-09 09:19:09 +00001482 if (PointerWidth == 64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001483 return "avx";
1484 else if (PointerWidth == 32 && MMX3DNowLevel == NoMMX3DNow)
1485 return "no-mmx";
1486 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001487 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001488 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001489 CPU = llvm::StringSwitch<CPUKind>(Name)
1490 .Case("i386", CK_i386)
1491 .Case("i486", CK_i486)
1492 .Case("winchip-c6", CK_WinChipC6)
1493 .Case("winchip2", CK_WinChip2)
1494 .Case("c3", CK_C3)
1495 .Case("i586", CK_i586)
1496 .Case("pentium", CK_Pentium)
1497 .Case("pentium-mmx", CK_PentiumMMX)
1498 .Case("i686", CK_i686)
1499 .Case("pentiumpro", CK_PentiumPro)
1500 .Case("pentium2", CK_Pentium2)
1501 .Case("pentium3", CK_Pentium3)
1502 .Case("pentium3m", CK_Pentium3M)
1503 .Case("pentium-m", CK_PentiumM)
1504 .Case("c3-2", CK_C3_2)
1505 .Case("yonah", CK_Yonah)
1506 .Case("pentium4", CK_Pentium4)
1507 .Case("pentium4m", CK_Pentium4M)
1508 .Case("prescott", CK_Prescott)
1509 .Case("nocona", CK_Nocona)
1510 .Case("core2", CK_Core2)
1511 .Case("penryn", CK_Penryn)
1512 .Case("atom", CK_Atom)
1513 .Case("corei7", CK_Corei7)
1514 .Case("corei7-avx", CK_Corei7AVX)
1515 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001516 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001517 .Case("k6", CK_K6)
1518 .Case("k6-2", CK_K6_2)
1519 .Case("k6-3", CK_K6_3)
1520 .Case("athlon", CK_Athlon)
1521 .Case("athlon-tbird", CK_AthlonThunderbird)
1522 .Case("athlon-4", CK_Athlon4)
1523 .Case("athlon-xp", CK_AthlonXP)
1524 .Case("athlon-mp", CK_AthlonMP)
1525 .Case("athlon64", CK_Athlon64)
1526 .Case("athlon64-sse3", CK_Athlon64SSE3)
1527 .Case("athlon-fx", CK_AthlonFX)
1528 .Case("k8", CK_K8)
1529 .Case("k8-sse3", CK_K8SSE3)
1530 .Case("opteron", CK_Opteron)
1531 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001532 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001533 .Case("btver1", CK_BTVER1)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001534 .Case("bdver1", CK_BDVER1)
1535 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001536 .Case("x86-64", CK_x86_64)
1537 .Case("geode", CK_Geode)
1538 .Default(CK_Generic);
1539
Chandler Carruth26a39142011-09-28 09:45:08 +00001540 // Perform any per-CPU checks necessary to determine if this CPU is
1541 // acceptable.
1542 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1543 // invalid without explaining *why*.
1544 switch (CPU) {
1545 case CK_Generic:
1546 // No processor selected!
1547 return false;
1548
1549 case CK_i386:
1550 case CK_i486:
1551 case CK_WinChipC6:
1552 case CK_WinChip2:
1553 case CK_C3:
1554 case CK_i586:
1555 case CK_Pentium:
1556 case CK_PentiumMMX:
1557 case CK_i686:
1558 case CK_PentiumPro:
1559 case CK_Pentium2:
1560 case CK_Pentium3:
1561 case CK_Pentium3M:
1562 case CK_PentiumM:
1563 case CK_Yonah:
1564 case CK_C3_2:
1565 case CK_Pentium4:
1566 case CK_Pentium4M:
1567 case CK_Prescott:
1568 case CK_K6:
1569 case CK_K6_2:
1570 case CK_K6_3:
1571 case CK_Athlon:
1572 case CK_AthlonThunderbird:
1573 case CK_Athlon4:
1574 case CK_AthlonXP:
1575 case CK_AthlonMP:
1576 case CK_Geode:
1577 // Only accept certain architectures when compiling in 32-bit mode.
1578 if (PointerWidth != 32)
1579 return false;
1580
1581 // Fallthrough
1582 case CK_Nocona:
1583 case CK_Core2:
1584 case CK_Penryn:
1585 case CK_Atom:
1586 case CK_Corei7:
1587 case CK_Corei7AVX:
1588 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001589 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001590 case CK_Athlon64:
1591 case CK_Athlon64SSE3:
1592 case CK_AthlonFX:
1593 case CK_K8:
1594 case CK_K8SSE3:
1595 case CK_Opteron:
1596 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001597 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001598 case CK_BTVER1:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001599 case CK_BDVER1:
1600 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001601 case CK_x86_64:
1602 return true;
1603 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001604 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001605 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001606};
Chris Lattner3daed522009-03-02 22:20:04 +00001607
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001608void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001609 // FIXME: This should not be here.
1610 Features["3dnow"] = false;
1611 Features["3dnowa"] = false;
1612 Features["mmx"] = false;
1613 Features["sse"] = false;
1614 Features["sse2"] = false;
1615 Features["sse3"] = false;
1616 Features["ssse3"] = false;
1617 Features["sse41"] = false;
1618 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001619 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001620 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001621 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001622 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001623 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001624 Features["lzcnt"] = false;
1625 Features["bmi"] = false;
1626 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001627 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001628 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001629 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001630 Features["xop"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001631
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001632 // FIXME: This *really* should not be here.
1633
1634 // X86_64 always has SSE2.
1635 if (PointerWidth == 64)
1636 Features["sse2"] = Features["sse"] = Features["mmx"] = true;
1637
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001638 switch (CPU) {
1639 case CK_Generic:
1640 case CK_i386:
1641 case CK_i486:
1642 case CK_i586:
1643 case CK_Pentium:
1644 case CK_i686:
1645 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001646 break;
1647 case CK_PentiumMMX:
1648 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001649 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001650 break;
1651 case CK_Pentium3:
1652 case CK_Pentium3M:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001653 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001654 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001655 break;
1656 case CK_PentiumM:
1657 case CK_Pentium4:
1658 case CK_Pentium4M:
1659 case CK_x86_64:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001660 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001661 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001662 break;
1663 case CK_Yonah:
1664 case CK_Prescott:
1665 case CK_Nocona:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001666 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001667 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001668 break;
1669 case CK_Core2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001670 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001671 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001672 break;
1673 case CK_Penryn:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001674 setFeatureEnabled(Features, "mmx", true);
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001675 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001676 break;
1677 case CK_Atom:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001678 setFeatureEnabled(Features, "mmx", true);
Chandler Carruth49defe62011-09-28 10:36:46 +00001679 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001680 break;
1681 case CK_Corei7:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001682 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001683 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001684 break;
1685 case CK_Corei7AVX:
1686 case CK_CoreAVXi:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001687 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001688 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001689 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001690 setFeatureEnabled(Features, "pclmul", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001691 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001692 case CK_CoreAVX2:
1693 setFeatureEnabled(Features, "mmx", true);
Craig Topperfd936302012-04-26 07:31:30 +00001694 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001695 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001696 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001697 setFeatureEnabled(Features, "lzcnt", true);
1698 setFeatureEnabled(Features, "bmi", true);
1699 setFeatureEnabled(Features, "bmi2", true);
Craig Topper2ae95072012-06-03 21:46:30 +00001700 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001701 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001702 case CK_K6:
1703 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001704 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001705 break;
1706 case CK_K6_2:
1707 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001708 case CK_WinChip2:
1709 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001710 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001711 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00001712 case CK_Athlon:
1713 case CK_AthlonThunderbird:
1714 case CK_Geode:
1715 setFeatureEnabled(Features, "3dnowa", true);
1716 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001717 case CK_Athlon4:
1718 case CK_AthlonXP:
1719 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001720 setFeatureEnabled(Features, "sse", true);
1721 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001722 break;
1723 case CK_K8:
1724 case CK_Opteron:
1725 case CK_Athlon64:
1726 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00001727 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001728 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001729 break;
1730 case CK_K8SSE3:
1731 case CK_OpteronSSE3:
1732 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00001733 setFeatureEnabled(Features, "sse3", true);
1734 setFeatureEnabled(Features, "3dnowa", true);
1735 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00001736 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00001737 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00001738 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00001739 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001740 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001741 case CK_BTVER1:
1742 setFeatureEnabled(Features, "ssse3", true);
1743 setFeatureEnabled(Features, "sse4a", true);
Craig Topper90ea0362012-05-30 05:54:54 +00001744 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001745 case CK_BDVER1:
1746 case CK_BDVER2:
Craig Topper70d9b162012-05-01 07:18:03 +00001747 setFeatureEnabled(Features, "avx", true);
Craig Topperb6af69e2012-06-09 22:24:14 +00001748 setFeatureEnabled(Features, "xop", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001749 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001750 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001751 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001752 case CK_C3_2:
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001753 setFeatureEnabled(Features, "mmx", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001754 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001755 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001756 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001757}
1758
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001759bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001760 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001761 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00001762 // FIXME: This *really* should not be here. We need some way of translating
1763 // options into llvm subtarget features.
1764 if (!Features.count(Name) &&
1765 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001766 return false;
1767
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001768 // FIXME: this should probably use a switch with fall through.
1769
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001770 if (Enabled) {
1771 if (Name == "mmx")
1772 Features["mmx"] = true;
1773 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001774 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001775 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001776 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001777 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001778 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1779 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001780 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001781 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001782 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001783 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001784 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001785 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1786 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00001787 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001788 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00001789 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001790 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001791 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001792 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001793 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00001794 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00001795 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00001796 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00001797 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001798 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00001799 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1800 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001801 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00001802 else if (Name == "avx2")
1803 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1804 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00001805 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00001806 else if (Name == "fma")
1807 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1808 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1809 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00001810 else if (Name == "fma4")
1811 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1812 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00001813 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
1814 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00001815 else if (Name == "xop")
1816 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
1817 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1818 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
1819 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00001820 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00001821 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00001822 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00001823 else if (Name == "lzcnt")
1824 Features["lzcnt"] = true;
1825 else if (Name == "bmi")
1826 Features["bmi"] = true;
1827 else if (Name == "bmi2")
1828 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00001829 else if (Name == "popcnt")
1830 Features["popcnt"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001831 } else {
1832 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001833 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001834 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00001835 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00001836 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001837 Features["sse4a"] = Features["avx"] = Features["avx2"] =
1838 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001839 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001840 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00001841 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00001842 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001843 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001844 Features["fma4"] = Features["aes"] = Features["pclmul"] =
1845 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001846 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00001847 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00001848 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001849 Features["avx2"] = Features["fma"] = Features["fma4"] =
1850 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001851 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00001852 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
1853 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00001854 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00001855 Features["sse41"] = Features["sse42"] = Features["avx"] =
1856 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00001857 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00001858 Features["sse42"] = Features["avx"] = Features["avx2"] =
1859 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001860 else if (Name == "3dnow")
1861 Features["3dnow"] = Features["3dnowa"] = false;
1862 else if (Name == "3dnowa")
1863 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001864 else if (Name == "aes")
1865 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001866 else if (Name == "pclmul")
1867 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001868 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00001869 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00001870 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001871 else if (Name == "avx2")
1872 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001873 else if (Name == "fma")
1874 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001875 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00001876 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001877 else if (Name == "lzcnt")
1878 Features["lzcnt"] = false;
1879 else if (Name == "bmi")
1880 Features["bmi"] = false;
1881 else if (Name == "bmi2")
1882 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001883 else if (Name == "popcnt")
1884 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001885 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00001886 Features["fma4"] = Features["xop"] = false;
1887 else if (Name == "xop")
1888 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001889 }
1890
1891 return true;
1892}
1893
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001894/// HandleTargetOptions - Perform initialization based on the user
1895/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001896void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001897 // Remember the maximum enabled sselevel.
1898 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1899 // Ignore disabled features.
1900 if (Features[i][0] == '-')
1901 continue;
1902
Benjamin Kramer713575a2012-03-05 15:10:44 +00001903 StringRef Feature = StringRef(Features[i]).substr(1);
1904
1905 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00001906 HasAES = true;
1907 continue;
1908 }
1909
Craig Topper3c0bc152012-05-31 05:18:48 +00001910 if (Feature == "pclmul") {
1911 HasPCLMUL = true;
1912 continue;
1913 }
1914
Benjamin Kramer713575a2012-03-05 15:10:44 +00001915 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00001916 HasLZCNT = true;
1917 continue;
1918 }
1919
Benjamin Kramer713575a2012-03-05 15:10:44 +00001920 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00001921 HasBMI = true;
1922 continue;
1923 }
1924
Benjamin Kramer713575a2012-03-05 15:10:44 +00001925 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00001926 HasBMI2 = true;
1927 continue;
1928 }
1929
Benjamin Kramer713575a2012-03-05 15:10:44 +00001930 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00001931 HasPOPCNT = true;
1932 continue;
1933 }
1934
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001935 if (Feature == "sse4a") {
1936 HasSSE4a = true;
1937 continue;
1938 }
1939
Benjamin Kramer713575a2012-03-05 15:10:44 +00001940 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00001941 HasFMA4 = true;
1942 continue;
1943 }
1944
Craig Topper2ae95072012-06-03 21:46:30 +00001945 if (Feature == "fma") {
1946 HasFMA = true;
1947 continue;
1948 }
1949
Craig Topperb6af69e2012-06-09 22:24:14 +00001950 if (Feature == "xop") {
1951 HasXOP = true;
1952 continue;
1953 }
1954
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001955 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00001956 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00001957 .Case("avx2", AVX2)
1958 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001959 .Case("sse42", SSE42)
1960 .Case("sse41", SSE41)
1961 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00001962 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001963 .Case("sse2", SSE2)
1964 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001965 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001966 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001967
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001968 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00001969 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001970 .Case("3dnowa", AMD3DNowAthlon)
1971 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001972 .Case("mmx", MMX)
1973 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00001974
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001975 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00001976 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001977
1978 // Don't tell the backend if we're turning off mmx; it will end up disabling
1979 // SSE, which we don't want.
1980 std::vector<std::string>::iterator it;
1981 it = std::find(Features.begin(), Features.end(), "-mmx");
1982 if (it != Features.end())
1983 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00001984}
Chris Lattnerc0f59212009-03-02 22:27:17 +00001985
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001986/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
1987/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00001988void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001989 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00001990 // Target identification.
1991 if (PointerWidth == 64) {
Aaron Ballmanc0765a02012-03-14 20:50:57 +00001992 if (getLongWidth() == 64) {
1993 Builder.defineMacro("_LP64");
1994 Builder.defineMacro("__LP64__");
1995 }
Benjamin Kramera9992772010-01-09 17:55:51 +00001996 Builder.defineMacro("__amd64__");
1997 Builder.defineMacro("__amd64");
1998 Builder.defineMacro("__x86_64");
1999 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002000 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002001 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002002 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002003
Chris Lattnerc0f59212009-03-02 22:27:17 +00002004 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002005 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2006 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002007 switch (CPU) {
2008 case CK_Generic:
2009 break;
2010 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002011 // The rest are coming from the i386 define above.
2012 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002013 break;
2014 case CK_i486:
2015 case CK_WinChipC6:
2016 case CK_WinChip2:
2017 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002018 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002019 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002020 case CK_PentiumMMX:
2021 Builder.defineMacro("__pentium_mmx__");
2022 Builder.defineMacro("__tune_pentium_mmx__");
2023 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002024 case CK_i586:
2025 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002026 defineCPUMacros(Builder, "i586");
2027 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002028 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002029 case CK_Pentium3:
2030 case CK_Pentium3M:
2031 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002032 Builder.defineMacro("__tune_pentium3__");
2033 // Fallthrough
2034 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002035 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002036 Builder.defineMacro("__tune_pentium2__");
2037 // Fallthrough
2038 case CK_PentiumPro:
2039 Builder.defineMacro("__tune_i686__");
2040 Builder.defineMacro("__tune_pentiumpro__");
2041 // Fallthrough
2042 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002043 Builder.defineMacro("__i686");
2044 Builder.defineMacro("__i686__");
2045 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2046 Builder.defineMacro("__pentiumpro");
2047 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002048 break;
2049 case CK_Pentium4:
2050 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002051 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002052 break;
2053 case CK_Yonah:
2054 case CK_Prescott:
2055 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002056 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002057 break;
2058 case CK_Core2:
2059 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002060 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002061 break;
2062 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002063 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002064 break;
2065 case CK_Corei7:
2066 case CK_Corei7AVX:
2067 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002068 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002069 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002070 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002071 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002072 Builder.defineMacro("__k6_2__");
2073 Builder.defineMacro("__tune_k6_2__");
2074 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002075 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002076 if (CPU != CK_K6_2) { // In case of fallthrough
2077 // FIXME: GCC may be enabling these in cases where some other k6
2078 // architecture is specified but -m3dnow is explicitly provided. The
2079 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002080 Builder.defineMacro("__k6_3__");
2081 Builder.defineMacro("__tune_k6_3__");
2082 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002083 // Fallthrough
2084 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002085 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002086 break;
2087 case CK_Athlon:
2088 case CK_AthlonThunderbird:
2089 case CK_Athlon4:
2090 case CK_AthlonXP:
2091 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002092 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002093 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002094 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002095 Builder.defineMacro("__tune_athlon_sse__");
2096 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002097 break;
2098 case CK_K8:
2099 case CK_K8SSE3:
2100 case CK_x86_64:
2101 case CK_Opteron:
2102 case CK_OpteronSSE3:
2103 case CK_Athlon64:
2104 case CK_Athlon64SSE3:
2105 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002106 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002107 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002108 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002109 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002110 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002111 case CK_BTVER1:
2112 defineCPUMacros(Builder, "btver1");
2113 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002114 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002115 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002116 break;
2117 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002118 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002119 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002120 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002121 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002122 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002123 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002124
Chandler Carruth88c75b02011-09-28 09:54:07 +00002125 // Target properties.
2126 Builder.defineMacro("__LITTLE_ENDIAN__");
2127 Builder.defineMacro("__REGISTER_PREFIX__", "");
2128
Chris Lattner54175442009-04-19 17:32:33 +00002129 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2130 // functions in glibc header files that use FP Stack inline asm which the
2131 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002132 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002133
Chandler Carruth88c75b02011-09-28 09:54:07 +00002134 if (HasAES)
2135 Builder.defineMacro("__AES__");
2136
Craig Topper3c0bc152012-05-31 05:18:48 +00002137 if (HasPCLMUL)
2138 Builder.defineMacro("__PCLMUL__");
2139
Craig Topper31ceea02011-12-25 05:06:45 +00002140 if (HasLZCNT)
2141 Builder.defineMacro("__LZCNT__");
2142
2143 if (HasBMI)
2144 Builder.defineMacro("__BMI__");
2145
2146 if (HasBMI2)
2147 Builder.defineMacro("__BMI2__");
2148
Craig Toppere14e08b2011-12-29 16:10:46 +00002149 if (HasPOPCNT)
2150 Builder.defineMacro("__POPCNT__");
2151
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002152 if (HasSSE4a)
2153 Builder.defineMacro("__SSE4A__");
2154
Craig Topper6a511e12011-12-30 07:33:42 +00002155 if (HasFMA4)
2156 Builder.defineMacro("__FMA4__");
2157
Craig Topper2ae95072012-06-03 21:46:30 +00002158 if (HasFMA)
2159 Builder.defineMacro("__FMA__");
2160
Craig Topperb6af69e2012-06-09 22:24:14 +00002161 if (HasXOP)
2162 Builder.defineMacro("__XOP__");
2163
Chris Lattner84f0ea82009-03-02 22:40:39 +00002164 // Each case falls through to the previous one here.
2165 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002166 case AVX2:
2167 Builder.defineMacro("__AVX2__");
2168 case AVX:
2169 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002170 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002171 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002172 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002173 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002174 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002175 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002176 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002177 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002178 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002179 Builder.defineMacro("__SSE2__");
2180 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002181 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002182 Builder.defineMacro("__SSE__");
2183 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002184 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002185 break;
2186 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002187
Francois Pichet62ec1f22011-09-17 17:15:52 +00002188 if (Opts.MicrosoftExt && PointerWidth == 32) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002189 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002190 case AVX2:
2191 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002192 case SSE42:
2193 case SSE41:
2194 case SSSE3:
2195 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002196 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002197 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002198 break;
2199 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002200 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002201 break;
2202 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002203 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002204 }
2205 }
2206
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002207 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002208 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002209 case AMD3DNowAthlon:
2210 Builder.defineMacro("__3dNOW_A__");
2211 case AMD3DNow:
2212 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002213 case MMX:
2214 Builder.defineMacro("__MMX__");
2215 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002216 break;
2217 }
Chris Lattnerc0f59212009-03-02 22:27:17 +00002218}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002219
Douglas Gregore727d212012-01-30 06:38:25 +00002220bool X86TargetInfo::hasFeature(StringRef Feature) const {
2221 return llvm::StringSwitch<bool>(Feature)
2222 .Case("aes", HasAES)
2223 .Case("avx", SSELevel >= AVX)
2224 .Case("avx2", SSELevel >= AVX2)
2225 .Case("bmi", HasBMI)
2226 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002227 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002228 .Case("fma4", HasFMA4)
2229 .Case("lzcnt", HasLZCNT)
2230 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2231 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2232 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002233 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002234 .Case("popcnt", HasPOPCNT)
2235 .Case("sse", SSELevel >= SSE1)
2236 .Case("sse2", SSELevel >= SSE2)
2237 .Case("sse3", SSELevel >= SSE3)
2238 .Case("ssse3", SSELevel >= SSSE3)
2239 .Case("sse41", SSELevel >= SSE41)
2240 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002241 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002242 .Case("x86", true)
2243 .Case("x86_32", PointerWidth == 32)
2244 .Case("x86_64", PointerWidth == 64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002245 .Case("xop", HasXOP)
Douglas Gregore727d212012-01-30 06:38:25 +00002246 .Default(false);
2247}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002248
Eli Friedman618234a2008-08-20 02:34:37 +00002249bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002250X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002251 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002252 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002253 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002254 case 'Y': // first letter of a pair:
2255 switch (*(Name+1)) {
2256 default: return false;
2257 case '0': // First SSE register.
2258 case 't': // Any SSE register, when SSE2 is enabled.
2259 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2260 case 'm': // any MMX register, when inter-unit moves enabled.
2261 break; // falls through to setAllowsRegister.
2262 }
Eli Friedman618234a2008-08-20 02:34:37 +00002263 case 'a': // eax.
2264 case 'b': // ebx.
2265 case 'c': // ecx.
2266 case 'd': // edx.
2267 case 'S': // esi.
2268 case 'D': // edi.
2269 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002270 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002271 case 't': // top of floating point stack.
2272 case 'u': // second from top of floating point stack.
2273 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002274 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002275 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002276 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002277 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2278 case 'l': // "Index" registers: any general register that can be used as an
2279 // index in a base+index memory access.
2280 Info.setAllowsRegister();
2281 return true;
2282 case 'C': // SSE floating point constant.
2283 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002284 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002285 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002286 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002287 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002288 return true;
2289 }
2290}
2291
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002292
Eli Friedman618234a2008-08-20 02:34:37 +00002293std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002294X86TargetInfo::convertConstraint(const char *&Constraint) const {
2295 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002296 case 'a': return std::string("{ax}");
2297 case 'b': return std::string("{bx}");
2298 case 'c': return std::string("{cx}");
2299 case 'd': return std::string("{dx}");
2300 case 'S': return std::string("{si}");
2301 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002302 case 'p': // address
2303 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002304 case 't': // top of floating point stack.
2305 return std::string("{st}");
2306 case 'u': // second from top of floating point stack.
2307 return std::string("{st(1)}"); // second from top of floating point stack.
2308 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002309 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002310 }
2311}
Eli Friedman618234a2008-08-20 02:34:37 +00002312} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002313
2314namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002315// X86-32 generic target
2316class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002317public:
Eli Friedman618234a2008-08-20 02:34:37 +00002318 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2319 DoubleAlign = LongLongAlign = 32;
2320 LongDoubleWidth = 96;
2321 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002322 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002323 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2324 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002325 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002326 SizeType = UnsignedInt;
2327 PtrDiffType = SignedInt;
2328 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002329 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002330
2331 // Use fpret for all types.
2332 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2333 (1 << TargetInfo::Double) |
2334 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002335
2336 // x86-32 has atomics up to 8 bytes
2337 // FIXME: Check that we actually have cmpxchg8b before setting
2338 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2339 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002340 }
Meador Ingec5613b22012-06-16 03:34:49 +00002341 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2342 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002343 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002344
Chris Lattner21fb98e2009-09-23 06:06:36 +00002345 int getEHDataRegisterNumber(unsigned RegNo) const {
2346 if (RegNo == 0) return 0;
2347 if (RegNo == 1) return 2;
2348 return -1;
2349 }
Eli Friedman618234a2008-08-20 02:34:37 +00002350};
2351} // end anonymous namespace
2352
2353namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002354class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2355public:
2356 NetBSDI386TargetInfo(const std::string &triple) :
2357 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2358 }
2359
2360 virtual unsigned getFloatEvalMethod() const {
2361 // NetBSD defaults to "double" rounding
2362 return 1;
2363 }
2364};
2365} // end anonymous namespace
2366
2367namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002368class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2369public:
2370 OpenBSDI386TargetInfo(const std::string& triple) :
2371 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2372 SizeType = UnsignedLong;
2373 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002374 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002375 }
2376};
2377} // end anonymous namespace
2378
2379namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002380class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002381public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002382 DarwinI386TargetInfo(const std::string& triple) :
2383 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002384 LongDoubleWidth = 128;
2385 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002386 SuitableAlign = 128;
Eli Friedman1afabd92009-03-29 20:31:09 +00002387 SizeType = UnsignedLong;
2388 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002389 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2390 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002391 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002392 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002393 }
2394
Eli Friedman618234a2008-08-20 02:34:37 +00002395};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002396} // end anonymous namespace
2397
2398namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002399// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002400class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002401public:
2402 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002403 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002404 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002405 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002406 DoubleAlign = LongLongAlign = 64;
2407 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 +00002408 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002409 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002410 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002411 virtual void getTargetDefines(const LangOptions &Opts,
2412 MacroBuilder &Builder) const {
2413 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2414 }
2415};
2416} // end anonymous namespace
2417
2418namespace {
2419
2420// x86-32 Windows Visual Studio target
2421class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2422public:
2423 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2424 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002425 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002426 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2427 }
2428 virtual void getTargetDefines(const LangOptions &Opts,
2429 MacroBuilder &Builder) const {
2430 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2431 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2432 // The value of the following reflects processor type.
2433 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2434 // We lost the original triple, so we use the default.
2435 Builder.defineMacro("_M_IX86", "600");
2436 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002437};
2438} // end anonymous namespace
2439
2440namespace {
2441// x86-32 MinGW target
2442class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2443public:
2444 MinGWX86_32TargetInfo(const std::string& triple)
2445 : WindowsX86_32TargetInfo(triple) {
2446 }
2447 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002448 MacroBuilder &Builder) const {
2449 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002450 DefineStd(Builder, "WIN32", Opts);
2451 DefineStd(Builder, "WINNT", Opts);
2452 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002453 Builder.defineMacro("__MSVCRT__");
2454 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002455
2456 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2457 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002458 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002459 // Provide "as-is" __declspec.
2460 Builder.defineMacro("__declspec", "__declspec");
2461 else
2462 // Provide alias of __attribute__ like mingw32-gcc.
2463 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002464 }
2465};
2466} // end anonymous namespace
2467
2468namespace {
2469// x86-32 Cygwin target
2470class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2471public:
2472 CygwinX86_32TargetInfo(const std::string& triple)
2473 : X86_32TargetInfo(triple) {
2474 TLSSupported = false;
2475 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002476 DoubleAlign = LongLongAlign = 64;
2477 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2478 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002479 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002480 }
2481 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002482 MacroBuilder &Builder) const {
2483 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2484 Builder.defineMacro("__CYGWIN__");
2485 Builder.defineMacro("__CYGWIN32__");
2486 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002487 if (Opts.CPlusPlus)
2488 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002489 }
Eli Friedman29a30502008-08-21 01:40:19 +00002490};
2491} // end anonymous namespace
2492
2493namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002494// x86-32 Haiku target
2495class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2496public:
2497 HaikuX86_32TargetInfo(const std::string& triple)
2498 : X86_32TargetInfo(triple) {
2499 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002500 IntPtrType = SignedLong;
2501 PtrDiffType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002502 this->UserLabelPrefix = "";
Eli Friedmana7e68452010-08-22 01:00:03 +00002503 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002504 virtual void getTargetDefines(const LangOptions &Opts,
2505 MacroBuilder &Builder) const {
2506 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2507 Builder.defineMacro("__INTEL__");
2508 Builder.defineMacro("__HAIKU__");
2509 }
2510};
2511} // end anonymous namespace
2512
Douglas Gregordca52262011-07-01 22:41:14 +00002513// RTEMS Target
2514template<typename Target>
2515class RTEMSTargetInfo : public OSTargetInfo<Target> {
2516protected:
2517 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2518 MacroBuilder &Builder) const {
2519 // RTEMS defines; list based off of gcc output
2520
Douglas Gregordca52262011-07-01 22:41:14 +00002521 Builder.defineMacro("__rtems__");
2522 Builder.defineMacro("__ELF__");
2523 }
2524public:
2525 RTEMSTargetInfo(const std::string &triple)
2526 : OSTargetInfo<Target>(triple) {
2527 this->UserLabelPrefix = "";
2528
2529 llvm::Triple Triple(triple);
2530 switch (Triple.getArch()) {
2531 default:
2532 case llvm::Triple::x86:
2533 // this->MCountName = ".mcount";
2534 break;
2535 case llvm::Triple::mips:
2536 case llvm::Triple::mipsel:
2537 case llvm::Triple::ppc:
2538 case llvm::Triple::ppc64:
2539 // this->MCountName = "_mcount";
2540 break;
2541 case llvm::Triple::arm:
2542 // this->MCountName = "__mcount";
2543 break;
2544 }
2545
2546 }
2547};
2548
2549namespace {
2550// x86-32 RTEMS target
2551class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2552public:
2553 RTEMSX86_32TargetInfo(const std::string& triple)
2554 : X86_32TargetInfo(triple) {
2555 SizeType = UnsignedLong;
2556 IntPtrType = SignedLong;
2557 PtrDiffType = SignedLong;
2558 this->UserLabelPrefix = "";
2559 }
2560 virtual void getTargetDefines(const LangOptions &Opts,
2561 MacroBuilder &Builder) const {
2562 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2563 Builder.defineMacro("__INTEL__");
2564 Builder.defineMacro("__rtems__");
2565 }
2566};
2567} // end anonymous namespace
2568
Chris Lattner86ed3a32010-04-11 19:29:39 +00002569namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002570// x86-64 generic target
2571class X86_64TargetInfo : public X86TargetInfo {
2572public:
Chris Lattner33328642009-03-20 15:52:06 +00002573 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00002574 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00002575 LongDoubleWidth = 128;
2576 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00002577 LargeArrayMinWidth = 128;
2578 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002579 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00002580 IntMaxType = SignedLong;
2581 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002582 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002583 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00002584
Eli Friedmaned855cb2008-08-21 00:13:15 +00002585 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2586 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002587 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002588
2589 // Use fpret only for long double.
2590 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00002591
Anders Carlssoneea64802011-10-31 16:27:11 +00002592 // Use fp2ret for _Complex long double.
2593 ComplexLongDoubleUsesFP2Ret = true;
2594
Eli Friedman2be46072011-10-14 20:59:01 +00002595 // x86-64 has atomics up to 16 bytes.
2596 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
2597 // on CPUs with cmpxchg16b
2598 MaxAtomicPromoteWidth = 128;
2599 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00002600 }
Meador Ingec5613b22012-06-16 03:34:49 +00002601 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2602 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00002603 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002604
Chris Lattner21fb98e2009-09-23 06:06:36 +00002605 int getEHDataRegisterNumber(unsigned RegNo) const {
2606 if (RegNo == 0) return 0;
2607 if (RegNo == 1) return 1;
2608 return -1;
2609 }
Eli Friedman618234a2008-08-20 02:34:37 +00002610};
2611} // end anonymous namespace
2612
2613namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002614// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002615class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002616public:
2617 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002618 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002619 TLSSupported = false;
2620 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00002621 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00002622 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00002623 IntMaxType = SignedLongLong;
2624 UIntMaxType = UnsignedLongLong;
2625 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00002626 SizeType = UnsignedLongLong;
2627 PtrDiffType = SignedLongLong;
2628 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00002629 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002630 }
2631 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002632 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002633 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002634 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00002635 }
Meador Ingec5613b22012-06-16 03:34:49 +00002636 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2637 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00002638 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002639};
2640} // end anonymous namespace
2641
2642namespace {
2643// x86-64 Windows Visual Studio target
2644class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
2645public:
2646 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
2647 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002648 LongDoubleWidth = LongDoubleAlign = 64;
2649 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00002650 }
2651 virtual void getTargetDefines(const LangOptions &Opts,
2652 MacroBuilder &Builder) const {
2653 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
2654 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00002655 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002656 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002657 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002658};
2659} // end anonymous namespace
2660
2661namespace {
2662// x86-64 MinGW target
2663class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
2664public:
2665 MinGWX86_64TargetInfo(const std::string& triple)
2666 : WindowsX86_64TargetInfo(triple) {
2667 }
2668 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002669 MacroBuilder &Builder) const {
2670 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002671 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00002672 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00002673 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00002674 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002675
2676 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2677 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002678 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002679 // Provide "as-is" __declspec.
2680 Builder.defineMacro("__declspec", "__declspec");
2681 else
2682 // Provide alias of __attribute__ like mingw32-gcc.
2683 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002684 }
2685};
2686} // end anonymous namespace
2687
2688namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002689class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
2690public:
Mike Stump1eb44332009-09-09 15:08:12 +00002691 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00002692 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
2693 Int64Type = SignedLongLong;
2694 }
2695};
2696} // end anonymous namespace
2697
2698namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00002699class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
2700public:
Mike Stump1eb44332009-09-09 15:08:12 +00002701 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00002702 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
2703 IntMaxType = SignedLongLong;
2704 UIntMaxType = UnsignedLongLong;
2705 Int64Type = SignedLongLong;
2706 }
2707};
2708} // end anonymous namespace
2709
2710namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00002711class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002712 // Possible FPU choices.
2713 enum FPUMode {
2714 NoFPU,
2715 VFP2FPU,
2716 VFP3FPU,
2717 NeonFPU
2718 };
2719
2720 static bool FPUModeIsVFP(FPUMode Mode) {
2721 return Mode >= VFP2FPU && Mode <= NeonFPU;
2722 }
2723
2724 static const TargetInfo::GCCRegAlias GCCRegAliases[];
2725 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002726
Daniel Dunbareac7c532009-12-18 18:42:37 +00002727 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002728
2729 unsigned FPU : 3;
2730
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002731 unsigned IsThumb : 1;
2732
2733 // Initialized via features.
2734 unsigned SoftFloat : 1;
2735 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002736
Chris Lattner2752c012010-03-03 19:03:45 +00002737 static const Builtin::Info BuiltinInfo[];
2738
Chris Lattner393ff042008-04-21 18:56:49 +00002739public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002740 ARMTargetInfo(const std::string &TripleStr)
Daniel Dunbareac7c532009-12-18 18:42:37 +00002741 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s")
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002742 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00002743 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002744 SizeType = UnsignedInt;
2745 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00002746 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
2747 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002748
Chris Lattner9bffb072010-04-23 16:29:58 +00002749 // {} in inline assembly are neon specifiers, not assembly variant
2750 // specifiers.
2751 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00002752
Daniel Dunbareac7c532009-12-18 18:42:37 +00002753 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00002754 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002755 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002756 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2757 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002758 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
2759 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002760 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002761 } else {
2762 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2763 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002764 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002765 }
John McCallee79a4c2010-08-21 22:46:04 +00002766
2767 // ARM targets default to using the ARM C++ ABI.
2768 CXXABI = CXXABI_ARM;
Eli Friedman2be46072011-10-14 20:59:01 +00002769
2770 // ARM has atomics up to 8 bytes
2771 // FIXME: Set MaxAtomicInlineWidth if we have the feature v6e
2772 MaxAtomicPromoteWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00002773
2774 // Do force alignment of members that follow zero length bitfields. If
2775 // the alignment of the zero-length bitfield is greater than the member
2776 // that follows it, `bar', `bar' will be aligned as the type of the
2777 // zero length bitfield.
2778 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00002779 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002780 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00002781 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00002782 ABI = Name;
2783
Daniel Dunbara2a41612009-09-14 00:02:24 +00002784 // The defaults (above) are for AAPCS, check if we need to change them.
2785 //
2786 // FIXME: We need support for -meabi... we could just mangle it into the
2787 // name.
2788 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002789 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002790 SizeType = UnsignedLong;
2791
James Molloya6d81f92011-11-23 13:35:08 +00002792 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
2793 WCharType = SignedInt;
2794
Daniel Dunbar684de632010-04-22 16:14:54 +00002795 // Do not respect the alignment of bit-field types when laying out
2796 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
2797 UseBitFieldTypeAlignment = false;
2798
Chad Rosier61a62212011-08-04 01:21:14 +00002799 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00002800 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
2801 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00002802 ZeroLengthBitfieldBoundary = 32;
2803
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002804 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00002805 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
2806 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002807 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 +00002808 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002809 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002810 } else {
2811 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 +00002812 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002813 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00002814 }
2815
Chad Rosier9f1210c2011-07-26 07:03:04 +00002816 // FIXME: Override "preferred align" for double and long long.
Daniel Dunbara2a41612009-09-14 00:02:24 +00002817 } else if (Name == "aapcs") {
2818 // FIXME: Enumerated types are variable width in straight AAPCS.
2819 } else if (Name == "aapcs-linux") {
Chad Rosier9f1210c2011-07-26 07:03:04 +00002820 ;
Daniel Dunbara2a41612009-09-14 00:02:24 +00002821 } else
2822 return false;
2823
2824 return true;
2825 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002826
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002827 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002828 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
2829 Features["vfp2"] = true;
2830 else if (CPU == "cortex-a8" || CPU == "cortex-a9")
2831 Features["neon"] = true;
2832 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002833
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002834 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002835 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002836 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00002837 if (Name == "soft-float" || Name == "soft-float-abi" ||
Chad Rosier7a938fa2012-04-04 20:39:32 +00002838 Name == "vfp2" || Name == "vfp3" || Name == "neon" || Name == "d16" ||
2839 Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002840 Features[Name] = Enabled;
2841 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002842 return false;
2843
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002844 return true;
2845 }
2846
2847 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbara91320b2009-12-21 23:28:17 +00002848 FPU = NoFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002849 SoftFloat = SoftFloatABI = false;
2850 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
2851 if (Features[i] == "+soft-float")
2852 SoftFloat = true;
2853 else if (Features[i] == "+soft-float-abi")
2854 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00002855 else if (Features[i] == "+vfp2")
2856 FPU = VFP2FPU;
2857 else if (Features[i] == "+vfp3")
2858 FPU = VFP3FPU;
2859 else if (Features[i] == "+neon")
2860 FPU = NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002861 }
2862
2863 // Remove front-end specific options which the backend handles differently.
2864 std::vector<std::string>::iterator it;
2865 it = std::find(Features.begin(), Features.end(), "+soft-float");
2866 if (it != Features.end())
2867 Features.erase(it);
2868 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
2869 if (it != Features.end())
2870 Features.erase(it);
2871 }
2872
Douglas Gregore727d212012-01-30 06:38:25 +00002873 virtual bool hasFeature(StringRef Feature) const {
2874 return llvm::StringSwitch<bool>(Feature)
2875 .Case("arm", true)
2876 .Case("softfloat", SoftFloat)
2877 .Case("thumb", IsThumb)
2878 .Case("neon", FPU == NeonFPU && !SoftFloat &&
2879 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
2880 .Default(false);
2881 }
Chris Lattner5f9e2722011-07-23 10:55:15 +00002882 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00002883 return llvm::StringSwitch<const char*>(Name)
2884 .Cases("arm8", "arm810", "4")
2885 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
2886 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
2887 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
2888 .Case("ep9312", "4T")
2889 .Cases("arm10tdmi", "arm1020t", "5T")
2890 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
2891 .Case("arm926ej-s", "5TEJ")
2892 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
2893 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002894 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002895 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00002896 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002897 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
2898 .Cases("cortex-a8", "cortex-a9", "7A")
Bob Wilson06f45632011-01-06 16:57:20 +00002899 .Case("cortex-m3", "7M")
Jim Grosbach69033132012-03-29 19:53:34 +00002900 .Case("cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00002901 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00002902 .Default(0);
2903 }
2904 virtual bool setCPU(const std::string &Name) {
2905 if (!getCPUDefineSuffix(Name))
2906 return false;
2907
2908 CPU = Name;
2909 return true;
2910 }
Chris Lattner33328642009-03-20 15:52:06 +00002911 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002912 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002913 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00002914 Builder.defineMacro("__arm");
2915 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002916
Chris Lattnerc0f59212009-03-02 22:27:17 +00002917 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00002918 Builder.defineMacro("__ARMEL__");
2919 Builder.defineMacro("__LITTLE_ENDIAN__");
2920 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002921
Chris Lattner5f9e2722011-07-23 10:55:15 +00002922 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00002923 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002924
Mike Stump437bb4b2009-04-08 02:07:04 +00002925 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002926
Daniel Dunbareac7c532009-12-18 18:42:37 +00002927 // FIXME: It's more complicated than this and we don't really support
2928 // interworking.
2929 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00002930 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002931
Daniel Dunbareac7c532009-12-18 18:42:37 +00002932 if (ABI == "aapcs" || ABI == "aapcs-linux")
Benjamin Kramera9992772010-01-09 17:55:51 +00002933 Builder.defineMacro("__ARM_EABI__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002934
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00002935 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00002936 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00002937
2938 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00002939 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002940
Bob Wilson84f95cf2011-05-13 18:56:03 +00002941 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002942 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002943 Builder.defineMacro("__THUMBEL__");
2944 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00002945 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002946 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00002947 }
2948
2949 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00002950 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002951
2952 if (FPUModeIsVFP((FPUMode) FPU))
Benjamin Kramera9992772010-01-09 17:55:51 +00002953 Builder.defineMacro("__VFP_FP__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00002954
2955 // This only gets set when Neon instructions are actually available, unlike
2956 // the VFP define, hence the soft float and arch check. This is subtly
2957 // different from gcc, we follow the intent which was that it should be set
2958 // when Neon instructions are actually available.
Bob Wilson84f95cf2011-05-13 18:56:03 +00002959 if (FPU == NeonFPU && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00002960 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00002961 }
2962 virtual void getTargetBuiltins(const Builtin::Info *&Records,
2963 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00002964 Records = BuiltinInfo;
2965 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00002966 }
Bob Wilson8b30a932012-01-26 22:14:27 +00002967 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00002968 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2969 return TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00002970 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002971 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002972 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002973 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00002974 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002975 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002976 TargetInfo::ConstraintInfo &Info) const {
Eli Friedmana9f54962008-08-20 07:44:10 +00002977 // FIXME: Check if this is complete
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002978 switch (*Name) {
Eli Friedmana9f54962008-08-20 07:44:10 +00002979 default:
Nate Begemanad487f42008-04-22 05:03:19 +00002980 case 'l': // r0-r7
2981 case 'h': // r8-r15
2982 case 'w': // VFP Floating point register single precision
2983 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00002984 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00002985 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00002986 case 'Q': // A memory address that is a single base register.
2987 Info.setAllowsMemory();
2988 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00002989 case 'U': // a memory reference...
2990 switch (Name[1]) {
2991 case 'q': // ...ARMV4 ldrsb
2992 case 'v': // ...VFP load/store (reg+constant offset)
2993 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00002994 case 't': // address valid for load/store opaque types wider
2995 // than 128-bits
2996 case 'n': // valid address for Neon doubleword vector load/store
2997 case 'm': // valid address for Neon element and structure load/store
2998 case 's': // valid address for non-offset loads/stores of quad-word
2999 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003000 Info.setAllowsMemory();
3001 Name++;
3002 return true;
3003 }
Nate Begemanad487f42008-04-22 05:03:19 +00003004 }
Chris Lattner393ff042008-04-21 18:56:49 +00003005 return false;
3006 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003007 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003008 std::string R;
3009 switch (*Constraint) {
3010 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003011 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003012 Constraint++;
3013 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003014 case 'p': // 'p' should be translated to 'r' by default.
3015 R = std::string("r");
3016 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003017 default:
3018 return std::string(1, *Constraint);
3019 }
3020 return R;
3021 }
Chris Lattner393ff042008-04-21 18:56:49 +00003022 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003023 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003024 return "";
3025 }
3026};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003027
3028const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003029 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003030 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003031 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3032
3033 // Float registers
3034 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3035 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3036 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003037 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003038
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003039 // Double registers
3040 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3041 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003042 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3043 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003044
3045 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003046 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3047 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003048};
3049
3050void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003051 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003052 Names = GCCRegNames;
3053 NumNames = llvm::array_lengthof(GCCRegNames);
3054}
3055
3056const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003057 { { "a1" }, "r0" },
3058 { { "a2" }, "r1" },
3059 { { "a3" }, "r2" },
3060 { { "a4" }, "r3" },
3061 { { "v1" }, "r4" },
3062 { { "v2" }, "r5" },
3063 { { "v3" }, "r6" },
3064 { { "v4" }, "r7" },
3065 { { "v5" }, "r8" },
3066 { { "v6", "rfp" }, "r9" },
3067 { { "sl" }, "r10" },
3068 { { "fp" }, "r11" },
3069 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003070 { { "r13" }, "sp" },
3071 { { "r14" }, "lr" },
3072 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003073 // The S, D and Q registers overlap, but aren't really aliases; we
3074 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003075};
3076
3077void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3078 unsigned &NumAliases) const {
3079 Aliases = GCCRegAliases;
3080 NumAliases = llvm::array_lengthof(GCCRegAliases);
3081}
Chris Lattner2752c012010-03-03 19:03:45 +00003082
3083const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003084#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003085#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003086 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003087#include "clang/Basic/BuiltinsARM.def"
3088};
Chris Lattner393ff042008-04-21 18:56:49 +00003089} // end anonymous namespace.
3090
Eli Friedmana9f54962008-08-20 07:44:10 +00003091namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003092class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003093 public DarwinTargetInfo<ARMTargetInfo> {
3094protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003095 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003096 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003097 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003098 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003099
Torok Edwin5f6c1942009-06-30 17:10:35 +00003100public:
Mike Stump1eb44332009-09-09 15:08:12 +00003101 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003102 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3103 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003104 // iOS always has 64-bit atomic instructions.
3105 // FIXME: This should be based off of the target features in ARMTargetInfo.
3106 MaxAtomicInlineWidth = 64;
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003107 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003108};
3109} // end anonymous namespace.
3110
Tony Linthicum96319392011-12-12 21:14:55 +00003111
3112namespace {
3113// Hexagon abstract base class
3114class HexagonTargetInfo : public TargetInfo {
3115 static const Builtin::Info BuiltinInfo[];
3116 static const char * const GCCRegNames[];
3117 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3118 std::string CPU;
3119public:
3120 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003121 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003122 DescriptionString = ("e-p:32:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003123 "i64:64:64-i32:32:32-i16:16:16-i1:32:32"
3124 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003125
3126 // {} in inline assembly are packet specifiers, not assembly variant
3127 // specifiers.
3128 NoAsmVariants = true;
3129 }
3130
3131 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3132 unsigned &NumRecords) const {
3133 Records = BuiltinInfo;
3134 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3135 }
3136
3137 virtual bool validateAsmConstraint(const char *&Name,
3138 TargetInfo::ConstraintInfo &Info) const {
3139 return true;
3140 }
3141
3142 virtual void getTargetDefines(const LangOptions &Opts,
3143 MacroBuilder &Builder) const;
3144
Douglas Gregore727d212012-01-30 06:38:25 +00003145 virtual bool hasFeature(StringRef Feature) const {
3146 return Feature == "hexagon";
3147 }
3148
Meador Ingec5613b22012-06-16 03:34:49 +00003149 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3150 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003151 }
3152 virtual void getGCCRegNames(const char * const *&Names,
3153 unsigned &NumNames) const;
3154 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3155 unsigned &NumAliases) const;
3156 virtual const char *getClobbers() const {
3157 return "";
3158 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003159
3160 static const char *getHexagonCPUSuffix(StringRef Name) {
3161 return llvm::StringSwitch<const char*>(Name)
3162 .Case("hexagonv2", "2")
3163 .Case("hexagonv3", "3")
3164 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003165 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003166 .Default(0);
3167 }
3168
Tony Linthicum96319392011-12-12 21:14:55 +00003169 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003170 if (!getHexagonCPUSuffix(Name))
3171 return false;
3172
Tony Linthicum96319392011-12-12 21:14:55 +00003173 CPU = Name;
3174 return true;
3175 }
3176};
3177
3178void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3179 MacroBuilder &Builder) const {
3180 Builder.defineMacro("qdsp6");
3181 Builder.defineMacro("__qdsp6", "1");
3182 Builder.defineMacro("__qdsp6__", "1");
3183
3184 Builder.defineMacro("hexagon");
3185 Builder.defineMacro("__hexagon", "1");
3186 Builder.defineMacro("__hexagon__", "1");
3187
3188 if(CPU == "hexagonv1") {
3189 Builder.defineMacro("__HEXAGON_V1__");
3190 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3191 if(Opts.HexagonQdsp6Compat) {
3192 Builder.defineMacro("__QDSP6_V1__");
3193 Builder.defineMacro("__QDSP6_ARCH__", "1");
3194 }
3195 }
3196 else if(CPU == "hexagonv2") {
3197 Builder.defineMacro("__HEXAGON_V2__");
3198 Builder.defineMacro("__HEXAGON_ARCH__", "2");
3199 if(Opts.HexagonQdsp6Compat) {
3200 Builder.defineMacro("__QDSP6_V2__");
3201 Builder.defineMacro("__QDSP6_ARCH__", "2");
3202 }
3203 }
3204 else if(CPU == "hexagonv3") {
3205 Builder.defineMacro("__HEXAGON_V3__");
3206 Builder.defineMacro("__HEXAGON_ARCH__", "3");
3207 if(Opts.HexagonQdsp6Compat) {
3208 Builder.defineMacro("__QDSP6_V3__");
3209 Builder.defineMacro("__QDSP6_ARCH__", "3");
3210 }
3211 }
3212 else if(CPU == "hexagonv4") {
3213 Builder.defineMacro("__HEXAGON_V4__");
3214 Builder.defineMacro("__HEXAGON_ARCH__", "4");
3215 if(Opts.HexagonQdsp6Compat) {
3216 Builder.defineMacro("__QDSP6_V4__");
3217 Builder.defineMacro("__QDSP6_ARCH__", "4");
3218 }
3219 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00003220 else if(CPU == "hexagonv5") {
3221 Builder.defineMacro("__HEXAGON_V5__");
3222 Builder.defineMacro("__HEXAGON_ARCH__", "5");
3223 if(Opts.HexagonQdsp6Compat) {
3224 Builder.defineMacro("__QDSP6_V5__");
3225 Builder.defineMacro("__QDSP6_ARCH__", "5");
3226 }
3227 }
Tony Linthicum96319392011-12-12 21:14:55 +00003228}
3229
3230const char * const HexagonTargetInfo::GCCRegNames[] = {
3231 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3232 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3233 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3234 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
3235 "p0", "p1", "p2", "p3",
3236 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
3237};
3238
3239void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
3240 unsigned &NumNames) const {
3241 Names = GCCRegNames;
3242 NumNames = llvm::array_lengthof(GCCRegNames);
3243}
3244
3245
3246const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
3247 { { "sp" }, "r29" },
3248 { { "fp" }, "r30" },
3249 { { "lr" }, "r31" },
3250 };
3251
3252void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3253 unsigned &NumAliases) const {
3254 Aliases = GCCRegAliases;
3255 NumAliases = llvm::array_lengthof(GCCRegAliases);
3256}
3257
3258
3259const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
3260#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3261#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3262 ALL_LANGUAGES },
3263#include "clang/Basic/BuiltinsHexagon.def"
3264};
3265}
3266
3267
Reid Spencer5f016e22007-07-11 17:01:13 +00003268namespace {
Eli Friedman01b86682008-08-20 07:28:14 +00003269class SparcV8TargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00003270 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3271 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003272 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00003273public:
Eli Friedman01b86682008-08-20 07:28:14 +00003274 SparcV8TargetInfo(const std::string& triple) : TargetInfo(triple) {
3275 // FIXME: Support Sparc quad-precision long double?
Eli Friedmaned855cb2008-08-21 00:13:15 +00003276 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 +00003277 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Eli Friedman01b86682008-08-20 07:28:14 +00003278 }
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003279 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003280 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003281 bool Enabled) const {
3282 if (Name == "soft-float")
3283 Features[Name] = Enabled;
3284 else
3285 return false;
3286
3287 return true;
3288 }
3289 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3290 SoftFloat = false;
3291 for (unsigned i = 0, e = Features.size(); i != e; ++i)
3292 if (Features[i] == "+soft-float")
3293 SoftFloat = true;
3294 }
Chris Lattner33328642009-03-20 15:52:06 +00003295 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003296 MacroBuilder &Builder) const {
3297 DefineStd(Builder, "sparc", Opts);
3298 Builder.defineMacro("__sparcv8");
3299 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00003300
3301 if (SoftFloat)
3302 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00003303 }
Douglas Gregore727d212012-01-30 06:38:25 +00003304
3305 virtual bool hasFeature(StringRef Feature) const {
3306 return llvm::StringSwitch<bool>(Feature)
3307 .Case("softfloat", SoftFloat)
3308 .Case("sparc", true)
3309 .Default(false);
3310 }
3311
Gabor Greif26658672008-02-21 16:29:08 +00003312 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3313 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003314 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00003315 }
Meador Ingec5613b22012-06-16 03:34:49 +00003316 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3317 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00003318 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003319 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003320 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003321 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003322 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003323 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00003324 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00003325 // FIXME: Implement!
3326 return false;
Gabor Greif26658672008-02-21 16:29:08 +00003327 }
3328 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00003329 // FIXME: Implement!
3330 return "";
Gabor Greif26658672008-02-21 16:29:08 +00003331 }
3332};
3333
Chris Lattnere957f532009-01-27 01:58:38 +00003334const char * const SparcV8TargetInfo::GCCRegNames[] = {
3335 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3336 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
3337 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
3338 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
3339};
3340
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003341void SparcV8TargetInfo::getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00003342 unsigned &NumNames) const {
3343 Names = GCCRegNames;
3344 NumNames = llvm::array_lengthof(GCCRegNames);
3345}
3346
3347const TargetInfo::GCCRegAlias SparcV8TargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003348 { { "g0" }, "r0" },
3349 { { "g1" }, "r1" },
3350 { { "g2" }, "r2" },
3351 { { "g3" }, "r3" },
3352 { { "g4" }, "r4" },
3353 { { "g5" }, "r5" },
3354 { { "g6" }, "r6" },
3355 { { "g7" }, "r7" },
3356 { { "o0" }, "r8" },
3357 { { "o1" }, "r9" },
3358 { { "o2" }, "r10" },
3359 { { "o3" }, "r11" },
3360 { { "o4" }, "r12" },
3361 { { "o5" }, "r13" },
3362 { { "o6", "sp" }, "r14" },
3363 { { "o7" }, "r15" },
3364 { { "l0" }, "r16" },
3365 { { "l1" }, "r17" },
3366 { { "l2" }, "r18" },
3367 { { "l3" }, "r19" },
3368 { { "l4" }, "r20" },
3369 { { "l5" }, "r21" },
3370 { { "l6" }, "r22" },
3371 { { "l7" }, "r23" },
3372 { { "i0" }, "r24" },
3373 { { "i1" }, "r25" },
3374 { { "i2" }, "r26" },
3375 { { "i3" }, "r27" },
3376 { { "i4" }, "r28" },
3377 { { "i5" }, "r29" },
3378 { { "i6", "fp" }, "r30" },
3379 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00003380};
3381
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003382void SparcV8TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00003383 unsigned &NumAliases) const {
3384 Aliases = GCCRegAliases;
3385 NumAliases = llvm::array_lengthof(GCCRegAliases);
3386}
Gabor Greif26658672008-02-21 16:29:08 +00003387} // end anonymous namespace.
3388
Eli Friedman01b86682008-08-20 07:28:14 +00003389namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00003390class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
3391public:
3392 AuroraUXSparcV8TargetInfo(const std::string& triple) :
3393 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
3394 SizeType = UnsignedInt;
3395 PtrDiffType = SignedInt;
3396 }
3397};
Torok Edwin5f6c1942009-06-30 17:10:35 +00003398class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00003399public:
3400 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003401 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00003402 SizeType = UnsignedInt;
3403 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00003404 }
3405};
3406} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00003407
Chris Lattner2621fd12008-05-08 05:58:21 +00003408namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003409 class MSP430TargetInfo : public TargetInfo {
3410 static const char * const GCCRegNames[];
3411 public:
3412 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003413 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003414 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00003415 IntWidth = 16; IntAlign = 16;
3416 LongWidth = 32; LongLongWidth = 64;
3417 LongAlign = LongLongAlign = 16;
3418 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003419 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003420 SizeType = UnsignedInt;
3421 IntMaxType = SignedLong;
3422 UIntMaxType = UnsignedLong;
3423 IntPtrType = SignedShort;
3424 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00003425 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00003426 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003427 }
3428 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003429 MacroBuilder &Builder) const {
3430 Builder.defineMacro("MSP430");
3431 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003432 // FIXME: defines for different 'flavours' of MCU
3433 }
3434 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3435 unsigned &NumRecords) const {
3436 // FIXME: Implement.
3437 Records = 0;
3438 NumRecords = 0;
3439 }
Douglas Gregore727d212012-01-30 06:38:25 +00003440 virtual bool hasFeature(StringRef Feature) const {
3441 return Feature == "msp430";
3442 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003443 virtual void getGCCRegNames(const char * const *&Names,
3444 unsigned &NumNames) const;
3445 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3446 unsigned &NumAliases) const {
3447 // No aliases.
3448 Aliases = 0;
3449 NumAliases = 0;
3450 }
3451 virtual bool validateAsmConstraint(const char *&Name,
3452 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00003453 // No target constraints for now.
3454 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003455 }
3456 virtual const char *getClobbers() const {
3457 // FIXME: Is this really right?
3458 return "";
3459 }
Meador Ingec5613b22012-06-16 03:34:49 +00003460 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003461 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00003462 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00003463 }
3464 };
3465
3466 const char * const MSP430TargetInfo::GCCRegNames[] = {
3467 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
3468 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3469 };
3470
3471 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
3472 unsigned &NumNames) const {
3473 Names = GCCRegNames;
3474 NumNames = llvm::array_lengthof(GCCRegNames);
3475 }
3476}
3477
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00003478namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00003479
Mike Stump1eb44332009-09-09 15:08:12 +00003480 // LLVM and Clang cannot be used directly to output native binaries for
3481 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00003482 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00003483 //
3484 // TCE uses the llvm bitcode as input and uses it for generating customized
3485 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00003486 // publicly available in http://tce.cs.tut.fi
3487
Eli Friedman209f5bb2011-10-07 19:51:42 +00003488 static const unsigned TCEOpenCLAddrSpaceMap[] = {
3489 3, // opencl_global
3490 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00003491 5, // opencl_constant
3492 0, // cuda_device
3493 0, // cuda_constant
3494 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00003495 };
3496
Eli Friedmanb63decf2009-08-19 20:47:07 +00003497 class TCETargetInfo : public TargetInfo{
3498 public:
3499 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
3500 TLSSupported = false;
3501 IntWidth = 32;
3502 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003503 PointerWidth = 32;
3504 IntAlign = 32;
3505 LongAlign = LongLongAlign = 32;
3506 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003507 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003508 SizeType = UnsignedInt;
3509 IntMaxType = SignedLong;
3510 UIntMaxType = UnsignedLong;
3511 IntPtrType = SignedInt;
3512 PtrDiffType = SignedInt;
3513 FloatWidth = 32;
3514 FloatAlign = 32;
3515 DoubleWidth = 32;
3516 DoubleAlign = 32;
3517 LongDoubleWidth = 32;
3518 LongDoubleAlign = 32;
3519 FloatFormat = &llvm::APFloat::IEEEsingle;
3520 DoubleFormat = &llvm::APFloat::IEEEsingle;
3521 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00003522 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
3523 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00003524 "f32:32:32-f64:32:32-v64:32:32-"
3525 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00003526 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003527 }
3528
3529 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003530 MacroBuilder &Builder) const {
3531 DefineStd(Builder, "tce", Opts);
3532 Builder.defineMacro("__TCE__");
3533 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00003534 }
Douglas Gregore727d212012-01-30 06:38:25 +00003535 virtual bool hasFeature(StringRef Feature) const {
3536 return Feature == "tce";
3537 }
3538
Eli Friedmanb63decf2009-08-19 20:47:07 +00003539 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3540 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00003541 virtual const char *getClobbers() const {
3542 return "";
3543 }
Meador Ingec5613b22012-06-16 03:34:49 +00003544 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3545 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00003546 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00003547 virtual void getGCCRegNames(const char * const *&Names,
3548 unsigned &NumNames) const {}
3549 virtual bool validateAsmConstraint(const char *&Name,
3550 TargetInfo::ConstraintInfo &info) const {
3551 return true;
3552 }
3553 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3554 unsigned &NumAliases) const {}
3555 };
3556}
3557
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003558namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003559class MipsTargetInfoBase : public TargetInfo {
3560 std::string CPU;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003561 bool SoftFloat;
3562 bool SingleFloat;
3563
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003564protected:
3565 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003566
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003567public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003568 MipsTargetInfoBase(const std::string& triple,
3569 const std::string& ABIStr,
3570 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003571 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003572 CPU(CPUStr),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003573 SoftFloat(false), SingleFloat(false),
3574 ABI(ABIStr)
3575 {}
3576
Eric Christophered734732010-03-02 02:41:08 +00003577 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003578 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00003579 virtual bool setCPU(const std::string &Name) {
3580 CPU = Name;
3581 return true;
3582 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003583 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00003584 Features[ABI] = true;
3585 Features[CPU] = true;
3586 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003587
Eric Christophered734732010-03-02 02:41:08 +00003588 virtual void getArchDefines(const LangOptions &Opts,
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003589 MacroBuilder &Builder) const {
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003590 if (SoftFloat && SingleFloat)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003591 llvm_unreachable("Invalid float ABI for Mips.");
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00003592 else if (SoftFloat)
3593 Builder.defineMacro("__mips_soft_float", Twine(1));
3594 else {
3595 Builder.defineMacro("__mips_hard_float", Twine(1));
3596 if (SingleFloat)
3597 Builder.defineMacro("__mips_single_float", Twine(1));
3598 }
Simon Atanasyan90913892012-04-05 19:28:31 +00003599
3600 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
3601 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
3602 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003603 }
3604
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003605 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003606 MacroBuilder &Builder) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003607 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3608 unsigned &NumRecords) const {
3609 // FIXME: Implement!
3610 }
Douglas Gregore727d212012-01-30 06:38:25 +00003611 virtual bool hasFeature(StringRef Feature) const {
3612 return Feature == "mips";
3613 }
Meador Ingec5613b22012-06-16 03:34:49 +00003614 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3615 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003616 }
3617 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003618 unsigned &NumNames) const {
3619 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00003620 // CPU register names
3621 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003622 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
3623 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
3624 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00003625 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
3626 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003627 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
3628 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
3629 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
3630 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00003631 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003632 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
3633 "$fcc5","$fcc6","$fcc7"
3634 };
3635 Names = GCCRegNames;
3636 NumNames = llvm::array_lengthof(GCCRegNames);
3637 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003638 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003639 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003640 virtual bool validateAsmConstraint(const char *&Name,
3641 TargetInfo::ConstraintInfo &Info) const {
3642 switch (*Name) {
3643 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00003644 return false;
3645
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003646 case 'r': // CPU registers.
3647 case 'd': // Equivalent to "r" unless generating MIPS16 code.
3648 case 'y': // Equivalent to "r", backwards compatibility only.
3649 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00003650 case 'c': // $25 for indirect jumps
3651 case 'l': // lo register
3652 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003653 Info.setAllowsRegister();
3654 return true;
3655 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003656 }
3657
3658 virtual const char *getClobbers() const {
3659 // FIXME: Implement!
3660 return "";
3661 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003662
3663 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3664 StringRef Name,
3665 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00003666 if (Name == "soft-float" || Name == "single-float" ||
3667 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
3668 Name == "mips32" || Name == "mips32r2" ||
3669 Name == "mips64" || Name == "mips64r2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003670 Features[Name] = Enabled;
3671 return true;
3672 }
3673 return false;
3674 }
3675
3676 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3677 SoftFloat = false;
3678 SingleFloat = false;
3679
3680 for (std::vector<std::string>::iterator it = Features.begin(),
3681 ie = Features.end(); it != ie; ++it) {
3682 if (*it == "+single-float") {
3683 SingleFloat = true;
3684 break;
3685 }
3686
3687 if (*it == "+soft-float") {
3688 SoftFloat = true;
3689 // This option is front-end specific.
3690 // Do not need to pass it to the backend.
3691 Features.erase(it);
3692 break;
3693 }
3694 }
3695 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003696};
3697
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003698class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003699public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003700 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003701 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00003702 SizeType = UnsignedInt;
3703 PtrDiffType = SignedInt;
3704 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003705 virtual bool setABI(const std::string &Name) {
3706 if ((Name == "o32") || (Name == "eabi")) {
3707 ABI = Name;
3708 return true;
3709 } else
3710 return false;
3711 }
3712 virtual void getArchDefines(const LangOptions &Opts,
3713 MacroBuilder &Builder) const {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003714 MipsTargetInfoBase::getArchDefines(Opts, Builder);
3715
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003716 if (ABI == "o32") {
3717 Builder.defineMacro("__mips_o32");
3718 Builder.defineMacro("_ABIO32", "1");
3719 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
3720 }
3721 else if (ABI == "eabi")
3722 Builder.defineMacro("__mips_eabi");
3723 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003724 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003725 }
3726 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3727 unsigned &NumAliases) const {
3728 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3729 { { "at" }, "$1" },
3730 { { "v0" }, "$2" },
3731 { { "v1" }, "$3" },
3732 { { "a0" }, "$4" },
3733 { { "a1" }, "$5" },
3734 { { "a2" }, "$6" },
3735 { { "a3" }, "$7" },
3736 { { "t0" }, "$8" },
3737 { { "t1" }, "$9" },
3738 { { "t2" }, "$10" },
3739 { { "t3" }, "$11" },
3740 { { "t4" }, "$12" },
3741 { { "t5" }, "$13" },
3742 { { "t6" }, "$14" },
3743 { { "t7" }, "$15" },
3744 { { "s0" }, "$16" },
3745 { { "s1" }, "$17" },
3746 { { "s2" }, "$18" },
3747 { { "s3" }, "$19" },
3748 { { "s4" }, "$20" },
3749 { { "s5" }, "$21" },
3750 { { "s6" }, "$22" },
3751 { { "s7" }, "$23" },
3752 { { "t8" }, "$24" },
3753 { { "t9" }, "$25" },
3754 { { "k0" }, "$26" },
3755 { { "k1" }, "$27" },
3756 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00003757 { { "sp","$sp" }, "$29" },
3758 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003759 { { "ra" }, "$31" }
3760 };
3761 Aliases = GCCRegAliases;
3762 NumAliases = llvm::array_lengthof(GCCRegAliases);
3763 }
3764};
3765
3766class Mips32EBTargetInfo : public Mips32TargetInfoBase {
3767public:
3768 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
3769 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
3770 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
3771 }
3772 virtual void getTargetDefines(const LangOptions &Opts,
3773 MacroBuilder &Builder) const {
3774 DefineStd(Builder, "mips", Opts);
3775 Builder.defineMacro("_mips");
3776 DefineStd(Builder, "MIPSEB", Opts);
3777 Builder.defineMacro("_MIPSEB");
3778 Builder.defineMacro("__REGISTER_PREFIX__", "");
3779 getArchDefines(Opts, Builder);
3780 }
3781};
3782
3783class Mips32ELTargetInfo : public Mips32TargetInfoBase {
3784public:
3785 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003786 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003787 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 +00003788 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003789 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003790 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00003791 MacroBuilder &Builder) const {
3792 DefineStd(Builder, "mips", Opts);
3793 Builder.defineMacro("_mips");
3794 DefineStd(Builder, "MIPSEL", Opts);
3795 Builder.defineMacro("_MIPSEL");
3796 Builder.defineMacro("__REGISTER_PREFIX__", "");
3797 getArchDefines(Opts, Builder);
3798 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003799};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003800
3801class Mips64TargetInfoBase : public MipsTargetInfoBase {
3802 virtual void SetDescriptionString(const std::string &Name) = 0;
3803public:
3804 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00003805 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003806 LongWidth = LongAlign = 64;
3807 PointerWidth = PointerAlign = 64;
3808 LongDoubleWidth = LongDoubleAlign = 128;
3809 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003810 SuitableAlign = 128;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003811 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003812 virtual bool setABI(const std::string &Name) {
3813 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003814
3815 if (Name != "n32" && Name != "n64")
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003816 return false;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00003817
3818 ABI = Name;
3819
3820 if (Name == "n32") {
3821 LongWidth = LongAlign = 32;
3822 PointerWidth = PointerAlign = 32;
3823 }
3824
3825 return true;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003826 }
3827 virtual void getArchDefines(const LangOptions &Opts,
3828 MacroBuilder &Builder) const {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00003829 MipsTargetInfoBase::getArchDefines(Opts, Builder);
3830
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003831 if (ABI == "n32") {
3832 Builder.defineMacro("__mips_n32");
3833 Builder.defineMacro("_ABIN32", "2");
3834 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
3835 }
3836 else if (ABI == "n64") {
3837 Builder.defineMacro("__mips_n64");
3838 Builder.defineMacro("_ABI64", "3");
3839 Builder.defineMacro("_MIPS_SIM", "_ABI64");
3840 }
3841 else
David Blaikieb219cfc2011-09-23 05:06:16 +00003842 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003843 }
3844 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3845 unsigned &NumAliases) const {
3846 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
3847 { { "at" }, "$1" },
3848 { { "v0" }, "$2" },
3849 { { "v1" }, "$3" },
3850 { { "a0" }, "$4" },
3851 { { "a1" }, "$5" },
3852 { { "a2" }, "$6" },
3853 { { "a3" }, "$7" },
3854 { { "a4" }, "$8" },
3855 { { "a5" }, "$9" },
3856 { { "a6" }, "$10" },
3857 { { "a7" }, "$11" },
3858 { { "t0" }, "$12" },
3859 { { "t1" }, "$13" },
3860 { { "t2" }, "$14" },
3861 { { "t3" }, "$15" },
3862 { { "s0" }, "$16" },
3863 { { "s1" }, "$17" },
3864 { { "s2" }, "$18" },
3865 { { "s3" }, "$19" },
3866 { { "s4" }, "$20" },
3867 { { "s5" }, "$21" },
3868 { { "s6" }, "$22" },
3869 { { "s7" }, "$23" },
3870 { { "t8" }, "$24" },
3871 { { "t9" }, "$25" },
3872 { { "k0" }, "$26" },
3873 { { "k1" }, "$27" },
3874 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00003875 { { "sp","$sp" }, "$29" },
3876 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003877 { { "ra" }, "$31" }
3878 };
3879 Aliases = GCCRegAliases;
3880 NumAliases = llvm::array_lengthof(GCCRegAliases);
3881 }
3882};
3883
3884class Mips64EBTargetInfo : public Mips64TargetInfoBase {
3885 virtual void SetDescriptionString(const std::string &Name) {
3886 // Change DescriptionString only if ABI is n32.
3887 if (Name == "n32")
3888 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 +00003889 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3890 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003891 }
3892public:
3893 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
3894 // Default ABI is n64.
3895 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 +00003896 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3897 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003898 }
3899 virtual void getTargetDefines(const LangOptions &Opts,
3900 MacroBuilder &Builder) const {
3901 DefineStd(Builder, "mips", Opts);
3902 Builder.defineMacro("_mips");
3903 DefineStd(Builder, "MIPSEB", Opts);
3904 Builder.defineMacro("_MIPSEB");
3905 Builder.defineMacro("__REGISTER_PREFIX__", "");
3906 getArchDefines(Opts, Builder);
3907 }
3908};
3909
3910class Mips64ELTargetInfo : public Mips64TargetInfoBase {
3911 virtual void SetDescriptionString(const std::string &Name) {
3912 // Change DescriptionString only if ABI is n32.
3913 if (Name == "n32")
3914 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 +00003915 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
3916 "-v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003917 }
3918public:
3919 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003920 // Default ABI is n64.
3921 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003922 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 +00003923 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
3924 "v64:64:64-n32";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00003925 }
3926 virtual void getTargetDefines(const LangOptions &Opts,
3927 MacroBuilder &Builder) const {
3928 DefineStd(Builder, "mips", Opts);
3929 Builder.defineMacro("_mips");
3930 DefineStd(Builder, "MIPSEL", Opts);
3931 Builder.defineMacro("_MIPSEL");
3932 Builder.defineMacro("__REGISTER_PREFIX__", "");
3933 getArchDefines(Opts, Builder);
3934 }
3935};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00003936} // end anonymous namespace.
3937
Ivan Krasinef05abd2011-08-24 20:22:22 +00003938namespace {
3939class PNaClTargetInfo : public TargetInfo {
3940public:
3941 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003942 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003943 this->UserLabelPrefix = "";
3944 this->LongAlign = 32;
3945 this->LongWidth = 32;
3946 this->PointerAlign = 32;
3947 this->PointerWidth = 32;
3948 this->IntMaxType = TargetInfo::SignedLongLong;
3949 this->UIntMaxType = TargetInfo::UnsignedLongLong;
3950 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003951 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003952 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00003953 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00003954 this->SizeType = TargetInfo::UnsignedInt;
3955 this->PtrDiffType = TargetInfo::SignedInt;
3956 this->IntPtrType = TargetInfo::SignedInt;
David Meyerdd4a8892011-10-11 03:12:01 +00003957 this->RegParmMax = 2;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003958 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
3959 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
3960 }
3961
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003962 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00003963 }
3964 virtual void getArchDefines(const LangOptions &Opts,
3965 MacroBuilder &Builder) const {
3966 Builder.defineMacro("__le32__");
3967 Builder.defineMacro("__pnacl__");
3968 }
3969 virtual void getTargetDefines(const LangOptions &Opts,
3970 MacroBuilder &Builder) const {
Ivan Krasin089ee112011-08-25 23:49:20 +00003971 DefineStd(Builder, "unix", Opts);
3972 Builder.defineMacro("__ELF__");
3973 if (Opts.POSIXThreads)
3974 Builder.defineMacro("_REENTRANT");
3975 if (Opts.CPlusPlus)
3976 Builder.defineMacro("_GNU_SOURCE");
3977
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00003978 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00003979 Builder.defineMacro("__native_client__");
3980 getArchDefines(Opts, Builder);
3981 }
Douglas Gregore727d212012-01-30 06:38:25 +00003982 virtual bool hasFeature(StringRef Feature) const {
3983 return Feature == "pnacl";
3984 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00003985 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3986 unsigned &NumRecords) const {
3987 }
Meador Ingec5613b22012-06-16 03:34:49 +00003988 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3989 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00003990 }
3991 virtual void getGCCRegNames(const char * const *&Names,
3992 unsigned &NumNames) const;
3993 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3994 unsigned &NumAliases) const;
3995 virtual bool validateAsmConstraint(const char *&Name,
3996 TargetInfo::ConstraintInfo &Info) const {
3997 return false;
3998 }
3999
4000 virtual const char *getClobbers() const {
4001 return "";
4002 }
4003};
4004
4005void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
4006 unsigned &NumNames) const {
4007 Names = NULL;
4008 NumNames = 0;
4009}
4010
4011void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4012 unsigned &NumAliases) const {
4013 Aliases = NULL;
4014 NumAliases = 0;
4015}
4016} // end anonymous namespace.
4017
4018
Reid Spencer5f016e22007-07-11 17:01:13 +00004019//===----------------------------------------------------------------------===//
4020// Driver code
4021//===----------------------------------------------------------------------===//
4022
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004023static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004024 llvm::Triple Triple(T);
4025 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00004026
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004027 switch (Triple.getArch()) {
4028 default:
4029 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00004030
Tony Linthicum96319392011-12-12 21:14:55 +00004031 case llvm::Triple::hexagon:
4032 return new HexagonTargetInfo(T);
4033
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004034 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00004035 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004036 if (Triple.isOSDarwin())
4037 return new DarwinARMTargetInfo(T);
4038
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004039 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00004040 case llvm::Triple::Linux:
4041 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004042 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00004043 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004044 case llvm::Triple::NetBSD:
4045 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004046 case llvm::Triple::RTEMS:
4047 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004048 default:
4049 return new ARMTargetInfo(T);
4050 }
Eli Friedman61538a72008-05-20 14:21:01 +00004051
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004052 case llvm::Triple::msp430:
4053 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00004054
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004055 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004056 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004057 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004058 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004059 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004060 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004061 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004062 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004063 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004064 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004065 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004066 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00004067 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004068
4069 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004070 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004071 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004072 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004073 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004074 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004075 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004076 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004077 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004078 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004079 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004080 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00004081 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004082
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004083 case llvm::Triple::mips64:
4084 switch (os) {
4085 case llvm::Triple::Linux:
4086 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
4087 case llvm::Triple::RTEMS:
4088 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
4089 case llvm::Triple::FreeBSD:
4090 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
4091 case llvm::Triple::NetBSD:
4092 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
4093 default:
4094 return new Mips64EBTargetInfo(T);
4095 }
4096
4097 case llvm::Triple::mips64el:
4098 switch (os) {
4099 case llvm::Triple::Linux:
4100 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
4101 case llvm::Triple::RTEMS:
4102 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
4103 case llvm::Triple::FreeBSD:
4104 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
4105 case llvm::Triple::NetBSD:
4106 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
4107 default:
4108 return new Mips64ELTargetInfo(T);
4109 }
4110
Ivan Krasinef05abd2011-08-24 20:22:22 +00004111 case llvm::Triple::le32:
4112 switch (os) {
4113 case llvm::Triple::NativeClient:
4114 return new PNaClTargetInfo(T);
4115 default:
4116 return NULL;
4117 }
4118
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004119 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004120 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00004121 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004122 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004123 case llvm::Triple::Linux:
4124 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004125 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004126 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004127 case llvm::Triple::NetBSD:
4128 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
4129 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004130 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004131 default:
4132 return new PPC32TargetInfo(T);
4133 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004134
4135 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004136 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00004137 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004138 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004139 case llvm::Triple::Linux:
4140 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004141 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00004142 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004143 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00004144 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004145 case llvm::Triple::NetBSD:
4146 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
4147 default:
4148 return new PPC64TargetInfo(T);
4149 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004150
Peter Collingbourneedb66f32012-05-20 23:28:41 +00004151 case llvm::Triple::nvptx:
4152 return new NVPTX32TargetInfo(T);
4153 case llvm::Triple::nvptx64:
4154 return new NVPTX64TargetInfo(T);
4155
Chris Lattner9cbeb632010-03-06 21:21:27 +00004156 case llvm::Triple::mblaze:
4157 return new MBlazeTargetInfo(T);
4158
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004159 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004160 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00004161 case llvm::Triple::Linux:
4162 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004163 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004164 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004165 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004166 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004167 case llvm::Triple::NetBSD:
4168 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
4169 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00004170 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00004171 default:
4172 return new SparcV8TargetInfo(T);
4173 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004174
John Thompson3f6918a2009-11-19 17:18:50 +00004175 // FIXME: Need a real SPU target.
4176 case llvm::Triple::cellspu:
4177 return new PS3SPUTargetInfo<PPC64TargetInfo>(T);
4178
Eli Friedmanb63decf2009-08-19 20:47:07 +00004179 case llvm::Triple::tce:
4180 return new TCETargetInfo(T);
4181
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004182 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004183 if (Triple.isOSDarwin())
4184 return new DarwinI386TargetInfo(T);
4185
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004186 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004187 case llvm::Triple::AuroraUX:
4188 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004189 case llvm::Triple::Linux:
4190 return new LinuxTargetInfo<X86_32TargetInfo>(T);
4191 case llvm::Triple::DragonFly:
4192 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
4193 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00004194 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004195 case llvm::Triple::OpenBSD:
4196 return new OpenBSDI386TargetInfo(T);
4197 case llvm::Triple::FreeBSD:
4198 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00004199 case llvm::Triple::Minix:
4200 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004201 case llvm::Triple::Solaris:
4202 return new SolarisTargetInfo<X86_32TargetInfo>(T);
4203 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004204 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004205 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004206 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004207 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00004208 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00004209 case llvm::Triple::Haiku:
4210 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00004211 case llvm::Triple::RTEMS:
4212 return new RTEMSX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004213 default:
4214 return new X86_32TargetInfo(T);
4215 }
4216
4217 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004218 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
4219 return new DarwinX86_64TargetInfo(T);
4220
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004221 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004222 case llvm::Triple::AuroraUX:
4223 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004224 case llvm::Triple::Linux:
4225 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00004226 case llvm::Triple::DragonFly:
4227 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004228 case llvm::Triple::NetBSD:
4229 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
4230 case llvm::Triple::OpenBSD:
4231 return new OpenBSDX86_64TargetInfo(T);
4232 case llvm::Triple::FreeBSD:
4233 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
4234 case llvm::Triple::Solaris:
4235 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00004236 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00004237 return new MinGWX86_64TargetInfo(T);
4238 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00004239 return new VisualStudioWindowsX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00004240 default:
4241 return new X86_64TargetInfo(T);
4242 }
4243 }
Reid Spencer5f016e22007-07-11 17:01:13 +00004244}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004245
4246/// CreateTargetInfo - Return the target info object for the specified target
4247/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00004248TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004249 TargetOptions &Opts) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004250 llvm::Triple Triple(Opts.Triple);
4251
4252 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00004253 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004254 if (!Target) {
4255 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
4256 return 0;
4257 }
4258
Daniel Dunbareac7c532009-12-18 18:42:37 +00004259 // Set the target CPU if specified.
4260 if (!Opts.CPU.empty() && !Target->setCPU(Opts.CPU)) {
4261 Diags.Report(diag::err_target_unknown_cpu) << Opts.CPU;
4262 return 0;
4263 }
4264
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004265 // Set the target ABI if specified.
4266 if (!Opts.ABI.empty() && !Target->setABI(Opts.ABI)) {
4267 Diags.Report(diag::err_target_unknown_abi) << Opts.ABI;
4268 return 0;
4269 }
4270
Charles Davis98b7c5c2010-06-11 01:06:47 +00004271 // Set the target C++ ABI.
John McCallee79a4c2010-08-21 22:46:04 +00004272 if (!Opts.CXXABI.empty() && !Target->setCXXABI(Opts.CXXABI)) {
Charles Davis98b7c5c2010-06-11 01:06:47 +00004273 Diags.Report(diag::err_target_unknown_cxxabi) << Opts.CXXABI;
4274 return 0;
4275 }
4276
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004277 // Compute the default target features, we need the target to handle this
4278 // because features may have dependencies on one another.
4279 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004280 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004281
4282 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004283 // First the enables.
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004284 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4285 ie = Opts.Features.end(); it != ie; ++it) {
4286 const char *Name = it->c_str();
4287
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004288 if (Name[0] != '+')
4289 continue;
4290
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004291 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00004292 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
4293 Diags.Report(diag::err_target_invalid_feature) << Name;
4294 return 0;
4295 }
4296 }
4297
4298 // Then the disables.
4299 for (std::vector<std::string>::const_iterator it = Opts.Features.begin(),
4300 ie = Opts.Features.end(); it != ie; ++it) {
4301 const char *Name = it->c_str();
4302
4303 if (Name[0] == '+')
4304 continue;
4305
4306 // Apply the feature via the target.
4307 if (Name[0] != '-' ||
4308 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004309 Diags.Report(diag::err_target_invalid_feature) << Name;
4310 return 0;
4311 }
4312 }
4313
4314 // Add the features to the compile options.
4315 //
4316 // FIXME: If we are completely confident that we have the right set, we only
4317 // need to pass the minuses.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004318 Opts.Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004319 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
4320 ie = Features.end(); it != ie; ++it)
Benjamin Kramer713575a2012-03-05 15:10:44 +00004321 Opts.Features.push_back((it->second ? "+" : "-") + it->first().str());
Daniel Dunbarb93292a2009-12-19 03:30:57 +00004322 Target->HandleTargetFeatures(Opts.Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00004323
4324 return Target.take();
4325}