blob: 841ca62ab6ea1c54a7cde2d7a8f0c41805052898 [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"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000028#include "llvm/IR/Type.h"
Chris Lattner797c3c42009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.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");
Alexander Potapenko087c65f2012-09-20 10:10:01 +000095 // AddressSanitizer doesn't play well with source fortification, which is on
96 // by default on Darwin.
Will Dietz4f45bc02013-01-18 11:30:38 +000097 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikova7c47172009-05-03 13:42:53 +000098
John McCall098df7f2011-06-16 00:03:19 +000099 if (!Opts.ObjCAutoRefCount) {
John McCallf85e1932011-06-15 23:02:42 +0000100 // __weak is always defined, for use in blocks and with objc pointers.
101 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000102
John McCallf85e1932011-06-15 23:02:42 +0000103 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregore289d812011-09-13 17:21:33 +0000104 if (Opts.getGC() != LangOptions::NonGC)
John McCallf85e1932011-06-15 23:02:42 +0000105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
106 else
107 Builder.defineMacro("__strong", "");
Eric Christopher7c9adf92011-07-07 22:55:26 +0000108
John McCallf85e1932011-06-15 23:02:42 +0000109 // __unsafe_unretained is defined to nothing in non-ARC mode. We even
110 // allow this in C, since one might have block pointers in structs that
111 // are used in pure C code and in Objective-C ARC.
112 Builder.defineMacro("__unsafe_unretained", "");
John McCallf85e1932011-06-15 23:02:42 +0000113 }
Eric Christopher7c9adf92011-07-07 22:55:26 +0000114
Eli Friedman2de4fee2009-06-04 23:00:29 +0000115 if (Opts.Static)
Benjamin Kramera9992772010-01-09 17:55:51 +0000116 Builder.defineMacro("__STATIC__");
Eli Friedman2de4fee2009-06-04 23:00:29 +0000117 else
Benjamin Kramera9992772010-01-09 17:55:51 +0000118 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000119
120 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000121 Builder.defineMacro("_REENTRANT");
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000122
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000123 // Get the platform type and version number from the triple.
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000124 unsigned Maj, Min, Rev;
Bob Wilson48b68a02012-01-31 23:52:58 +0000125 if (Triple.isMacOSX()) {
126 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000127 PlatformName = "macosx";
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000128 } else {
Bob Wilson48b68a02012-01-31 23:52:58 +0000129 Triple.getOSVersion(Maj, Min, Rev);
130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000131 }
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000132
Sebastian Pop9ec60df2012-01-20 22:01:23 +0000133 // If -target arch-pc-win32-macho option specified, we're
Eric Christopher895d4222011-07-29 21:20:35 +0000134 // generating code for Win32 ABI. No need to emit
Chad Rosierd9259f32011-07-19 20:00:06 +0000135 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
136 if (PlatformName == "win32") {
137 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
138 return;
139 }
140
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000141 // Set the appropriate OS version define.
Bob Wilson48b68a02012-01-31 23:52:58 +0000142 if (Triple.getOS() == llvm::Triple::IOS) {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000144 char Str[6];
145 Str[0] = '0' + Maj;
146 Str[1] = '0' + (Min / 10);
147 Str[2] = '0' + (Min % 10);
148 Str[3] = '0' + (Rev / 10);
149 Str[4] = '0' + (Rev % 10);
150 Str[5] = '\0';
151 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__", Str);
152 } else {
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000153 // Note that the Driver allows versions which aren't representable in the
154 // define (because we only get a single digit for the minor and micro
155 // revision numbers). So, we limit them to the maximum representable
156 // version.
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000157 assert(Triple.getEnvironmentName().empty() && "Invalid environment!");
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000159 char Str[5];
160 Str[0] = '0' + (Maj / 10);
161 Str[1] = '0' + (Maj % 10);
Daniel Dunbar8a3a7f32011-04-21 21:27:33 +0000162 Str[2] = '0' + std::min(Min, 9U);
163 Str[3] = '0' + std::min(Rev, 9U);
Daniel Dunbar21ae3192010-01-26 01:44:04 +0000164 Str[4] = '\0';
165 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar8d33cd72009-04-10 19:52:24 +0000166 }
Daniel Dunbar0d027ba2011-04-19 21:40:34 +0000167
168 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman618234a2008-08-20 02:34:37 +0000169}
Reid Spencer5f016e22007-07-11 17:01:13 +0000170
Chris Lattner797c3c42009-08-10 19:03:04 +0000171namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000172template<typename Target>
173class DarwinTargetInfo : public OSTargetInfo<Target> {
174protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000175 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000176 MacroBuilder &Builder) const {
Eric Christopher7c9adf92011-07-07 22:55:26 +0000177 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000178 this->PlatformMinVersion);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000179 }
Mike Stump1eb44332009-09-09 15:08:12 +0000180
Torok Edwin5f6c1942009-06-30 17:10:35 +0000181public:
182 DarwinTargetInfo(const std::string& triple) :
183 OSTargetInfo<Target>(triple) {
Eric Christopheraa7333c2011-07-02 00:20:22 +0000184 llvm::Triple T = llvm::Triple(triple);
185 this->TLSSupported = T.isMacOSX() && !T.isMacOSXVersionLT(10,7);
Daniel Dunbare177d3b2011-02-21 23:12:51 +0000186 this->MCountName = "\01mcount";
Torok Edwin5f6c1942009-06-30 17:10:35 +0000187 }
188
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000191 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000195 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000196 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000197
Anders Carlsson18af3682010-06-08 22:47:50 +0000198 virtual const char *getStaticInitSectionSpecifier() const {
199 // FIXME: We should return 0 when building kexts.
200 return "__TEXT,__StaticInit,regular,pure_instructions";
201 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000202
John McCall41887602012-01-29 01:20:30 +0000203 /// Darwin does not support protected visibility. Darwin's "default"
204 /// is very similar to ELF's "protected"; Darwin requires a "weak"
205 /// attribute on declarations that can be dynamically replaced.
206 virtual bool hasProtectedVisibility() const {
207 return false;
208 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000209};
210
Chris Lattner797c3c42009-08-10 19:03:04 +0000211
Torok Edwin5f6c1942009-06-30 17:10:35 +0000212// DragonFlyBSD Target
213template<typename Target>
214class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
215protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000216 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000218 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000219 Builder.defineMacro("__DragonFly__");
220 Builder.defineMacro("__DragonFly_cc_version", "100001");
221 Builder.defineMacro("__ELF__");
222 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
223 Builder.defineMacro("__tune_i386__");
224 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000225 }
226public:
Mike Stump1eb44332009-09-09 15:08:12 +0000227 DragonFlyBSDTargetInfo(const std::string &triple)
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228 : OSTargetInfo<Target>(triple) {
229 this->UserLabelPrefix = "";
230
231 llvm::Triple Triple(triple);
232 switch (Triple.getArch()) {
233 default:
234 case llvm::Triple::x86:
235 case llvm::Triple::x86_64:
236 this->MCountName = ".mcount";
237 break;
238 }
239 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000240};
241
242// FreeBSD Target
243template<typename Target>
244class FreeBSDTargetInfo : public OSTargetInfo<Target> {
245protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000246 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000247 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000248 // FreeBSD defines; list based off of gcc output
249
Benjamin Kramer474202f2011-10-18 10:10:08 +0000250 unsigned Release = Triple.getOSMajorVersion();
251 if (Release == 0U)
252 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000253
Benjamin Kramer474202f2011-10-18 10:10:08 +0000254 Builder.defineMacro("__FreeBSD__", Twine(Release));
255 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000256 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
257 DefineStd(Builder, "unix", Opts);
258 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000259 }
260public:
Mike Stump1eb44332009-09-09 15:08:12 +0000261 FreeBSDTargetInfo(const std::string &triple)
Duncan Sands1e90faf2009-07-08 13:55:08 +0000262 : OSTargetInfo<Target>(triple) {
263 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000264
265 llvm::Triple Triple(triple);
266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 case llvm::Triple::mips:
273 case llvm::Triple::mipsel:
274 case llvm::Triple::ppc:
275 case llvm::Triple::ppc64:
276 this->MCountName = "_mcount";
277 break;
278 case llvm::Triple::arm:
279 this->MCountName = "__mcount";
280 break;
281 }
282
Duncan Sands1e90faf2009-07-08 13:55:08 +0000283 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000284};
285
Chris Lattner38e317d2010-07-07 16:01:42 +0000286// Minix Target
287template<typename Target>
288class MinixTargetInfo : public OSTargetInfo<Target> {
289protected:
290 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
291 MacroBuilder &Builder) const {
292 // Minix defines
293
294 Builder.defineMacro("__minix", "3");
295 Builder.defineMacro("_EM_WSIZE", "4");
296 Builder.defineMacro("_EM_PSIZE", "4");
297 Builder.defineMacro("_EM_SSIZE", "2");
298 Builder.defineMacro("_EM_LSIZE", "4");
299 Builder.defineMacro("_EM_FSIZE", "4");
300 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000301 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000302 DefineStd(Builder, "unix", Opts);
303 }
304public:
305 MinixTargetInfo(const std::string &triple)
306 : OSTargetInfo<Target>(triple) {
307 this->UserLabelPrefix = "";
308 }
309};
310
Torok Edwin5f6c1942009-06-30 17:10:35 +0000311// Linux target
312template<typename Target>
313class LinuxTargetInfo : public OSTargetInfo<Target> {
314protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000315 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000316 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000317 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000318 DefineStd(Builder, "unix", Opts);
319 DefineStd(Builder, "linux", Opts);
320 Builder.defineMacro("__gnu_linux__");
321 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000322 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000323 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000324 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000325 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000326 if (Opts.CPlusPlus)
327 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000328 }
329public:
Mike Stump1eb44332009-09-09 15:08:12 +0000330 LinuxTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000331 : OSTargetInfo<Target>(triple) {
332 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000333 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000334 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000335
336 virtual const char *getStaticInitSectionSpecifier() const {
337 return ".text.startup";
338 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000339};
340
Chris Lattnerb62bb282009-07-13 20:29:08 +0000341// NetBSD Target
342template<typename Target>
343class NetBSDTargetInfo : public OSTargetInfo<Target> {
344protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000345 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000346 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000347 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000348 Builder.defineMacro("__NetBSD__");
349 Builder.defineMacro("__unix__");
350 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000351 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000352 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000353 }
354public:
Mike Stump1eb44332009-09-09 15:08:12 +0000355 NetBSDTargetInfo(const std::string &triple)
Chris Lattnerb62bb282009-07-13 20:29:08 +0000356 : OSTargetInfo<Target>(triple) {
357 this->UserLabelPrefix = "";
358 }
359};
360
Torok Edwin5f6c1942009-06-30 17:10:35 +0000361// OpenBSD Target
362template<typename Target>
363class OpenBSDTargetInfo : public OSTargetInfo<Target> {
364protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000365 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000366 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000367 // OpenBSD defines; list based off of gcc output
368
Benjamin Kramera9992772010-01-09 17:55:51 +0000369 Builder.defineMacro("__OpenBSD__");
370 DefineStd(Builder, "unix", Opts);
371 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000372 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000373 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000374 }
375public:
Mike Stump1eb44332009-09-09 15:08:12 +0000376 OpenBSDTargetInfo(const std::string &triple)
Eli Friedman62d829a2011-12-15 02:15:56 +0000377 : OSTargetInfo<Target>(triple) {
378 this->UserLabelPrefix = "";
Hans Wennborge48667f2012-08-01 18:53:19 +0000379 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000380
381 llvm::Triple Triple(triple);
382 switch (Triple.getArch()) {
383 default:
384 case llvm::Triple::x86:
385 case llvm::Triple::x86_64:
386 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000387 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000388 this->MCountName = "__mcount";
389 break;
390 case llvm::Triple::mips64:
391 case llvm::Triple::mips64el:
392 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000393 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000394 this->MCountName = "_mcount";
395 break;
396 }
397 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000398};
399
Eli Friedman42f74f22012-08-08 23:57:20 +0000400// Bitrig Target
401template<typename Target>
402class BitrigTargetInfo : public OSTargetInfo<Target> {
403protected:
404 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
405 MacroBuilder &Builder) const {
406 // Bitrig defines; list based off of gcc output
407
408 Builder.defineMacro("__Bitrig__");
409 DefineStd(Builder, "unix", Opts);
410 Builder.defineMacro("__ELF__");
411 if (Opts.POSIXThreads)
412 Builder.defineMacro("_REENTRANT");
413 }
414public:
415 BitrigTargetInfo(const std::string &triple)
416 : OSTargetInfo<Target>(triple) {
417 this->UserLabelPrefix = "";
418 this->TLSSupported = false;
419 this->MCountName = "__mcount";
420 }
421};
422
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423// PSP Target
424template<typename Target>
425class PSPTargetInfo : public OSTargetInfo<Target> {
426protected:
427 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000428 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000429 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000430 Builder.defineMacro("PSP");
431 Builder.defineMacro("_PSP");
432 Builder.defineMacro("__psp__");
433 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000434 }
435public:
436 PSPTargetInfo(const std::string& triple)
437 : OSTargetInfo<Target>(triple) {
438 this->UserLabelPrefix = "";
439 }
440};
441
John Thompson3f6918a2009-11-19 17:18:50 +0000442// PS3 PPU Target
443template<typename Target>
444class PS3PPUTargetInfo : public OSTargetInfo<Target> {
445protected:
446 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000447 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000448 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000449 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000450 Builder.defineMacro("__PPU__");
451 Builder.defineMacro("__CELLOS_LV2__");
452 Builder.defineMacro("__ELF__");
453 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000454 Builder.defineMacro("_ARCH_PPC64");
455 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457public:
458 PS3PPUTargetInfo(const std::string& triple)
459 : OSTargetInfo<Target>(triple) {
460 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000461 this->LongWidth = this->LongAlign = 32;
462 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000463 this->IntMaxType = TargetInfo::SignedLongLong;
464 this->UIntMaxType = TargetInfo::UnsignedLongLong;
465 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000466 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000467 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 +0000468 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470};
471
472// FIXME: Need a real SPU target.
473// PS3 SPU Target
474template<typename Target>
475class PS3SPUTargetInfo : public OSTargetInfo<Target> {
476protected:
477 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000478 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000479 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000480 Builder.defineMacro("__SPU__");
481 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000482 }
483public:
484 PS3SPUTargetInfo(const std::string& triple)
485 : OSTargetInfo<Target>(triple) {
486 this->UserLabelPrefix = "";
487 }
488};
489
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000490// AuroraUX target
491template<typename Target>
492class AuroraUXTargetInfo : public OSTargetInfo<Target> {
493protected:
494 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000495 MacroBuilder &Builder) const {
496 DefineStd(Builder, "sun", Opts);
497 DefineStd(Builder, "unix", Opts);
498 Builder.defineMacro("__ELF__");
499 Builder.defineMacro("__svr4__");
500 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000501 }
502public:
503 AuroraUXTargetInfo(const std::string& triple)
504 : OSTargetInfo<Target>(triple) {
505 this->UserLabelPrefix = "";
506 this->WCharType = this->SignedLong;
507 // FIXME: WIntType should be SignedLong
508 }
509};
510
Torok Edwin5f6c1942009-06-30 17:10:35 +0000511// Solaris target
512template<typename Target>
513class SolarisTargetInfo : public OSTargetInfo<Target> {
514protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000515 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000516 MacroBuilder &Builder) const {
517 DefineStd(Builder, "sun", Opts);
518 DefineStd(Builder, "unix", Opts);
519 Builder.defineMacro("__ELF__");
520 Builder.defineMacro("__svr4__");
521 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000522 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
523 // newer, but to 500 for everything else. feature_test.h has a check to
524 // ensure that you are not using C99 with an old version of X/Open or C89
525 // with a new version.
526 if (Opts.C99 || Opts.C11)
527 Builder.defineMacro("_XOPEN_SOURCE", "600");
528 else
529 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000530 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000531 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000532 Builder.defineMacro("_LARGEFILE_SOURCE");
533 Builder.defineMacro("_LARGEFILE64_SOURCE");
534 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000535 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000536 }
537public:
Mike Stump1eb44332009-09-09 15:08:12 +0000538 SolarisTargetInfo(const std::string& triple)
Torok Edwin5f6c1942009-06-30 17:10:35 +0000539 : OSTargetInfo<Target>(triple) {
540 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000541 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000542 // FIXME: WIntType should be SignedLong
543 }
544};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000545
546// Windows target
547template<typename Target>
548class WindowsTargetInfo : public OSTargetInfo<Target> {
549protected:
550 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
551 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000552 Builder.defineMacro("_WIN32");
553 }
554 void getVisualStudioDefines(const LangOptions &Opts,
555 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000556 if (Opts.CPlusPlus) {
557 if (Opts.RTTI)
558 Builder.defineMacro("_CPPRTTI");
559
560 if (Opts.Exceptions)
561 Builder.defineMacro("_CPPUNWIND");
562 }
563
564 if (!Opts.CharIsSigned)
565 Builder.defineMacro("_CHAR_UNSIGNED");
566
567 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
568 // but it works for now.
569 if (Opts.POSIXThreads)
570 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000571
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000572 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000573 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000574
Francois Pichet62ec1f22011-09-17 17:15:52 +0000575 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576 Builder.defineMacro("_MSC_EXTENSIONS");
577
Richard Smith80ad52f2013-01-02 11:42:31 +0000578 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000579 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
580 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
581 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
582 }
583 }
584
585 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000586 }
587
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000588public:
589 WindowsTargetInfo(const std::string &triple)
590 : OSTargetInfo<Target>(triple) {}
591};
592
Derek Schuff7da46f92012-10-11 16:55:58 +0000593template <typename Target>
594class NaClTargetInfo : public OSTargetInfo<Target> {
595 protected:
596 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
597 MacroBuilder &Builder) const {
598 if (Opts.POSIXThreads)
599 Builder.defineMacro("_REENTRANT");
600 if (Opts.CPlusPlus)
601 Builder.defineMacro("_GNU_SOURCE");
602
603 DefineStd(Builder, "unix", Opts);
604 Builder.defineMacro("__ELF__");
605 Builder.defineMacro("__native_client__");
606 }
607 public:
608 NaClTargetInfo(const std::string &triple)
609 : OSTargetInfo<Target>(triple) {
610 this->UserLabelPrefix = "";
611 this->LongAlign = 32;
612 this->LongWidth = 32;
613 this->PointerAlign = 32;
614 this->PointerWidth = 32;
615 this->IntMaxType = TargetInfo::SignedLongLong;
616 this->UIntMaxType = TargetInfo::UnsignedLongLong;
617 this->Int64Type = TargetInfo::SignedLongLong;
618 this->DoubleAlign = 64;
619 this->LongDoubleWidth = 64;
620 this->LongDoubleAlign = 64;
621 this->SizeType = TargetInfo::UnsignedInt;
622 this->PtrDiffType = TargetInfo::SignedInt;
623 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000624 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000625 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
626 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
627 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
628 }
Derek Schuff263366f2012-10-16 22:30:41 +0000629 virtual typename Target::CallingConvCheckResult checkCallingConvention(
630 CallingConv CC) const {
631 return CC == CC_PnaclCall ? Target::CCCR_OK :
632 Target::checkCallingConvention(CC);
633 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000634};
Mike Stump1eb44332009-09-09 15:08:12 +0000635} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000636
Chris Lattnerd29b6302008-10-05 21:50:58 +0000637//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000638// Specific target implementations.
639//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000640
Eli Friedmane4277982008-08-20 23:11:40 +0000641namespace {
642// PPC abstract base class
643class PPCTargetInfo : public TargetInfo {
644 static const Builtin::Info BuiltinInfo[];
645 static const char * const GCCRegNames[];
646 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000647 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000648public:
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000649 PPCTargetInfo(const std::string& triple) : TargetInfo(triple) {
650 LongDoubleWidth = LongDoubleAlign = 128;
651 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
652 }
Eli Friedman15b91762009-06-05 07:05:05 +0000653
Hal Finkel39d5fa12012-07-03 16:51:04 +0000654 /// \brief Flags for architecture specific defines.
655 typedef enum {
656 ArchDefineNone = 0,
657 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
658 ArchDefinePpcgr = 1 << 1,
659 ArchDefinePpcsq = 1 << 2,
660 ArchDefine440 = 1 << 3,
661 ArchDefine603 = 1 << 4,
662 ArchDefine604 = 1 << 5,
663 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000664 ArchDefinePwr5 = 1 << 7,
665 ArchDefinePwr5x = 1 << 8,
666 ArchDefinePwr6 = 1 << 9,
667 ArchDefinePwr6x = 1 << 10,
668 ArchDefinePwr7 = 1 << 11,
669 ArchDefineA2 = 1 << 12,
670 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000671 } ArchDefineTypes;
672
Bill Schmidt2821e182013-02-01 20:23:10 +0000673 // Note: GCC recognizes the following additional cpus:
674 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
675 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
676 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000677 virtual bool setCPU(const std::string &Name) {
678 bool CPUKnown = llvm::StringSwitch<bool>(Name)
679 .Case("generic", true)
680 .Case("440", true)
681 .Case("450", true)
682 .Case("601", true)
683 .Case("602", true)
684 .Case("603", true)
685 .Case("603e", true)
686 .Case("603ev", true)
687 .Case("604", true)
688 .Case("604e", true)
689 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000690 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000691 .Case("g3", true)
692 .Case("7400", true)
693 .Case("g4", true)
694 .Case("7450", true)
695 .Case("g4+", true)
696 .Case("750", true)
697 .Case("970", true)
698 .Case("g5", true)
699 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000700 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000701 .Case("e500mc", true)
702 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000703 .Case("power3", true)
704 .Case("pwr3", true)
705 .Case("power4", true)
706 .Case("pwr4", true)
707 .Case("power5", true)
708 .Case("pwr5", true)
709 .Case("power5x", true)
710 .Case("pwr5x", true)
711 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000712 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000713 .Case("power6x", true)
714 .Case("pwr6x", true)
715 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000716 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000717 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000718 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000719 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000720 .Case("ppc64", true)
721 .Default(false);
722
723 if (CPUKnown)
724 CPU = Name;
725
726 return CPUKnown;
727 }
728
Eli Friedmane4277982008-08-20 23:11:40 +0000729 virtual void getTargetBuiltins(const Builtin::Info *&Records,
730 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000731 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000732 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000733 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000734
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000735 virtual bool isCLZForZeroUndef() const { return false; }
736
Chris Lattner33328642009-03-20 15:52:06 +0000737 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000738 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000739
Bill Schmidt199402b2013-02-01 02:14:03 +0000740 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
741
742 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
743 StringRef Name,
744 bool Enabled) const;
745
Douglas Gregore727d212012-01-30 06:38:25 +0000746 virtual bool hasFeature(StringRef Feature) const;
747
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000748 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000749 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000750 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000751 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000752 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000753 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000754 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000755 default: return false;
756 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000757 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000758 case 'b': // Base register
759 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000760 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000761 break;
762 // FIXME: The following are added to allow parsing.
763 // I just took a guess at what the actions should be.
764 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000765 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000766 case 'v': // Altivec vector register
767 Info.setAllowsRegister();
768 break;
769 case 'w':
770 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000771 case 'd':// VSX vector register to hold vector double data
772 case 'f':// VSX vector register to hold vector float data
773 case 's':// VSX vector register to hold scalar float data
774 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000775 break;
776 default:
777 return false;
778 }
779 Info.setAllowsRegister();
780 Name++; // Skip over 'w'.
781 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000782 case 'h': // `MQ', `CTR', or `LINK' register
783 case 'q': // `MQ' register
784 case 'c': // `CTR' register
785 case 'l': // `LINK' register
786 case 'x': // `CR' register (condition register) number 0
787 case 'y': // `CR' register (condition register)
788 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000789 Info.setAllowsRegister();
790 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000791 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000792 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000793 // (use `L' instead for SImode constants)
794 case 'K': // Unsigned 16-bit constant
795 case 'L': // Signed 16-bit constant shifted left 16 bits
796 case 'M': // Constant larger than 31
797 case 'N': // Exact power of 2
798 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000799 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000800 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000801 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000802 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000803 break;
804 case 'm': // Memory operand. Note that on PowerPC targets, m can
805 // include addresses that update the base register. It
806 // is therefore only safe to use `m' in an asm statement
807 // if that asm statement accesses the operand exactly once.
808 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000809 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000810 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000811 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000813 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
814 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000815 // register to be updated.
816 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000817 if (Name[1] != 's')
818 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000819 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000820 // include any automodification of the base register. Unlike
821 // `m', this constraint can be used in asm statements that
822 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000823 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000824 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000825 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000826 break;
827 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000828 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000829 case 'Z': // Memory operand that is an indexed or indirect from a
830 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000831 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000832 Info.setAllowsMemory();
833 Info.setAllowsRegister();
834 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000835 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000836 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000837 // register (`p' is preferable for asm statements)
838 case 'S': // Constant suitable as a 64-bit mask operand
839 case 'T': // Constant suitable as a 32-bit mask operand
840 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000841 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000842 // instructions
843 case 'W': // Vector constant that does not require memory
844 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000845 break;
846 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000847 }
John Thompson8e6065a2010-06-24 22:44:13 +0000848 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000849 }
Eli Friedmane4277982008-08-20 23:11:40 +0000850 virtual const char *getClobbers() const {
851 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000852 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000853 int getEHDataRegisterNumber(unsigned RegNo) const {
854 if (RegNo == 0) return 3;
855 if (RegNo == 1) return 4;
856 return -1;
857 }
Eli Friedmane4277982008-08-20 23:11:40 +0000858};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000859
Eli Friedmane4277982008-08-20 23:11:40 +0000860const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000861#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000862#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000863 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000864#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000865};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000866
867
Chris Lattnerc0f59212009-03-02 22:27:17 +0000868/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
869/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000870void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000871 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000872 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000873 Builder.defineMacro("__ppc__");
874 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000875 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000876 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000877 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000878 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000879 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000880 Builder.defineMacro("__ppc64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000881 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +0000882 Builder.defineMacro("__ppc__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000883 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000884
Chris Lattnerc0f59212009-03-02 22:27:17 +0000885 // Target properties.
Hans Wennborg5e601dc2012-08-02 13:45:48 +0000886 if (getTriple().getOS() != llvm::Triple::NetBSD &&
887 getTriple().getOS() != llvm::Triple::OpenBSD)
Joerg Sonnenberger7cd1de52011-07-05 14:56:12 +0000888 Builder.defineMacro("_BIG_ENDIAN");
Benjamin Kramera9992772010-01-09 17:55:51 +0000889 Builder.defineMacro("__BIG_ENDIAN__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000890
Chris Lattnerc0f59212009-03-02 22:27:17 +0000891 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000892 Builder.defineMacro("__NATURAL_ALIGNMENT__");
893 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000894
Chris Lattnerc0f59212009-03-02 22:27:17 +0000895 // FIXME: Should be controlled by command line option.
Benjamin Kramera9992772010-01-09 17:55:51 +0000896 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000897
John Thompson3f6918a2009-11-19 17:18:50 +0000898 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000899 Builder.defineMacro("__VEC__", "10206");
900 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000901 }
Hal Finkel02a84272012-06-11 22:35:19 +0000902
903 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000904 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
905 .Case("440", ArchDefineName)
906 .Case("450", ArchDefineName | ArchDefine440)
907 .Case("601", ArchDefineName)
908 .Case("602", ArchDefineName | ArchDefinePpcgr)
909 .Case("603", ArchDefineName | ArchDefinePpcgr)
910 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
911 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
912 .Case("604", ArchDefineName | ArchDefinePpcgr)
913 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
914 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000915 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000916 .Case("7400", ArchDefineName | ArchDefinePpcgr)
917 .Case("7450", ArchDefineName | ArchDefinePpcgr)
918 .Case("750", ArchDefineName | ArchDefinePpcgr)
919 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
920 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000921 .Case("a2", ArchDefineA2)
922 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000923 .Case("pwr3", ArchDefinePpcgr)
924 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
925 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
926 | ArchDefinePpcsq)
927 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
928 | ArchDefinePpcgr | ArchDefinePpcsq)
929 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
930 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
931 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
932 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
933 | ArchDefinePpcsq)
934 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
935 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
936 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
937 .Case("power3", ArchDefinePpcgr)
938 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
939 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
940 | ArchDefinePpcsq)
941 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
942 | ArchDefinePpcgr | ArchDefinePpcsq)
943 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
944 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
945 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
946 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
947 | ArchDefinePpcsq)
948 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
949 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
950 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000951 .Default(ArchDefineNone);
952
953 if (defs & ArchDefineName)
954 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
955 if (defs & ArchDefinePpcgr)
956 Builder.defineMacro("_ARCH_PPCGR");
957 if (defs & ArchDefinePpcsq)
958 Builder.defineMacro("_ARCH_PPCSQ");
959 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000960 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000961 if (defs & ArchDefine603)
962 Builder.defineMacro("_ARCH_603");
963 if (defs & ArchDefine604)
964 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000965 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000966 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000967 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000968 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000969 if (defs & ArchDefinePwr5x)
970 Builder.defineMacro("_ARCH_PWR5X");
971 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000972 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000973 if (defs & ArchDefinePwr6x)
974 Builder.defineMacro("_ARCH_PWR6X");
975 if (defs & ArchDefinePwr7)
976 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000977 if (defs & ArchDefineA2)
978 Builder.defineMacro("_ARCH_A2");
979 if (defs & ArchDefineA2q) {
980 Builder.defineMacro("_ARCH_A2Q");
981 Builder.defineMacro("_ARCH_QP");
982 }
983
984 if (getTriple().getVendor() == llvm::Triple::BGQ) {
985 Builder.defineMacro("__bg__");
986 Builder.defineMacro("__THW_BLUEGENE__");
987 Builder.defineMacro("__bgq__");
988 Builder.defineMacro("__TOS_BGQ__");
989 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000990
991 // FIXME: The following are not yet generated here by Clang, but are
992 // generated by GCC:
993 //
994 // _SOFT_FLOAT_
995 // __RECIP_PRECISION__
996 // __APPLE_ALTIVEC__
997 // __VSX__
998 // __RECIP__
999 // __RECIPF__
1000 // __RSQRTE__
1001 // __RSQRTEF__
1002 // _SOFT_DOUBLE_
1003 // __NO_LWSYNC__
1004 // __HAVE_BSWAP__
1005 // __LONGDOUBLE128
1006 // __CMODEL_MEDIUM__
1007 // __CMODEL_LARGE__
1008 // _CALL_SYSV
1009 // _CALL_DARWIN
1010 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001011}
1012
1013void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1014 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1015 .Case("7400", true)
1016 .Case("g4", true)
1017 .Case("7450", true)
1018 .Case("g4+", true)
1019 .Case("970", true)
1020 .Case("g5", true)
1021 .Case("pwr6", true)
1022 .Case("pwr7", true)
1023 .Case("ppc64", true)
1024 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001025
1026 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001027}
1028
1029bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1030 StringRef Name,
1031 bool Enabled) const {
Hal Finkelfe6b2712013-03-30 13:47:44 +00001032 if (Name == "altivec" || Name == "fprnd" || Name == "mfocrf" ||
1033 Name == "popcntd" || Name == "qpx") {
Bill Schmidt199402b2013-02-01 02:14:03 +00001034 Features[Name] = Enabled;
1035 return true;
Hal Finkel02a84272012-06-11 22:35:19 +00001036 }
Bill Schmidt199402b2013-02-01 02:14:03 +00001037
1038 return false;
Chris Lattnerc0f59212009-03-02 22:27:17 +00001039}
1040
Douglas Gregore727d212012-01-30 06:38:25 +00001041bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1042 return Feature == "powerpc";
1043}
Chris Lattner393ff042008-04-21 18:56:49 +00001044
Douglas Gregore727d212012-01-30 06:38:25 +00001045
Eli Friedmane4277982008-08-20 23:11:40 +00001046const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001047 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1048 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1049 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1050 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1051 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1052 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1053 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1054 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001055 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001056 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001057 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001058 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1059 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1060 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1061 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001062 "vrsave", "vscr",
1063 "spe_acc", "spefscr",
1064 "sfp"
1065};
Reid Spencer5f016e22007-07-11 17:01:13 +00001066
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001067void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001068 unsigned &NumNames) const {
1069 Names = GCCRegNames;
1070 NumNames = llvm::array_lengthof(GCCRegNames);
1071}
Reid Spencer5f016e22007-07-11 17:01:13 +00001072
Eli Friedmane4277982008-08-20 23:11:40 +00001073const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1074 // While some of these aliases do map to different registers
1075 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001076 { { "0" }, "r0" },
1077 { { "1"}, "r1" },
1078 { { "2" }, "r2" },
1079 { { "3" }, "r3" },
1080 { { "4" }, "r4" },
1081 { { "5" }, "r5" },
1082 { { "6" }, "r6" },
1083 { { "7" }, "r7" },
1084 { { "8" }, "r8" },
1085 { { "9" }, "r9" },
1086 { { "10" }, "r10" },
1087 { { "11" }, "r11" },
1088 { { "12" }, "r12" },
1089 { { "13" }, "r13" },
1090 { { "14" }, "r14" },
1091 { { "15" }, "r15" },
1092 { { "16" }, "r16" },
1093 { { "17" }, "r17" },
1094 { { "18" }, "r18" },
1095 { { "19" }, "r19" },
1096 { { "20" }, "r20" },
1097 { { "21" }, "r21" },
1098 { { "22" }, "r22" },
1099 { { "23" }, "r23" },
1100 { { "24" }, "r24" },
1101 { { "25" }, "r25" },
1102 { { "26" }, "r26" },
1103 { { "27" }, "r27" },
1104 { { "28" }, "r28" },
1105 { { "29" }, "r29" },
1106 { { "30" }, "r30" },
1107 { { "31" }, "r31" },
1108 { { "fr0" }, "f0" },
1109 { { "fr1" }, "f1" },
1110 { { "fr2" }, "f2" },
1111 { { "fr3" }, "f3" },
1112 { { "fr4" }, "f4" },
1113 { { "fr5" }, "f5" },
1114 { { "fr6" }, "f6" },
1115 { { "fr7" }, "f7" },
1116 { { "fr8" }, "f8" },
1117 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001118 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001119 { { "fr11" }, "f11" },
1120 { { "fr12" }, "f12" },
1121 { { "fr13" }, "f13" },
1122 { { "fr14" }, "f14" },
1123 { { "fr15" }, "f15" },
1124 { { "fr16" }, "f16" },
1125 { { "fr17" }, "f17" },
1126 { { "fr18" }, "f18" },
1127 { { "fr19" }, "f19" },
1128 { { "fr20" }, "f20" },
1129 { { "fr21" }, "f21" },
1130 { { "fr22" }, "f22" },
1131 { { "fr23" }, "f23" },
1132 { { "fr24" }, "f24" },
1133 { { "fr25" }, "f25" },
1134 { { "fr26" }, "f26" },
1135 { { "fr27" }, "f27" },
1136 { { "fr28" }, "f28" },
1137 { { "fr29" }, "f29" },
1138 { { "fr30" }, "f30" },
1139 { { "fr31" }, "f31" },
1140 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001141};
1142
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001143void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001144 unsigned &NumAliases) const {
1145 Aliases = GCCRegAliases;
1146 NumAliases = llvm::array_lengthof(GCCRegAliases);
1147}
1148} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001149
1150namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001151class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001152public:
Chris Lattnere03ae302010-02-16 18:14:57 +00001153 PPC32TargetInfo(const std::string &triple) : PPCTargetInfo(triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001154 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 +00001155 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001156
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001157 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001158 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001159 case llvm::Triple::FreeBSD:
1160 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001161 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001162 PtrDiffType = SignedInt;
1163 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001164 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001165 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001166 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001167 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001168
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001169 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1170 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001171 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001172 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001173
1174 // PPC32 supports atomics up to 4 bytes.
1175 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001176 }
1177
Meador Ingec5613b22012-06-16 03:34:49 +00001178 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001179 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001180 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001181 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001182};
1183} // end anonymous namespace.
1184
1185namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001186class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001187public:
Eli Friedmane4277982008-08-20 23:11:40 +00001188 PPC64TargetInfo(const std::string& triple) : PPCTargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001189 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001190 IntMaxType = SignedLong;
1191 UIntMaxType = UnsignedLong;
1192 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001193
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001194 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1195 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001196 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001197 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1198 "i64:64:64-f32:32:32-f64:64:64-f128:64:64-"
1199 "v128:128:128-n32:64";
1200 } else
1201 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1202 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1203 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001204
1205 // PPC64 supports atomics up to 8 bytes.
1206 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001207 }
Meador Ingec5613b22012-06-16 03:34:49 +00001208 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1209 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001210 }
Eli Friedmane4277982008-08-20 23:11:40 +00001211};
1212} // end anonymous namespace.
1213
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001214
1215namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001216class DarwinPPC32TargetInfo :
1217 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001218public:
Roman Divackyc81f2a22011-01-06 08:27:10 +00001219 DarwinPPC32TargetInfo(const std::string& triple)
1220 : DarwinTargetInfo<PPC32TargetInfo>(triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001221 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001222 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001223 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001224 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001225 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1226 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001227 }
Meador Ingec5613b22012-06-16 03:34:49 +00001228 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1229 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001230 }
1231};
1232
1233class DarwinPPC64TargetInfo :
1234 public DarwinTargetInfo<PPC64TargetInfo> {
1235public:
1236 DarwinPPC64TargetInfo(const std::string& triple)
1237 : DarwinTargetInfo<PPC64TargetInfo>(triple) {
1238 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001239 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001240 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1241 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001242 }
1243};
1244} // end anonymous namespace.
1245
Reid Spencer5f016e22007-07-11 17:01:13 +00001246namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001247 static const unsigned NVPTXAddrSpaceMap[] = {
1248 1, // opencl_global
1249 3, // opencl_local
1250 4, // opencl_constant
1251 1, // cuda_device
1252 4, // cuda_constant
1253 3, // cuda_shared
1254 };
1255 class NVPTXTargetInfo : public TargetInfo {
1256 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001257 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001258 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 public:
1260 NVPTXTargetInfo(const std::string& triple) : TargetInfo(triple) {
1261 BigEndian = false;
1262 TLSSupported = false;
1263 LongWidth = LongAlign = 64;
1264 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001265 // Define available target features
1266 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001267 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001268 }
1269 virtual void getTargetDefines(const LangOptions &Opts,
1270 MacroBuilder &Builder) const {
1271 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001272 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001273 }
1274 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1275 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001276 Records = BuiltinInfo;
1277 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001278 }
1279 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001280 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001281 }
1282
1283 virtual void getGCCRegNames(const char * const *&Names,
1284 unsigned &NumNames) const;
1285 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1286 unsigned &NumAliases) const {
1287 // No aliases.
1288 Aliases = 0;
1289 NumAliases = 0;
1290 }
1291 virtual bool validateAsmConstraint(const char *&Name,
1292 TargetInfo::ConstraintInfo &info) const {
1293 // FIXME: implement
1294 return true;
1295 }
1296 virtual const char *getClobbers() const {
1297 // FIXME: Is this really right?
1298 return "";
1299 }
Meador Ingec5613b22012-06-16 03:34:49 +00001300 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001301 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001302 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001303 }
1304 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001305 bool Valid = llvm::StringSwitch<bool>(Name)
1306 .Case("sm_20", true)
1307 .Case("sm_21", true)
1308 .Case("sm_30", true)
1309 .Case("sm_35", true)
1310 .Default(false);
1311
1312 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001313 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001314 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1315 StringRef Name,
1316 bool Enabled) const;
1317 };
1318
1319 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1320#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1321#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1322 ALL_LANGUAGES },
1323#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001324 };
1325
1326 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1327 "r0"
1328 };
1329
1330 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1331 unsigned &NumNames) const {
1332 Names = GCCRegNames;
1333 NumNames = llvm::array_lengthof(GCCRegNames);
1334 }
1335
Justin Holewinski2c585b92012-05-24 17:43:12 +00001336 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1337 StringRef Name,
1338 bool Enabled) const {
1339 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1340 Name)) {
1341 Features[Name] = Enabled;
1342 return true;
1343 } else {
1344 return false;
1345 }
1346 }
1347
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001348 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1349 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001350 NVPTX32TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001351 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001352 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001353 DescriptionString
1354 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1355 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1356 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001357 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001358 };
1359
1360 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1361 public:
Justin Holewinski2c585b92012-05-24 17:43:12 +00001362 NVPTX64TargetInfo(const std::string& triple) : NVPTXTargetInfo(triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001363 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001364 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001365 DescriptionString
1366 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1367 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1368 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001369 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001370 };
1371}
1372
1373namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001374
1375static const unsigned R600AddrSpaceMap[] = {
1376 1, // opencl_global
1377 3, // opencl_local
1378 2, // opencl_constant
1379 1, // cuda_device
1380 2, // cuda_constant
1381 3 // cuda_shared
1382};
1383
Tom Stellardfd075912013-03-04 17:40:53 +00001384static const char *DescriptionStringR600 =
1385 "e"
1386 "-p:32:32:32"
1387 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1388 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1389 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1390 "-n32:64";
1391
1392static const char *DescriptionStringR600DoubleOps =
1393 "e"
1394 "-p:32:32:32"
1395 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1396 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1397 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1398 "-n32:64";
1399
1400static const char *DescriptionStringSI =
1401 "e"
1402 "-p:64:64:64"
1403 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1404 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1405 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1406 "-n32:64";
1407
Eli Friedman6505a292012-10-12 23:32:00 +00001408class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001409 /// \brief The GPU profiles supported by the R600 target.
1410 enum GPUKind {
1411 GK_NONE,
1412 GK_R600,
1413 GK_R600_DOUBLE_OPS,
1414 GK_R700,
1415 GK_R700_DOUBLE_OPS,
1416 GK_EVERGREEN,
1417 GK_EVERGREEN_DOUBLE_OPS,
1418 GK_NORTHERN_ISLANDS,
1419 GK_CAYMAN,
1420 GK_SOUTHERN_ISLANDS
1421 } GPU;
1422
Eli Friedman6505a292012-10-12 23:32:00 +00001423public:
Tom Stellardfd075912013-03-04 17:40:53 +00001424 R600TargetInfo(const std::string& triple)
1425 : TargetInfo(triple),
1426 GPU(GK_R600) {
1427 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001428 AddrSpaceMap = &R600AddrSpaceMap;
1429 }
1430
1431 virtual const char * getClobbers() const {
1432 return "";
1433 }
1434
1435 virtual void getGCCRegNames(const char * const *&Names,
1436 unsigned &numNames) const {
1437 Names = NULL;
1438 numNames = 0;
1439 }
1440
1441 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1442 unsigned &NumAliases) const {
1443 Aliases = NULL;
1444 NumAliases = 0;
1445 }
1446
1447 virtual bool validateAsmConstraint(const char *&Name,
1448 TargetInfo::ConstraintInfo &info) const {
1449 return true;
1450 }
1451
1452 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1453 unsigned &NumRecords) const {
1454 Records = NULL;
1455 NumRecords = 0;
1456 }
1457
1458
1459 virtual void getTargetDefines(const LangOptions &Opts,
1460 MacroBuilder &Builder) const {
1461 Builder.defineMacro("__R600__");
1462 }
1463
1464 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1465 return TargetInfo::CharPtrBuiltinVaList;
1466 }
1467
Tom Stellardfd075912013-03-04 17:40:53 +00001468 virtual bool setCPU(const std::string &Name) {
1469 GPU = llvm::StringSwitch<GPUKind>(Name)
1470 .Case("r600" , GK_R600)
1471 .Case("rv610", GK_R600)
1472 .Case("rv620", GK_R600)
1473 .Case("rv630", GK_R600)
1474 .Case("rv635", GK_R600)
1475 .Case("rs780", GK_R600)
1476 .Case("rs880", GK_R600)
1477 .Case("rv670", GK_R600_DOUBLE_OPS)
1478 .Case("rv710", GK_R700)
1479 .Case("rv730", GK_R700)
1480 .Case("rv740", GK_R700_DOUBLE_OPS)
1481 .Case("rv770", GK_R700_DOUBLE_OPS)
1482 .Case("palm", GK_EVERGREEN)
1483 .Case("cedar", GK_EVERGREEN)
1484 .Case("sumo", GK_EVERGREEN)
1485 .Case("sumo2", GK_EVERGREEN)
1486 .Case("redwood", GK_EVERGREEN)
1487 .Case("juniper", GK_EVERGREEN)
1488 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1489 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1490 .Case("barts", GK_NORTHERN_ISLANDS)
1491 .Case("turks", GK_NORTHERN_ISLANDS)
1492 .Case("caicos", GK_NORTHERN_ISLANDS)
1493 .Case("cayman", GK_CAYMAN)
1494 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001495 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001496 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1497 .Case("verde", GK_SOUTHERN_ISLANDS)
1498 .Case("oland", GK_SOUTHERN_ISLANDS)
1499 .Default(GK_NONE);
1500
1501 if (GPU == GK_NONE) {
1502 return false;
1503 }
1504
1505 // Set the correct data layout
1506 switch (GPU) {
1507 case GK_NONE:
1508 case GK_R600:
1509 case GK_R700:
1510 case GK_EVERGREEN:
1511 case GK_NORTHERN_ISLANDS:
1512 DescriptionString = DescriptionStringR600;
1513 break;
1514 case GK_R600_DOUBLE_OPS:
1515 case GK_R700_DOUBLE_OPS:
1516 case GK_EVERGREEN_DOUBLE_OPS:
1517 case GK_CAYMAN:
1518 DescriptionString = DescriptionStringR600DoubleOps;
1519 break;
1520 case GK_SOUTHERN_ISLANDS:
1521 DescriptionString = DescriptionStringSI;
1522 break;
1523 }
1524
1525 return true;
1526 }
Eli Friedman6505a292012-10-12 23:32:00 +00001527};
1528
1529} // end anonymous namespace
1530
1531namespace {
Chris Lattner9cbeb632010-03-06 21:21:27 +00001532// MBlaze abstract base class
1533class MBlazeTargetInfo : public TargetInfo {
1534 static const char * const GCCRegNames[];
1535 static const TargetInfo::GCCRegAlias GCCRegAliases[];
1536
1537public:
1538 MBlazeTargetInfo(const std::string& triple) : TargetInfo(triple) {
Wesley Pecka48fa4b2010-12-12 20:56:47 +00001539 DescriptionString = "E-p:32:32:32-i8:8:8-i16:16:16";
Chris Lattner9cbeb632010-03-06 21:21:27 +00001540 }
1541
1542 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1543 unsigned &NumRecords) const {
1544 // FIXME: Implement.
1545 Records = 0;
1546 NumRecords = 0;
1547 }
1548
1549 virtual void getTargetDefines(const LangOptions &Opts,
1550 MacroBuilder &Builder) const;
1551
Douglas Gregore727d212012-01-30 06:38:25 +00001552 virtual bool hasFeature(StringRef Feature) const {
1553 return Feature == "mblaze";
1554 }
1555
Meador Ingec5613b22012-06-16 03:34:49 +00001556 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1557 return TargetInfo::CharPtrBuiltinVaList;
Chris Lattner9cbeb632010-03-06 21:21:27 +00001558 }
1559 virtual const char *getTargetPrefix() const {
1560 return "mblaze";
1561 }
1562 virtual void getGCCRegNames(const char * const *&Names,
1563 unsigned &NumNames) const;
1564 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1565 unsigned &NumAliases) const;
1566 virtual bool validateAsmConstraint(const char *&Name,
1567 TargetInfo::ConstraintInfo &Info) const {
1568 switch (*Name) {
1569 default: return false;
1570 case 'O': // Zero
1571 return true;
1572 case 'b': // Base register
1573 case 'f': // Floating point register
1574 Info.setAllowsRegister();
1575 return true;
1576 }
1577 }
1578 virtual const char *getClobbers() const {
1579 return "";
1580 }
1581};
1582
1583/// MBlazeTargetInfo::getTargetDefines - Return a set of the MBlaze-specific
1584/// #defines that are not tied to a specific subtarget.
1585void MBlazeTargetInfo::getTargetDefines(const LangOptions &Opts,
1586 MacroBuilder &Builder) const {
1587 // Target identification.
1588 Builder.defineMacro("__microblaze__");
1589 Builder.defineMacro("_ARCH_MICROBLAZE");
1590 Builder.defineMacro("__MICROBLAZE__");
1591
1592 // Target properties.
1593 Builder.defineMacro("_BIG_ENDIAN");
1594 Builder.defineMacro("__BIG_ENDIAN__");
1595
1596 // Subtarget options.
1597 Builder.defineMacro("__REGISTER_PREFIX__", "");
1598}
1599
1600
1601const char * const MBlazeTargetInfo::GCCRegNames[] = {
1602 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1603 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1604 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1605 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1606 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
1607 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
1608 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
1609 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
1610 "hi", "lo", "accum","rmsr", "$fcc1","$fcc2","$fcc3","$fcc4",
1611 "$fcc5","$fcc6","$fcc7","$ap", "$rap", "$frp"
1612};
1613
1614void MBlazeTargetInfo::getGCCRegNames(const char * const *&Names,
1615 unsigned &NumNames) const {
1616 Names = GCCRegNames;
1617 NumNames = llvm::array_lengthof(GCCRegNames);
1618}
1619
1620const TargetInfo::GCCRegAlias MBlazeTargetInfo::GCCRegAliases[] = {
1621 { {"f0"}, "r0" },
1622 { {"f1"}, "r1" },
1623 { {"f2"}, "r2" },
1624 { {"f3"}, "r3" },
1625 { {"f4"}, "r4" },
1626 { {"f5"}, "r5" },
1627 { {"f6"}, "r6" },
1628 { {"f7"}, "r7" },
1629 { {"f8"}, "r8" },
1630 { {"f9"}, "r9" },
1631 { {"f10"}, "r10" },
1632 { {"f11"}, "r11" },
1633 { {"f12"}, "r12" },
1634 { {"f13"}, "r13" },
1635 { {"f14"}, "r14" },
1636 { {"f15"}, "r15" },
1637 { {"f16"}, "r16" },
1638 { {"f17"}, "r17" },
1639 { {"f18"}, "r18" },
1640 { {"f19"}, "r19" },
1641 { {"f20"}, "r20" },
1642 { {"f21"}, "r21" },
1643 { {"f22"}, "r22" },
1644 { {"f23"}, "r23" },
1645 { {"f24"}, "r24" },
1646 { {"f25"}, "r25" },
1647 { {"f26"}, "r26" },
1648 { {"f27"}, "r27" },
1649 { {"f28"}, "r28" },
1650 { {"f29"}, "r29" },
1651 { {"f30"}, "r30" },
1652 { {"f31"}, "r31" },
1653};
1654
1655void MBlazeTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
1656 unsigned &NumAliases) const {
1657 Aliases = GCCRegAliases;
1658 NumAliases = llvm::array_lengthof(GCCRegAliases);
1659}
1660} // end anonymous namespace.
1661
1662namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001663// Namespace for x86 abstract base class
1664const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001665#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001666#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001667 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001668#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001669};
Eli Friedman61538a72008-05-20 14:21:01 +00001670
Nuno Lopes2550d702009-12-23 17:49:57 +00001671static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001672 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1673 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001674 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001675 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1676 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1677 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001678 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001679 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1680 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001681};
1682
Eric Christophercfd323d2011-06-21 00:05:20 +00001683const TargetInfo::AddlRegName AddlRegNames[] = {
1684 { { "al", "ah", "eax", "rax" }, 0 },
1685 { { "bl", "bh", "ebx", "rbx" }, 3 },
1686 { { "cl", "ch", "ecx", "rcx" }, 2 },
1687 { { "dl", "dh", "edx", "rdx" }, 1 },
1688 { { "esi", "rsi" }, 4 },
1689 { { "edi", "rdi" }, 5 },
1690 { { "esp", "rsp" }, 7 },
1691 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001692};
1693
1694// X86 target abstract base class; x86-32 and x86-64 are very close, so
1695// most of the implementation can be shared.
1696class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001697 enum X86SSEEnum {
Craig Topper05fe4b52012-01-09 09:19:09 +00001698 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001699 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001700 enum MMX3DNowEnum {
1701 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1702 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001703
Eric Christophereea12d12010-04-02 23:50:19 +00001704 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001705 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001706 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001707 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001708 bool HasBMI;
1709 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001710 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001711 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001712 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001713 bool HasRDSEED;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001714 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001715 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001716 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001717 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001718 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001719
Chandler Carruth499d9722011-09-28 08:55:34 +00001720 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1721 ///
1722 /// Each enumeration represents a particular CPU supported by Clang. These
1723 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1724 enum CPUKind {
1725 CK_Generic,
1726
1727 /// \name i386
1728 /// i386-generation processors.
1729 //@{
1730 CK_i386,
1731 //@}
1732
1733 /// \name i486
1734 /// i486-generation processors.
1735 //@{
1736 CK_i486,
1737 CK_WinChipC6,
1738 CK_WinChip2,
1739 CK_C3,
1740 //@}
1741
1742 /// \name i586
1743 /// i586-generation processors, P5 microarchitecture based.
1744 //@{
1745 CK_i586,
1746 CK_Pentium,
1747 CK_PentiumMMX,
1748 //@}
1749
1750 /// \name i686
1751 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1752 //@{
1753 CK_i686,
1754 CK_PentiumPro,
1755 CK_Pentium2,
1756 CK_Pentium3,
1757 CK_Pentium3M,
1758 CK_PentiumM,
1759 CK_C3_2,
1760
1761 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1762 /// Clang however has some logic to suport this.
1763 // FIXME: Warn, deprecate, and potentially remove this.
1764 CK_Yonah,
1765 //@}
1766
1767 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001768 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001769 //@{
1770 CK_Pentium4,
1771 CK_Pentium4M,
1772 CK_Prescott,
1773 CK_Nocona,
1774 //@}
1775
1776 /// \name Core
1777 /// Core microarchitecture based processors.
1778 //@{
1779 CK_Core2,
1780
1781 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1782 /// codename which GCC no longer accepts as an option to -march, but Clang
1783 /// has some logic for recognizing it.
1784 // FIXME: Warn, deprecate, and potentially remove this.
1785 CK_Penryn,
1786 //@}
1787
1788 /// \name Atom
1789 /// Atom processors
1790 //@{
1791 CK_Atom,
1792 //@}
1793
1794 /// \name Nehalem
1795 /// Nehalem microarchitecture based processors.
1796 //@{
1797 CK_Corei7,
1798 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001799 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001800 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001801 //@}
1802
1803 /// \name K6
1804 /// K6 architecture processors.
1805 //@{
1806 CK_K6,
1807 CK_K6_2,
1808 CK_K6_3,
1809 //@}
1810
1811 /// \name K7
1812 /// K7 architecture processors.
1813 //@{
1814 CK_Athlon,
1815 CK_AthlonThunderbird,
1816 CK_Athlon4,
1817 CK_AthlonXP,
1818 CK_AthlonMP,
1819 //@}
1820
1821 /// \name K8
1822 /// K8 architecture processors.
1823 //@{
1824 CK_Athlon64,
1825 CK_Athlon64SSE3,
1826 CK_AthlonFX,
1827 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001828 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001829 CK_Opteron,
1830 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001831 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001832 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001833
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001834 /// \name Bobcat
1835 /// Bobcat architecture processors.
1836 //@{
1837 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001838 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001839 //@}
1840
1841 /// \name Bulldozer
1842 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001843 //@{
1844 CK_BDVER1,
1845 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001846 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001847
Chandler Carruth499d9722011-09-28 08:55:34 +00001848 /// This specification is deprecated and will be removed in the future.
1849 /// Users should prefer \see CK_K8.
1850 // FIXME: Warn on this when the CPU is set to it.
1851 CK_x86_64,
1852 //@}
1853
1854 /// \name Geode
1855 /// Geode processors.
1856 //@{
1857 CK_Geode
1858 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001859 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001860
Eli Friedman618234a2008-08-20 02:34:37 +00001861public:
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001862 X86TargetInfo(const std::string& triple)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001863 : TargetInfo(triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Benjamin Kramer84f30802012-07-07 09:39:18 +00001864 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
Michael Liao463eb892012-11-10 05:17:46 +00001865 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
Michael Liao1bfc28c2013-03-29 05:17:55 +00001866 HasPRFCHW(false), HasRDSEED(false), HasSSE4a(false), HasFMA4(false),
Michael Liao72339a02013-03-26 17:52:08 +00001867 HasFMA(false), HasXOP(false), HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001868 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001869 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001870 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001871 virtual unsigned getFloatEvalMethod() const {
1872 // X87 evaluates with 80 bits "long double" precision.
1873 return SSELevel == NoSSE ? 2 : 0;
1874 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001875 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1876 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001877 Records = BuiltinInfo;
1878 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001879 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001880 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001881 unsigned &NumNames) const {
1882 Names = GCCRegNames;
1883 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001884 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001885 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001886 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001887 Aliases = 0;
1888 NumAliases = 0;
1889 }
1890 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001891 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001892 Names = AddlRegNames;
1893 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001894 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001895 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001896 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001897 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001898 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001899 return "~{dirflag},~{fpsr},~{flags}";
1900 }
Chris Lattner33328642009-03-20 15:52:06 +00001901 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001902 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001903 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001904 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001905 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001906 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001907 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001908 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001909 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001910 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001911 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001912 else if (getTriple().getArch() == llvm::Triple::x86 &&
1913 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001914 return "no-mmx";
1915 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001916 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001917 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001918 CPU = llvm::StringSwitch<CPUKind>(Name)
1919 .Case("i386", CK_i386)
1920 .Case("i486", CK_i486)
1921 .Case("winchip-c6", CK_WinChipC6)
1922 .Case("winchip2", CK_WinChip2)
1923 .Case("c3", CK_C3)
1924 .Case("i586", CK_i586)
1925 .Case("pentium", CK_Pentium)
1926 .Case("pentium-mmx", CK_PentiumMMX)
1927 .Case("i686", CK_i686)
1928 .Case("pentiumpro", CK_PentiumPro)
1929 .Case("pentium2", CK_Pentium2)
1930 .Case("pentium3", CK_Pentium3)
1931 .Case("pentium3m", CK_Pentium3M)
1932 .Case("pentium-m", CK_PentiumM)
1933 .Case("c3-2", CK_C3_2)
1934 .Case("yonah", CK_Yonah)
1935 .Case("pentium4", CK_Pentium4)
1936 .Case("pentium4m", CK_Pentium4M)
1937 .Case("prescott", CK_Prescott)
1938 .Case("nocona", CK_Nocona)
1939 .Case("core2", CK_Core2)
1940 .Case("penryn", CK_Penryn)
1941 .Case("atom", CK_Atom)
1942 .Case("corei7", CK_Corei7)
1943 .Case("corei7-avx", CK_Corei7AVX)
1944 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001945 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001946 .Case("k6", CK_K6)
1947 .Case("k6-2", CK_K6_2)
1948 .Case("k6-3", CK_K6_3)
1949 .Case("athlon", CK_Athlon)
1950 .Case("athlon-tbird", CK_AthlonThunderbird)
1951 .Case("athlon-4", CK_Athlon4)
1952 .Case("athlon-xp", CK_AthlonXP)
1953 .Case("athlon-mp", CK_AthlonMP)
1954 .Case("athlon64", CK_Athlon64)
1955 .Case("athlon64-sse3", CK_Athlon64SSE3)
1956 .Case("athlon-fx", CK_AthlonFX)
1957 .Case("k8", CK_K8)
1958 .Case("k8-sse3", CK_K8SSE3)
1959 .Case("opteron", CK_Opteron)
1960 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001961 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001962 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001963 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001964 .Case("bdver1", CK_BDVER1)
1965 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001966 .Case("x86-64", CK_x86_64)
1967 .Case("geode", CK_Geode)
1968 .Default(CK_Generic);
1969
Chandler Carruth26a39142011-09-28 09:45:08 +00001970 // Perform any per-CPU checks necessary to determine if this CPU is
1971 // acceptable.
1972 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1973 // invalid without explaining *why*.
1974 switch (CPU) {
1975 case CK_Generic:
1976 // No processor selected!
1977 return false;
1978
1979 case CK_i386:
1980 case CK_i486:
1981 case CK_WinChipC6:
1982 case CK_WinChip2:
1983 case CK_C3:
1984 case CK_i586:
1985 case CK_Pentium:
1986 case CK_PentiumMMX:
1987 case CK_i686:
1988 case CK_PentiumPro:
1989 case CK_Pentium2:
1990 case CK_Pentium3:
1991 case CK_Pentium3M:
1992 case CK_PentiumM:
1993 case CK_Yonah:
1994 case CK_C3_2:
1995 case CK_Pentium4:
1996 case CK_Pentium4M:
1997 case CK_Prescott:
1998 case CK_K6:
1999 case CK_K6_2:
2000 case CK_K6_3:
2001 case CK_Athlon:
2002 case CK_AthlonThunderbird:
2003 case CK_Athlon4:
2004 case CK_AthlonXP:
2005 case CK_AthlonMP:
2006 case CK_Geode:
2007 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00002008 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00002009 return false;
2010
2011 // Fallthrough
2012 case CK_Nocona:
2013 case CK_Core2:
2014 case CK_Penryn:
2015 case CK_Atom:
2016 case CK_Corei7:
2017 case CK_Corei7AVX:
2018 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002019 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00002020 case CK_Athlon64:
2021 case CK_Athlon64SSE3:
2022 case CK_AthlonFX:
2023 case CK_K8:
2024 case CK_K8SSE3:
2025 case CK_Opteron:
2026 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00002027 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002028 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00002029 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002030 case CK_BDVER1:
2031 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00002032 case CK_x86_64:
2033 return true;
2034 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00002035 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002036 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00002037
2038 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
2039 // We accept all non-ARM calling conventions
2040 return (CC == CC_X86ThisCall ||
2041 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00002042 CC == CC_X86StdCall ||
2043 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00002044 CC == CC_X86Pascal ||
2045 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002046 }
2047
Aaron Ballmanfff32482012-12-09 17:45:41 +00002048 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
2049 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00002050 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002051};
Chris Lattner3daed522009-03-02 22:20:04 +00002052
Chandler Carruthc3a2e652011-09-28 05:56:05 +00002053void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002054 // FIXME: This should not be here.
2055 Features["3dnow"] = false;
2056 Features["3dnowa"] = false;
2057 Features["mmx"] = false;
2058 Features["sse"] = false;
2059 Features["sse2"] = false;
2060 Features["sse3"] = false;
2061 Features["ssse3"] = false;
2062 Features["sse41"] = false;
2063 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002064 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002065 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002066 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002067 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002068 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002069 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002070 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002071 Features["bmi"] = false;
2072 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002073 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002074 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002075 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002076 Features["rdseed"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002077 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002078 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00002079 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002080 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002081
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002082 // FIXME: This *really* should not be here.
2083
2084 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00002085 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00002086 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002087
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002088 switch (CPU) {
2089 case CK_Generic:
2090 case CK_i386:
2091 case CK_i486:
2092 case CK_i586:
2093 case CK_Pentium:
2094 case CK_i686:
2095 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002096 break;
2097 case CK_PentiumMMX:
2098 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002099 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002100 break;
2101 case CK_Pentium3:
2102 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002103 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002104 break;
2105 case CK_PentiumM:
2106 case CK_Pentium4:
2107 case CK_Pentium4M:
2108 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002109 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002110 break;
2111 case CK_Yonah:
2112 case CK_Prescott:
2113 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002114 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002115 break;
2116 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002117 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002118 break;
2119 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00002120 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002121 break;
2122 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00002123 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002124 break;
2125 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002126 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002127 break;
2128 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00002129 setFeatureEnabled(Features, "avx", true);
2130 setFeatureEnabled(Features, "aes", true);
2131 setFeatureEnabled(Features, "pclmul", true);
2132 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002133 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00002134 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00002135 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002136 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002137 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002138 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002139 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002140 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00002141 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002142 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002143 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002144 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002145 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002146 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002147 setFeatureEnabled(Features, "bmi", true);
2148 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002149 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002150 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002151 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002152 case CK_K6:
2153 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002154 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002155 break;
2156 case CK_K6_2:
2157 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002158 case CK_WinChip2:
2159 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002160 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002161 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002162 case CK_Athlon:
2163 case CK_AthlonThunderbird:
2164 case CK_Geode:
2165 setFeatureEnabled(Features, "3dnowa", true);
2166 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002167 case CK_Athlon4:
2168 case CK_AthlonXP:
2169 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002170 setFeatureEnabled(Features, "sse", true);
2171 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002172 break;
2173 case CK_K8:
2174 case CK_Opteron:
2175 case CK_Athlon64:
2176 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002177 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002178 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002179 break;
2180 case CK_K8SSE3:
2181 case CK_OpteronSSE3:
2182 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002183 setFeatureEnabled(Features, "sse3", true);
2184 setFeatureEnabled(Features, "3dnowa", true);
2185 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002186 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002187 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002188 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002189 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002190 setFeatureEnabled(Features, "lzcnt", true);
2191 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002192 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002193 case CK_BTVER1:
2194 setFeatureEnabled(Features, "ssse3", true);
2195 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002196 setFeatureEnabled(Features, "lzcnt", true);
2197 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002198 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002199 case CK_BTVER2:
2200 setFeatureEnabled(Features, "avx", true);
2201 setFeatureEnabled(Features, "sse4a", true);
2202 setFeatureEnabled(Features, "lzcnt", true);
2203 setFeatureEnabled(Features, "aes", true);
2204 setFeatureEnabled(Features, "pclmul", true);
2205 setFeatureEnabled(Features, "bmi", true);
2206 setFeatureEnabled(Features, "f16c", true);
2207 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002208 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002209 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002210 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002211 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002212 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002213 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002214 case CK_BDVER2:
2215 setFeatureEnabled(Features, "xop", true);
2216 setFeatureEnabled(Features, "lzcnt", true);
2217 setFeatureEnabled(Features, "aes", true);
2218 setFeatureEnabled(Features, "pclmul", true);
2219 setFeatureEnabled(Features, "bmi", true);
2220 setFeatureEnabled(Features, "fma", true);
2221 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002222 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002223 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002224 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002225 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002226 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002227}
2228
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002229bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002230 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002231 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002232 // FIXME: This *really* should not be here. We need some way of translating
2233 // options into llvm subtarget features.
2234 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00002235 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
2236 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002237 return false;
2238
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002239 // FIXME: this should probably use a switch with fall through.
2240
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002241 if (Enabled) {
2242 if (Name == "mmx")
2243 Features["mmx"] = true;
2244 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002245 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002246 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002247 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002248 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002249 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2250 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002251 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002252 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002253 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002254 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002255 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002256 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2257 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002258 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002259 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002260 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002261 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002262 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002263 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002264 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002265 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002266 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002267 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002268 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002269 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002270 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2271 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002272 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002273 else if (Name == "avx2")
2274 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2275 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002276 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002277 else if (Name == "fma")
2278 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2279 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2280 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002281 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002282 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002283 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002284 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2285 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002286 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002287 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002288 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2289 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2290 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002291 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002292 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002293 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002294 else if (Name == "lzcnt")
2295 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002296 else if (Name == "rdrnd")
2297 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002298 else if (Name == "bmi")
2299 Features["bmi"] = true;
2300 else if (Name == "bmi2")
2301 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002302 else if (Name == "popcnt")
2303 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002304 else if (Name == "f16c")
2305 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002306 else if (Name == "rtm")
2307 Features["rtm"] = true;
Michael Liao72339a02013-03-26 17:52:08 +00002308 else if (Name == "prfchw")
2309 Features["prfchw"] = true;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002310 else if (Name == "rdseed")
2311 Features["rdseed"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002312 } else {
2313 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002314 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002315 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002316 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002317 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002318 Features["sse4a"] = Features["avx"] = Features["avx2"] =
2319 Features["fma"] = Features["fma4"] = Features["aes"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002320 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002321 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002322 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002323 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002324 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002325 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2326 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002327 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002328 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002329 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002330 Features["avx2"] = Features["fma"] = Features["fma4"] =
2331 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002332 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002333 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2334 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002335 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002336 Features["sse41"] = Features["sse42"] = Features["avx"] =
2337 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002338 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002339 Features["sse42"] = Features["avx"] = Features["avx2"] =
2340 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002341 else if (Name == "3dnow")
2342 Features["3dnow"] = Features["3dnowa"] = false;
2343 else if (Name == "3dnowa")
2344 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002345 else if (Name == "aes")
2346 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002347 else if (Name == "pclmul")
2348 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002349 else if (Name == "avx")
Craig Topper2ae95072012-06-03 21:46:30 +00002350 Features["avx"] = Features["avx2"] = Features["fma"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002351 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002352 else if (Name == "avx2")
2353 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002354 else if (Name == "fma")
2355 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002356 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002357 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002358 else if (Name == "lzcnt")
2359 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002360 else if (Name == "rdrnd")
2361 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002362 else if (Name == "bmi")
2363 Features["bmi"] = false;
2364 else if (Name == "bmi2")
2365 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002366 else if (Name == "popcnt")
2367 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002368 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002369 Features["fma4"] = Features["xop"] = false;
2370 else if (Name == "xop")
2371 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002372 else if (Name == "f16c")
2373 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002374 else if (Name == "rtm")
2375 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002376 else if (Name == "prfchw")
2377 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002378 else if (Name == "rdseed")
2379 Features["rdseed"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002380 }
2381
2382 return true;
2383}
2384
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002385/// HandleTargetOptions - Perform initialization based on the user
2386/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002387void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002388 // Remember the maximum enabled sselevel.
2389 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2390 // Ignore disabled features.
2391 if (Features[i][0] == '-')
2392 continue;
2393
Benjamin Kramer713575a2012-03-05 15:10:44 +00002394 StringRef Feature = StringRef(Features[i]).substr(1);
2395
2396 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002397 HasAES = true;
2398 continue;
2399 }
2400
Craig Topper3c0bc152012-05-31 05:18:48 +00002401 if (Feature == "pclmul") {
2402 HasPCLMUL = true;
2403 continue;
2404 }
2405
Benjamin Kramer713575a2012-03-05 15:10:44 +00002406 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002407 HasLZCNT = true;
2408 continue;
2409 }
2410
Benjamin Kramer84f30802012-07-07 09:39:18 +00002411 if (Feature == "rdrand") {
2412 HasRDRND = true;
2413 continue;
2414 }
2415
Benjamin Kramer713575a2012-03-05 15:10:44 +00002416 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002417 HasBMI = true;
2418 continue;
2419 }
2420
Benjamin Kramer713575a2012-03-05 15:10:44 +00002421 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002422 HasBMI2 = true;
2423 continue;
2424 }
2425
Benjamin Kramer713575a2012-03-05 15:10:44 +00002426 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002427 HasPOPCNT = true;
2428 continue;
2429 }
2430
Michael Liao463eb892012-11-10 05:17:46 +00002431 if (Feature == "rtm") {
2432 HasRTM = true;
2433 continue;
2434 }
2435
Michael Liao72339a02013-03-26 17:52:08 +00002436 if (Feature == "prfchw") {
2437 HasPRFCHW = true;
2438 continue;
2439 }
2440
Michael Liao1bfc28c2013-03-29 05:17:55 +00002441 if (Feature == "rdseed") {
2442 HasRDSEED = true;
2443 continue;
2444 }
2445
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002446 if (Feature == "sse4a") {
2447 HasSSE4a = true;
2448 continue;
2449 }
2450
Benjamin Kramer713575a2012-03-05 15:10:44 +00002451 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002452 HasFMA4 = true;
2453 continue;
2454 }
2455
Craig Topper2ae95072012-06-03 21:46:30 +00002456 if (Feature == "fma") {
2457 HasFMA = true;
2458 continue;
2459 }
2460
Craig Topperb6af69e2012-06-09 22:24:14 +00002461 if (Feature == "xop") {
2462 HasXOP = true;
2463 continue;
2464 }
2465
Manman Ren146e5a42012-10-11 00:59:55 +00002466 if (Feature == "f16c") {
2467 HasF16C = true;
2468 continue;
2469 }
2470
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002471 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002472 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002473 .Case("avx2", AVX2)
2474 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002475 .Case("sse42", SSE42)
2476 .Case("sse41", SSE41)
2477 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002478 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002479 .Case("sse2", SSE2)
2480 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002481 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002482 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002483
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002484 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002485 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002486 .Case("3dnowa", AMD3DNowAthlon)
2487 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002488 .Case("mmx", MMX)
2489 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002490
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002491 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002492 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002493
2494 // Don't tell the backend if we're turning off mmx; it will end up disabling
2495 // SSE, which we don't want.
2496 std::vector<std::string>::iterator it;
2497 it = std::find(Features.begin(), Features.end(), "-mmx");
2498 if (it != Features.end())
2499 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002500}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002501
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002502/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2503/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002504void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002505 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002506 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002507 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002508 Builder.defineMacro("__amd64__");
2509 Builder.defineMacro("__amd64");
2510 Builder.defineMacro("__x86_64");
2511 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002512 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002513 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002514 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002515
Chris Lattnerc0f59212009-03-02 22:27:17 +00002516 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002517 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2518 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002519 switch (CPU) {
2520 case CK_Generic:
2521 break;
2522 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002523 // The rest are coming from the i386 define above.
2524 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002525 break;
2526 case CK_i486:
2527 case CK_WinChipC6:
2528 case CK_WinChip2:
2529 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002530 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002531 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002532 case CK_PentiumMMX:
2533 Builder.defineMacro("__pentium_mmx__");
2534 Builder.defineMacro("__tune_pentium_mmx__");
2535 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002536 case CK_i586:
2537 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002538 defineCPUMacros(Builder, "i586");
2539 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002540 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002541 case CK_Pentium3:
2542 case CK_Pentium3M:
2543 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002544 Builder.defineMacro("__tune_pentium3__");
2545 // Fallthrough
2546 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002547 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002548 Builder.defineMacro("__tune_pentium2__");
2549 // Fallthrough
2550 case CK_PentiumPro:
2551 Builder.defineMacro("__tune_i686__");
2552 Builder.defineMacro("__tune_pentiumpro__");
2553 // Fallthrough
2554 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002555 Builder.defineMacro("__i686");
2556 Builder.defineMacro("__i686__");
2557 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2558 Builder.defineMacro("__pentiumpro");
2559 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002560 break;
2561 case CK_Pentium4:
2562 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002563 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002564 break;
2565 case CK_Yonah:
2566 case CK_Prescott:
2567 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002568 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002569 break;
2570 case CK_Core2:
2571 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002572 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002573 break;
2574 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002575 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002576 break;
2577 case CK_Corei7:
2578 case CK_Corei7AVX:
2579 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002580 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002581 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002582 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002583 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002584 Builder.defineMacro("__k6_2__");
2585 Builder.defineMacro("__tune_k6_2__");
2586 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002587 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002588 if (CPU != CK_K6_2) { // In case of fallthrough
2589 // FIXME: GCC may be enabling these in cases where some other k6
2590 // architecture is specified but -m3dnow is explicitly provided. The
2591 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002592 Builder.defineMacro("__k6_3__");
2593 Builder.defineMacro("__tune_k6_3__");
2594 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002595 // Fallthrough
2596 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002597 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002598 break;
2599 case CK_Athlon:
2600 case CK_AthlonThunderbird:
2601 case CK_Athlon4:
2602 case CK_AthlonXP:
2603 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002604 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002605 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002606 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002607 Builder.defineMacro("__tune_athlon_sse__");
2608 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002609 break;
2610 case CK_K8:
2611 case CK_K8SSE3:
2612 case CK_x86_64:
2613 case CK_Opteron:
2614 case CK_OpteronSSE3:
2615 case CK_Athlon64:
2616 case CK_Athlon64SSE3:
2617 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002618 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002619 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002620 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002621 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002622 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002623 case CK_BTVER1:
2624 defineCPUMacros(Builder, "btver1");
2625 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002626 case CK_BTVER2:
2627 defineCPUMacros(Builder, "btver2");
2628 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002629 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002630 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002631 break;
2632 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002633 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002634 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002635 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002636 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002637 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002638 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002639
Chandler Carruth88c75b02011-09-28 09:54:07 +00002640 // Target properties.
2641 Builder.defineMacro("__LITTLE_ENDIAN__");
2642 Builder.defineMacro("__REGISTER_PREFIX__", "");
2643
Chris Lattner54175442009-04-19 17:32:33 +00002644 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2645 // functions in glibc header files that use FP Stack inline asm which the
2646 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002647 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002648
Chandler Carruth88c75b02011-09-28 09:54:07 +00002649 if (HasAES)
2650 Builder.defineMacro("__AES__");
2651
Craig Topper3c0bc152012-05-31 05:18:48 +00002652 if (HasPCLMUL)
2653 Builder.defineMacro("__PCLMUL__");
2654
Craig Topper31ceea02011-12-25 05:06:45 +00002655 if (HasLZCNT)
2656 Builder.defineMacro("__LZCNT__");
2657
Benjamin Kramer84f30802012-07-07 09:39:18 +00002658 if (HasRDRND)
2659 Builder.defineMacro("__RDRND__");
2660
Craig Topper31ceea02011-12-25 05:06:45 +00002661 if (HasBMI)
2662 Builder.defineMacro("__BMI__");
2663
2664 if (HasBMI2)
2665 Builder.defineMacro("__BMI2__");
2666
Craig Toppere14e08b2011-12-29 16:10:46 +00002667 if (HasPOPCNT)
2668 Builder.defineMacro("__POPCNT__");
2669
Michael Liao463eb892012-11-10 05:17:46 +00002670 if (HasRTM)
2671 Builder.defineMacro("__RTM__");
2672
Michael Liao72339a02013-03-26 17:52:08 +00002673 if (HasPRFCHW)
2674 Builder.defineMacro("__PRFCHW__");
2675
Michael Liao1bfc28c2013-03-29 05:17:55 +00002676 if (HasRDSEED)
2677 Builder.defineMacro("__RDSEED__");
2678
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002679 if (HasSSE4a)
2680 Builder.defineMacro("__SSE4A__");
2681
Craig Topper6a511e12011-12-30 07:33:42 +00002682 if (HasFMA4)
2683 Builder.defineMacro("__FMA4__");
2684
Craig Topper2ae95072012-06-03 21:46:30 +00002685 if (HasFMA)
2686 Builder.defineMacro("__FMA__");
2687
Craig Topperb6af69e2012-06-09 22:24:14 +00002688 if (HasXOP)
2689 Builder.defineMacro("__XOP__");
2690
Manman Ren146e5a42012-10-11 00:59:55 +00002691 if (HasF16C)
2692 Builder.defineMacro("__F16C__");
2693
Chris Lattner84f0ea82009-03-02 22:40:39 +00002694 // Each case falls through to the previous one here.
2695 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002696 case AVX2:
2697 Builder.defineMacro("__AVX2__");
2698 case AVX:
2699 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002700 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002701 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002702 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002703 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002704 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002705 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002706 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002707 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002708 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002709 Builder.defineMacro("__SSE2__");
2710 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002711 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002712 Builder.defineMacro("__SSE__");
2713 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002714 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002715 break;
2716 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002717
Derek Schuffbabaf312012-10-11 15:52:22 +00002718 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002719 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002720 case AVX2:
2721 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002722 case SSE42:
2723 case SSE41:
2724 case SSSE3:
2725 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002726 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002727 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002728 break;
2729 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002730 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002731 break;
2732 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002733 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002734 }
2735 }
2736
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002737 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002738 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002739 case AMD3DNowAthlon:
2740 Builder.defineMacro("__3dNOW_A__");
2741 case AMD3DNow:
2742 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002743 case MMX:
2744 Builder.defineMacro("__MMX__");
2745 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002746 break;
2747 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002748
2749 if (CPU >= CK_i486) {
2750 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2751 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2752 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2753 }
2754 if (CPU >= CK_i586)
2755 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002756}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002757
Douglas Gregore727d212012-01-30 06:38:25 +00002758bool X86TargetInfo::hasFeature(StringRef Feature) const {
2759 return llvm::StringSwitch<bool>(Feature)
2760 .Case("aes", HasAES)
2761 .Case("avx", SSELevel >= AVX)
2762 .Case("avx2", SSELevel >= AVX2)
2763 .Case("bmi", HasBMI)
2764 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002765 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002766 .Case("fma4", HasFMA4)
2767 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002768 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002769 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2770 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2771 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002772 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002773 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002774 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002775 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002776 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002777 .Case("sse", SSELevel >= SSE1)
2778 .Case("sse2", SSELevel >= SSE2)
2779 .Case("sse3", SSELevel >= SSE3)
2780 .Case("ssse3", SSELevel >= SSSE3)
2781 .Case("sse41", SSELevel >= SSE41)
2782 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002783 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002784 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002785 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2786 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002787 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002788 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002789 .Default(false);
2790}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002791
Eli Friedman618234a2008-08-20 02:34:37 +00002792bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002793X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002794 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002795 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002796 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002797 case 'Y': // first letter of a pair:
2798 switch (*(Name+1)) {
2799 default: return false;
2800 case '0': // First SSE register.
2801 case 't': // Any SSE register, when SSE2 is enabled.
2802 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2803 case 'm': // any MMX register, when inter-unit moves enabled.
2804 break; // falls through to setAllowsRegister.
2805 }
Eli Friedman618234a2008-08-20 02:34:37 +00002806 case 'a': // eax.
2807 case 'b': // ebx.
2808 case 'c': // ecx.
2809 case 'd': // edx.
2810 case 'S': // esi.
2811 case 'D': // edi.
2812 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002813 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002814 case 't': // top of floating point stack.
2815 case 'u': // second from top of floating point stack.
2816 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002817 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002818 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002819 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002820 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2821 case 'l': // "Index" registers: any general register that can be used as an
2822 // index in a base+index memory access.
2823 Info.setAllowsRegister();
2824 return true;
2825 case 'C': // SSE floating point constant.
2826 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002827 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002828 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002829 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002830 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002831 return true;
2832 }
2833}
2834
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002835
Eli Friedman618234a2008-08-20 02:34:37 +00002836std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002837X86TargetInfo::convertConstraint(const char *&Constraint) const {
2838 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002839 case 'a': return std::string("{ax}");
2840 case 'b': return std::string("{bx}");
2841 case 'c': return std::string("{cx}");
2842 case 'd': return std::string("{dx}");
2843 case 'S': return std::string("{si}");
2844 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002845 case 'p': // address
2846 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002847 case 't': // top of floating point stack.
2848 return std::string("{st}");
2849 case 'u': // second from top of floating point stack.
2850 return std::string("{st(1)}"); // second from top of floating point stack.
2851 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002852 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002853 }
2854}
Eli Friedman618234a2008-08-20 02:34:37 +00002855} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002856
2857namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002858// X86-32 generic target
2859class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002860public:
Eli Friedman618234a2008-08-20 02:34:37 +00002861 X86_32TargetInfo(const std::string& triple) : X86TargetInfo(triple) {
2862 DoubleAlign = LongLongAlign = 32;
2863 LongDoubleWidth = 96;
2864 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002865 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002866 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2867 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002868 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002869 SizeType = UnsignedInt;
2870 PtrDiffType = SignedInt;
2871 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002872 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002873
2874 // Use fpret for all types.
2875 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2876 (1 << TargetInfo::Double) |
2877 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002878
2879 // x86-32 has atomics up to 8 bytes
2880 // FIXME: Check that we actually have cmpxchg8b before setting
2881 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2882 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002883 }
Meador Ingec5613b22012-06-16 03:34:49 +00002884 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2885 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002886 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002887
Chris Lattner21fb98e2009-09-23 06:06:36 +00002888 int getEHDataRegisterNumber(unsigned RegNo) const {
2889 if (RegNo == 0) return 0;
2890 if (RegNo == 1) return 2;
2891 return -1;
2892 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002893 virtual bool validateInputSize(StringRef Constraint,
2894 unsigned Size) const {
2895 switch (Constraint[0]) {
2896 default: break;
2897 case 'a':
2898 case 'b':
2899 case 'c':
2900 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002901 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002902 }
2903
2904 return true;
2905 }
Eli Friedman618234a2008-08-20 02:34:37 +00002906};
2907} // end anonymous namespace
2908
2909namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002910class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2911public:
2912 NetBSDI386TargetInfo(const std::string &triple) :
2913 NetBSDTargetInfo<X86_32TargetInfo>(triple) {
2914 }
2915
2916 virtual unsigned getFloatEvalMethod() const {
2917 // NetBSD defaults to "double" rounding
2918 return 1;
2919 }
2920};
2921} // end anonymous namespace
2922
2923namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002924class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2925public:
2926 OpenBSDI386TargetInfo(const std::string& triple) :
2927 OpenBSDTargetInfo<X86_32TargetInfo>(triple) {
2928 SizeType = UnsignedLong;
2929 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002930 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002931 }
2932};
2933} // end anonymous namespace
2934
2935namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002936class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2937public:
2938 BitrigI386TargetInfo(const std::string& triple) :
2939 BitrigTargetInfo<X86_32TargetInfo>(triple) {
2940 SizeType = UnsignedLong;
2941 IntPtrType = SignedLong;
2942 PtrDiffType = SignedLong;
2943 }
2944};
2945} // end anonymous namespace
2946
2947namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002948class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002949public:
Torok Edwin5f6c1942009-06-30 17:10:35 +00002950 DarwinI386TargetInfo(const std::string& triple) :
2951 DarwinTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002952 LongDoubleWidth = 128;
2953 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002954 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002955 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002956 SizeType = UnsignedLong;
2957 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002958 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2959 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002960 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002961 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002962 }
2963
Eli Friedman618234a2008-08-20 02:34:37 +00002964};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002965} // end anonymous namespace
2966
2967namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002968// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002969class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002970public:
2971 WindowsX86_32TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002972 : WindowsTargetInfo<X86_32TargetInfo>(triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002973 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002974 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002975 DoubleAlign = LongLongAlign = 64;
2976 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 +00002977 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002978 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002979 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002980 virtual void getTargetDefines(const LangOptions &Opts,
2981 MacroBuilder &Builder) const {
2982 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2983 }
2984};
2985} // end anonymous namespace
2986
2987namespace {
2988
2989// x86-32 Windows Visual Studio target
2990class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2991public:
2992 VisualStudioWindowsX86_32TargetInfo(const std::string& triple)
2993 : WindowsX86_32TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002994 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002995 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2996 }
2997 virtual void getTargetDefines(const LangOptions &Opts,
2998 MacroBuilder &Builder) const {
2999 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3000 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3001 // The value of the following reflects processor type.
3002 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3003 // We lost the original triple, so we use the default.
3004 Builder.defineMacro("_M_IX86", "600");
3005 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003006};
3007} // end anonymous namespace
3008
3009namespace {
3010// x86-32 MinGW target
3011class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3012public:
3013 MinGWX86_32TargetInfo(const std::string& triple)
3014 : WindowsX86_32TargetInfo(triple) {
3015 }
3016 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003017 MacroBuilder &Builder) const {
3018 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003019 DefineStd(Builder, "WIN32", Opts);
3020 DefineStd(Builder, "WINNT", Opts);
3021 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003022 Builder.defineMacro("__MSVCRT__");
3023 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003024
3025 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3026 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003027 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003028 // Provide "as-is" __declspec.
3029 Builder.defineMacro("__declspec", "__declspec");
3030 else
3031 // Provide alias of __attribute__ like mingw32-gcc.
3032 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003033 }
3034};
3035} // end anonymous namespace
3036
3037namespace {
3038// x86-32 Cygwin target
3039class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3040public:
3041 CygwinX86_32TargetInfo(const std::string& triple)
3042 : X86_32TargetInfo(triple) {
3043 TLSSupported = false;
3044 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003045 DoubleAlign = LongLongAlign = 64;
3046 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3047 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003048 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003049 }
3050 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003051 MacroBuilder &Builder) const {
3052 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00003053 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00003054 Builder.defineMacro("__CYGWIN__");
3055 Builder.defineMacro("__CYGWIN32__");
3056 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00003057 if (Opts.CPlusPlus)
3058 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00003059 }
Eli Friedman29a30502008-08-21 01:40:19 +00003060};
3061} // end anonymous namespace
3062
3063namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00003064// x86-32 Haiku target
3065class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3066public:
3067 HaikuX86_32TargetInfo(const std::string& triple)
3068 : X86_32TargetInfo(triple) {
3069 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00003070 IntPtrType = SignedLong;
3071 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00003072 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00003073 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00003074 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00003075 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00003076 virtual void getTargetDefines(const LangOptions &Opts,
3077 MacroBuilder &Builder) const {
3078 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3079 Builder.defineMacro("__INTEL__");
3080 Builder.defineMacro("__HAIKU__");
3081 }
3082};
3083} // end anonymous namespace
3084
Douglas Gregordca52262011-07-01 22:41:14 +00003085// RTEMS Target
3086template<typename Target>
3087class RTEMSTargetInfo : public OSTargetInfo<Target> {
3088protected:
3089 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3090 MacroBuilder &Builder) const {
3091 // RTEMS defines; list based off of gcc output
3092
Douglas Gregordca52262011-07-01 22:41:14 +00003093 Builder.defineMacro("__rtems__");
3094 Builder.defineMacro("__ELF__");
3095 }
3096public:
3097 RTEMSTargetInfo(const std::string &triple)
3098 : OSTargetInfo<Target>(triple) {
3099 this->UserLabelPrefix = "";
3100
3101 llvm::Triple Triple(triple);
3102 switch (Triple.getArch()) {
3103 default:
3104 case llvm::Triple::x86:
3105 // this->MCountName = ".mcount";
3106 break;
3107 case llvm::Triple::mips:
3108 case llvm::Triple::mipsel:
3109 case llvm::Triple::ppc:
3110 case llvm::Triple::ppc64:
3111 // this->MCountName = "_mcount";
3112 break;
3113 case llvm::Triple::arm:
3114 // this->MCountName = "__mcount";
3115 break;
3116 }
3117
3118 }
3119};
3120
3121namespace {
3122// x86-32 RTEMS target
3123class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3124public:
3125 RTEMSX86_32TargetInfo(const std::string& triple)
3126 : X86_32TargetInfo(triple) {
3127 SizeType = UnsignedLong;
3128 IntPtrType = SignedLong;
3129 PtrDiffType = SignedLong;
3130 this->UserLabelPrefix = "";
3131 }
3132 virtual void getTargetDefines(const LangOptions &Opts,
3133 MacroBuilder &Builder) const {
3134 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3135 Builder.defineMacro("__INTEL__");
3136 Builder.defineMacro("__rtems__");
3137 }
3138};
3139} // end anonymous namespace
3140
Chris Lattner86ed3a32010-04-11 19:29:39 +00003141namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003142// x86-64 generic target
3143class X86_64TargetInfo : public X86TargetInfo {
3144public:
Chris Lattner33328642009-03-20 15:52:06 +00003145 X86_64TargetInfo(const std::string &triple) : X86TargetInfo(triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003146 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003147 LongDoubleWidth = 128;
3148 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003149 LargeArrayMinWidth = 128;
3150 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003151 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003152 IntMaxType = SignedLong;
3153 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003154 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003155 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003156
Eli Friedmaned855cb2008-08-21 00:13:15 +00003157 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3158 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003159 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003160
3161 // Use fpret only for long double.
3162 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003163
Anders Carlssoneea64802011-10-31 16:27:11 +00003164 // Use fp2ret for _Complex long double.
3165 ComplexLongDoubleUsesFP2Ret = true;
3166
Eli Friedman2be46072011-10-14 20:59:01 +00003167 // x86-64 has atomics up to 16 bytes.
3168 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3169 // on CPUs with cmpxchg16b
3170 MaxAtomicPromoteWidth = 128;
3171 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003172 }
Meador Ingec5613b22012-06-16 03:34:49 +00003173 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3174 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003175 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003176
Chris Lattner21fb98e2009-09-23 06:06:36 +00003177 int getEHDataRegisterNumber(unsigned RegNo) const {
3178 if (RegNo == 0) return 0;
3179 if (RegNo == 1) return 1;
3180 return -1;
3181 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003182
3183 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00003184 return (CC == CC_Default ||
3185 CC == CC_C ||
3186 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003187 }
3188
Aaron Ballmanfff32482012-12-09 17:45:41 +00003189 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3190 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003191 }
3192
Eli Friedman618234a2008-08-20 02:34:37 +00003193};
3194} // end anonymous namespace
3195
3196namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003197// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003198class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003199public:
3200 WindowsX86_64TargetInfo(const std::string& triple)
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003201 : WindowsTargetInfo<X86_64TargetInfo>(triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003202 TLSSupported = false;
3203 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003204 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003205 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003206 IntMaxType = SignedLongLong;
3207 UIntMaxType = UnsignedLongLong;
3208 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003209 SizeType = UnsignedLongLong;
3210 PtrDiffType = SignedLongLong;
3211 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003212 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003213 }
3214 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003215 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003216 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003217 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003218 }
Meador Ingec5613b22012-06-16 03:34:49 +00003219 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3220 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003221 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003222};
3223} // end anonymous namespace
3224
3225namespace {
3226// x86-64 Windows Visual Studio target
3227class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3228public:
3229 VisualStudioWindowsX86_64TargetInfo(const std::string& triple)
3230 : WindowsX86_64TargetInfo(triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003231 LongDoubleWidth = LongDoubleAlign = 64;
3232 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003233 }
3234 virtual void getTargetDefines(const LangOptions &Opts,
3235 MacroBuilder &Builder) const {
3236 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3237 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003238 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003239 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003240 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003241};
3242} // end anonymous namespace
3243
3244namespace {
3245// x86-64 MinGW target
3246class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3247public:
3248 MinGWX86_64TargetInfo(const std::string& triple)
3249 : WindowsX86_64TargetInfo(triple) {
3250 }
3251 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003252 MacroBuilder &Builder) const {
3253 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003254 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003255 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003256 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003257 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003258
3259 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3260 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003261 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003262 // Provide "as-is" __declspec.
3263 Builder.defineMacro("__declspec", "__declspec");
3264 else
3265 // Provide alias of __attribute__ like mingw32-gcc.
3266 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003267 }
3268};
3269} // end anonymous namespace
3270
3271namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003272class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3273public:
Mike Stump1eb44332009-09-09 15:08:12 +00003274 DarwinX86_64TargetInfo(const std::string& triple)
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003275 : DarwinTargetInfo<X86_64TargetInfo>(triple) {
3276 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003277 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003278 }
3279};
3280} // end anonymous namespace
3281
3282namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003283class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3284public:
Mike Stump1eb44332009-09-09 15:08:12 +00003285 OpenBSDX86_64TargetInfo(const std::string& triple)
Eli Friedman6036ebe2009-07-05 22:31:18 +00003286 : OpenBSDTargetInfo<X86_64TargetInfo>(triple) {
3287 IntMaxType = SignedLongLong;
3288 UIntMaxType = UnsignedLongLong;
3289 Int64Type = SignedLongLong;
3290 }
3291};
3292} // end anonymous namespace
3293
3294namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003295class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3296public:
3297 BitrigX86_64TargetInfo(const std::string& triple)
3298 : BitrigTargetInfo<X86_64TargetInfo>(triple) {
3299 IntMaxType = SignedLongLong;
3300 UIntMaxType = UnsignedLongLong;
3301 Int64Type = SignedLongLong;
3302 }
3303};
Tim Northoverc264e162013-01-31 12:13:10 +00003304}
3305
3306namespace {
3307class AArch64TargetInfo : public TargetInfo {
3308 static const char * const GCCRegNames[];
3309 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003310
3311 static const Builtin::Info BuiltinInfo[];
Tim Northoverc264e162013-01-31 12:13:10 +00003312public:
3313 AArch64TargetInfo(const std::string& triple) : TargetInfo(triple) {
3314 BigEndian = false;
3315 LongWidth = LongAlign = 64;
3316 LongDoubleWidth = LongDoubleAlign = 128;
3317 PointerWidth = PointerAlign = 64;
3318 SuitableAlign = 128;
3319 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3320 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3321 "f128:128:128-n32:64-S128";
3322
3323 WCharType = UnsignedInt;
3324 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3325
Tim Northover6a93c862013-02-18 12:11:32 +00003326 // AArch64 backend supports 64-bit operations at the moment. In principle
3327 // 128-bit is possible if register-pairs are used.
3328 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3329
Tim Northoverc264e162013-01-31 12:13:10 +00003330 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3331 }
3332 virtual void getTargetDefines(const LangOptions &Opts,
3333 MacroBuilder &Builder) const {
3334 // GCC defines theses currently
3335 Builder.defineMacro("__aarch64__");
3336 Builder.defineMacro("__AARCH64EL__");
3337
3338 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3339
3340 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3341 // which was intended to be compatible with a 64-bit implementation. They
3342 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003343 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3344 Builder.defineMacro("__ARM_ACLE", "101");
3345 Builder.defineMacro("__ARM_ARCH", "8");
3346 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003347
Tim Northoverdabcbf92013-04-05 14:08:55 +00003348 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3349 Builder.defineMacro("__ARM_FEATURE_CLZ");
3350 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003351
3352 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3353 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003354 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003355
3356 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003357 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003358
3359 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003360 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3361 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003362
3363 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003364 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003365
3366 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003367 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003368
Tim Northoverdabcbf92013-04-05 14:08:55 +00003369 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003370 Opts.ShortWChar ? "2" : "4");
3371
Tim Northoverdabcbf92013-04-05 14:08:55 +00003372 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003373 Opts.ShortEnums ? "1" : "4");
3374
3375 if (BigEndian)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003376 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northoverc264e162013-01-31 12:13:10 +00003377 }
3378 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3379 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003380 Records = BuiltinInfo;
3381 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003382 }
3383 virtual bool hasFeature(StringRef Feature) const {
3384 return Feature == "aarch64";
3385 }
3386 virtual void getGCCRegNames(const char * const *&Names,
3387 unsigned &NumNames) const;
3388 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3389 unsigned &NumAliases) const;
3390
3391 virtual bool isCLZForZeroUndef() const { return false; }
3392
3393 virtual bool validateAsmConstraint(const char *&Name,
3394 TargetInfo::ConstraintInfo &Info) const {
3395 switch (*Name) {
3396 default: return false;
3397 case 'w': // An FP/SIMD vector register
3398 Info.setAllowsRegister();
3399 return true;
3400 case 'I': // Constant that can be used with an ADD instruction
3401 case 'J': // Constant that can be used with a SUB instruction
3402 case 'K': // Constant that can be used with a 32-bit logical instruction
3403 case 'L': // Constant that can be used with a 64-bit logical instruction
3404 case 'M': // Constant that can be used as a 32-bit MOV immediate
3405 case 'N': // Constant that can be used as a 64-bit MOV immediate
3406 case 'Y': // Floating point constant zero
3407 case 'Z': // Integer constant zero
3408 return true;
3409 case 'Q': // A memory reference with base register and no offset
3410 Info.setAllowsMemory();
3411 return true;
3412 case 'S': // A symbolic address
3413 Info.setAllowsRegister();
3414 return true;
3415 case 'U':
3416 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3417 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3418 // Usa: An absolute symbolic address
3419 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3420 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3421 }
3422 }
3423
3424 virtual const char *getClobbers() const {
3425 // There are no AArch64 clobbers shared by all asm statements.
3426 return "";
3427 }
3428
3429 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3430 return TargetInfo::AArch64ABIBuiltinVaList;
3431 }
3432};
3433
3434const char * const AArch64TargetInfo::GCCRegNames[] = {
3435 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3436 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3437 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3438 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3439
3440 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3441 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3442 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3443 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3444
3445 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3446 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3447 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3448 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3449
3450 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3451 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3452 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3453 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3454
3455 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3456 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3457 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3458 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3459
3460 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3461 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3462 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3463 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3464
3465 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3466 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3467 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3468 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3469};
3470
3471void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3472 unsigned &NumNames) const {
3473 Names = GCCRegNames;
3474 NumNames = llvm::array_lengthof(GCCRegNames);
3475}
3476
3477const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3478 { { "x16" }, "ip0"},
3479 { { "x17" }, "ip1"},
3480 { { "x29" }, "fp" },
3481 { { "x30" }, "lr" }
3482};
3483
3484void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3485 unsigned &NumAliases) const {
3486 Aliases = GCCRegAliases;
3487 NumAliases = llvm::array_lengthof(GCCRegAliases);
3488
3489}
Tim Northoverff920ee2013-05-04 07:15:13 +00003490
3491const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3492#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3493#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3494 ALL_LANGUAGES },
3495#include "clang/Basic/BuiltinsAArch64.def"
3496};
3497
Eli Friedman42f74f22012-08-08 23:57:20 +00003498} // end anonymous namespace
3499
3500namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003501class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003502 // Possible FPU choices.
3503 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003504 VFP2FPU = (1 << 0),
3505 VFP3FPU = (1 << 1),
3506 VFP4FPU = (1 << 2),
3507 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003508 };
3509
3510 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003511 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003512 }
3513
3514 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3515 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003516
Daniel Dunbareac7c532009-12-18 18:42:37 +00003517 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003518
Bob Wilsoncfaab002012-09-29 23:52:52 +00003519 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003520
Logan Chieneae5a8202012-10-10 06:56:20 +00003521 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003522 unsigned IsThumb : 1;
3523
3524 // Initialized via features.
3525 unsigned SoftFloat : 1;
3526 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003527
Chris Lattner2752c012010-03-03 19:03:45 +00003528 static const Builtin::Info BuiltinInfo[];
3529
Rafael Espindola620c0af2013-05-13 20:09:47 +00003530 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3531 // On linux, binaries targeting old cpus call functions in libgcc to
3532 // perform atomic operations. The implementation in libgcc then calls into
3533 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3534 // is that if we assume the kernel is at least as recent as the hardware,
3535 // it is safe to use atomic instructions on armv6 and newer.
3536 if (T.getOS() != llvm::Triple::Linux)
3537 return false;
3538 StringRef ArchName = T.getArchName();
3539 if (ArchName.startswith("armv6") || ArchName.startswith("armv7"))
3540 return true;
3541 return false;
3542 }
3543
Chris Lattner393ff042008-04-21 18:56:49 +00003544public:
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003545 ARMTargetInfo(const std::string &TripleStr)
Logan Chieneae5a8202012-10-10 06:56:20 +00003546 : TargetInfo(TripleStr), ABI("aapcs-linux"), CPU("arm1136j-s"), IsAAPCS(true)
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003547 {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003548 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003549 SizeType = UnsignedInt;
3550 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003551 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3552 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003553
Chris Lattner9bffb072010-04-23 16:29:58 +00003554 // {} in inline assembly are neon specifiers, not assembly variant
3555 // specifiers.
3556 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003557
Daniel Dunbareac7c532009-12-18 18:42:37 +00003558 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003559 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003560 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003561 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3562 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003563 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3564 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003565 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003566 } else {
3567 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3568 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003569 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003570 }
John McCallee79a4c2010-08-21 22:46:04 +00003571
3572 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003573 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003574
3575 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003576 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003577 if (shouldUseInlineAtomic(getTriple()))
3578 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003579
3580 // Do force alignment of members that follow zero length bitfields. If
3581 // the alignment of the zero-length bitfield is greater than the member
3582 // that follows it, `bar', `bar' will be aligned as the type of the
3583 // zero length bitfield.
3584 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003585 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003586 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003587 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003588 ABI = Name;
3589
Daniel Dunbara2a41612009-09-14 00:02:24 +00003590 // The defaults (above) are for AAPCS, check if we need to change them.
3591 //
3592 // FIXME: We need support for -meabi... we could just mangle it into the
3593 // name.
3594 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003595 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003596 // size_t is unsigned int on FreeBSD.
3597 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3598 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003599
James Molloya6d81f92011-11-23 13:35:08 +00003600 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3601 WCharType = SignedInt;
3602
Daniel Dunbar684de632010-04-22 16:14:54 +00003603 // Do not respect the alignment of bit-field types when laying out
3604 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3605 UseBitFieldTypeAlignment = false;
3606
Chad Rosier61a62212011-08-04 01:21:14 +00003607 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003608 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3609 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003610 ZeroLengthBitfieldBoundary = 32;
3611
Logan Chieneae5a8202012-10-10 06:56:20 +00003612 IsAAPCS = false;
3613
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003614 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003615 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3616 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003617 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 +00003618 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003619 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003620 } else {
3621 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 +00003622 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003623 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003624 }
3625
Chad Rosier9f1210c2011-07-26 07:03:04 +00003626 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003627 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003628 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003629 // FIXME: Enumerated types are variable width in straight AAPCS.
3630 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003631 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003632 } else
3633 return false;
3634
3635 return true;
3636 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003637
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003638 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003639 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3640 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003641 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3642 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003643 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003644 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003645 Features["vfp4"] = true;
3646 Features["neon"] = true;
3647 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003648 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003649
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003650 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003651 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003652 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003653 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003654 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
3655 Name == "d16" || Name == "neonfp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003656 Features[Name] = Enabled;
3657 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003658 return false;
3659
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003660 return true;
3661 }
3662
3663 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003664 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003665 SoftFloat = SoftFloatABI = false;
3666 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3667 if (Features[i] == "+soft-float")
3668 SoftFloat = true;
3669 else if (Features[i] == "+soft-float-abi")
3670 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003671 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003672 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003673 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003674 FPU |= VFP3FPU;
3675 else if (Features[i] == "+vfp4")
3676 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003677 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003678 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003679 }
3680
3681 // Remove front-end specific options which the backend handles differently.
3682 std::vector<std::string>::iterator it;
3683 it = std::find(Features.begin(), Features.end(), "+soft-float");
3684 if (it != Features.end())
3685 Features.erase(it);
3686 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3687 if (it != Features.end())
3688 Features.erase(it);
3689 }
3690
Douglas Gregore727d212012-01-30 06:38:25 +00003691 virtual bool hasFeature(StringRef Feature) const {
3692 return llvm::StringSwitch<bool>(Feature)
3693 .Case("arm", true)
3694 .Case("softfloat", SoftFloat)
3695 .Case("thumb", IsThumb)
3696 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3697 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3698 .Default(false);
3699 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003700 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003701 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003702 return llvm::StringSwitch<const char*>(Name)
3703 .Cases("arm8", "arm810", "4")
3704 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3705 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3706 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3707 .Case("ep9312", "4T")
3708 .Cases("arm10tdmi", "arm1020t", "5T")
3709 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3710 .Case("arm926ej-s", "5TEJ")
3711 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3712 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003713 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003714 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003715 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003716 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003717 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3718 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003719 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003720 .Case("cortex-a9-mp", "7F")
3721 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003722 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003723 .Case("cortex-m0", "6M")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003724 .Default(0);
3725 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003726 static const char *getCPUProfile(StringRef Name) {
3727 return llvm::StringSwitch<const char*>(Name)
3728 .Cases("cortex-a8", "cortex-a9", "A")
3729 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003730 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003731 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003732 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003733 virtual bool setCPU(const std::string &Name) {
3734 if (!getCPUDefineSuffix(Name))
3735 return false;
3736
3737 CPU = Name;
3738 return true;
3739 }
Chris Lattner33328642009-03-20 15:52:06 +00003740 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003741 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003742 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003743 Builder.defineMacro("__arm");
3744 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003745
Chris Lattnerc0f59212009-03-02 22:27:17 +00003746 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003747 Builder.defineMacro("__ARMEL__");
3748 Builder.defineMacro("__LITTLE_ENDIAN__");
3749 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003750
Chris Lattner5f9e2722011-07-23 10:55:15 +00003751 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003752 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003753 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3754 StringRef CPUProfile = getCPUProfile(CPU);
3755 if (!CPUProfile.empty())
3756 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3757
Mike Stump437bb4b2009-04-08 02:07:04 +00003758 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003759
Daniel Dunbareac7c532009-12-18 18:42:37 +00003760 // FIXME: It's more complicated than this and we don't really support
3761 // interworking.
3762 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003763 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003764
David Tweedb16abb12012-10-25 13:33:01 +00003765 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003766 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003767 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003768 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003769 Builder.defineMacro("__ARM_PCS", "1");
3770
David Tweedb16abb12012-10-25 13:33:01 +00003771 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003772 Builder.defineMacro("__ARM_PCS_VFP", "1");
3773 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003774
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003775 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003776 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003777
3778 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003779 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003780
Bob Wilson84f95cf2011-05-13 18:56:03 +00003781 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003782 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003783 Builder.defineMacro("__THUMBEL__");
3784 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003785 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003786 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003787 }
3788
3789 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003790 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003791
Bob Wilsoncfaab002012-09-29 23:52:52 +00003792 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003793 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003794 if (FPU & VFP2FPU)
3795 Builder.defineMacro("__ARM_VFPV2__");
3796 if (FPU & VFP3FPU)
3797 Builder.defineMacro("__ARM_VFPV3__");
3798 if (FPU & VFP4FPU)
3799 Builder.defineMacro("__ARM_VFPV4__");
3800 }
3801
Daniel Dunbara91320b2009-12-21 23:28:17 +00003802 // This only gets set when Neon instructions are actually available, unlike
3803 // the VFP define, hence the soft float and arch check. This is subtly
3804 // different from gcc, we follow the intent which was that it should be set
3805 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003806 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003807 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003808 }
3809 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3810 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003811 Records = BuiltinInfo;
3812 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003813 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003814 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003815 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003816 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003817 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003818 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003819 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003820 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003821 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003822 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003823 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003824 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003825 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003826 case 'l': // r0-r7
3827 case 'h': // r8-r15
3828 case 'w': // VFP Floating point register single precision
3829 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003830 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003831 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003832 case 'Q': // A memory address that is a single base register.
3833 Info.setAllowsMemory();
3834 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003835 case 'U': // a memory reference...
3836 switch (Name[1]) {
3837 case 'q': // ...ARMV4 ldrsb
3838 case 'v': // ...VFP load/store (reg+constant offset)
3839 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003840 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003841 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003842 case 'n': // valid address for Neon doubleword vector load/store
3843 case 'm': // valid address for Neon element and structure load/store
3844 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003845 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003846 Info.setAllowsMemory();
3847 Name++;
3848 return true;
3849 }
Nate Begemanad487f42008-04-22 05:03:19 +00003850 }
Chris Lattner393ff042008-04-21 18:56:49 +00003851 return false;
3852 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003853 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003854 std::string R;
3855 switch (*Constraint) {
3856 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003857 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003858 Constraint++;
3859 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003860 case 'p': // 'p' should be translated to 'r' by default.
3861 R = std::string("r");
3862 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003863 default:
3864 return std::string(1, *Constraint);
3865 }
3866 return R;
3867 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003868 virtual bool validateConstraintModifier(StringRef Constraint,
3869 const char Modifier,
3870 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003871 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003872 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003873
Bill Wendling50d46ca2012-10-25 23:28:48 +00003874 // Strip off constraint modifiers.
3875 while (Constraint[0] == '=' ||
3876 Constraint[0] == '+' ||
3877 Constraint[0] == '&')
3878 Constraint = Constraint.substr(1);
3879
3880 switch (Constraint[0]) {
3881 default: break;
3882 case 'r': {
3883 switch (Modifier) {
3884 default:
Bill Wendling6e6330c2012-11-30 23:46:56 +00003885 return isInOut || (isOutput && Size >= 32) ||
3886 (!isOutput && !isInOut && Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003887 case 'q':
3888 // A register of size 32 cannot fit a vector type.
3889 return false;
3890 }
3891 }
3892 }
3893
3894 return true;
3895 }
Chris Lattner393ff042008-04-21 18:56:49 +00003896 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003897 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003898 return "";
3899 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003900
3901 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3902 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3903 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003904
3905 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3906 if (RegNo == 0) return 0;
3907 if (RegNo == 1) return 1;
3908 return -1;
3909 }
Chris Lattner393ff042008-04-21 18:56:49 +00003910};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003911
3912const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003913 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003914 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003915 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3916
3917 // Float registers
3918 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3919 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3920 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003921 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003922
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003923 // Double registers
3924 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3925 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003926 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3927 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003928
3929 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003930 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3931 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003932};
3933
3934void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003935 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003936 Names = GCCRegNames;
3937 NumNames = llvm::array_lengthof(GCCRegNames);
3938}
3939
3940const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003941 { { "a1" }, "r0" },
3942 { { "a2" }, "r1" },
3943 { { "a3" }, "r2" },
3944 { { "a4" }, "r3" },
3945 { { "v1" }, "r4" },
3946 { { "v2" }, "r5" },
3947 { { "v3" }, "r6" },
3948 { { "v4" }, "r7" },
3949 { { "v5" }, "r8" },
3950 { { "v6", "rfp" }, "r9" },
3951 { { "sl" }, "r10" },
3952 { { "fp" }, "r11" },
3953 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003954 { { "r13" }, "sp" },
3955 { { "r14" }, "lr" },
3956 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003957 // The S, D and Q registers overlap, but aren't really aliases; we
3958 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003959};
3960
3961void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3962 unsigned &NumAliases) const {
3963 Aliases = GCCRegAliases;
3964 NumAliases = llvm::array_lengthof(GCCRegAliases);
3965}
Chris Lattner2752c012010-03-03 19:03:45 +00003966
3967const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003968#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003969#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003970 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003971#include "clang/Basic/BuiltinsARM.def"
3972};
Chris Lattner393ff042008-04-21 18:56:49 +00003973} // end anonymous namespace.
3974
Eli Friedmana9f54962008-08-20 07:44:10 +00003975namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003976class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003977 public DarwinTargetInfo<ARMTargetInfo> {
3978protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003979 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003980 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003981 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003982 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003983
Torok Edwin5f6c1942009-06-30 17:10:35 +00003984public:
Mike Stump1eb44332009-09-09 15:08:12 +00003985 DarwinARMTargetInfo(const std::string& triple)
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003986 : DarwinTargetInfo<ARMTargetInfo>(triple) {
3987 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003988 // iOS always has 64-bit atomic instructions.
3989 // FIXME: This should be based off of the target features in ARMTargetInfo.
3990 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003991
3992 // Darwin on iOS uses a variant of the ARM C++ ABI.
3993 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003994 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003995};
3996} // end anonymous namespace.
3997
Tony Linthicum96319392011-12-12 21:14:55 +00003998
3999namespace {
4000// Hexagon abstract base class
4001class HexagonTargetInfo : public TargetInfo {
4002 static const Builtin::Info BuiltinInfo[];
4003 static const char * const GCCRegNames[];
4004 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4005 std::string CPU;
4006public:
4007 HexagonTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004008 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00004009 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00004010 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00004011 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00004012
4013 // {} in inline assembly are packet specifiers, not assembly variant
4014 // specifiers.
4015 NoAsmVariants = true;
4016 }
4017
4018 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4019 unsigned &NumRecords) const {
4020 Records = BuiltinInfo;
4021 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4022 }
4023
4024 virtual bool validateAsmConstraint(const char *&Name,
4025 TargetInfo::ConstraintInfo &Info) const {
4026 return true;
4027 }
4028
4029 virtual void getTargetDefines(const LangOptions &Opts,
4030 MacroBuilder &Builder) const;
4031
Douglas Gregore727d212012-01-30 06:38:25 +00004032 virtual bool hasFeature(StringRef Feature) const {
4033 return Feature == "hexagon";
4034 }
4035
Meador Ingec5613b22012-06-16 03:34:49 +00004036 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4037 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00004038 }
4039 virtual void getGCCRegNames(const char * const *&Names,
4040 unsigned &NumNames) const;
4041 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4042 unsigned &NumAliases) const;
4043 virtual const char *getClobbers() const {
4044 return "";
4045 }
Sebastian Pop43115d42012-01-13 20:37:10 +00004046
4047 static const char *getHexagonCPUSuffix(StringRef Name) {
4048 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00004049 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00004050 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00004051 .Default(0);
4052 }
4053
Tony Linthicum96319392011-12-12 21:14:55 +00004054 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00004055 if (!getHexagonCPUSuffix(Name))
4056 return false;
4057
Tony Linthicum96319392011-12-12 21:14:55 +00004058 CPU = Name;
4059 return true;
4060 }
4061};
4062
4063void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4064 MacroBuilder &Builder) const {
4065 Builder.defineMacro("qdsp6");
4066 Builder.defineMacro("__qdsp6", "1");
4067 Builder.defineMacro("__qdsp6__", "1");
4068
4069 Builder.defineMacro("hexagon");
4070 Builder.defineMacro("__hexagon", "1");
4071 Builder.defineMacro("__hexagon__", "1");
4072
4073 if(CPU == "hexagonv1") {
4074 Builder.defineMacro("__HEXAGON_V1__");
4075 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4076 if(Opts.HexagonQdsp6Compat) {
4077 Builder.defineMacro("__QDSP6_V1__");
4078 Builder.defineMacro("__QDSP6_ARCH__", "1");
4079 }
4080 }
4081 else if(CPU == "hexagonv2") {
4082 Builder.defineMacro("__HEXAGON_V2__");
4083 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4084 if(Opts.HexagonQdsp6Compat) {
4085 Builder.defineMacro("__QDSP6_V2__");
4086 Builder.defineMacro("__QDSP6_ARCH__", "2");
4087 }
4088 }
4089 else if(CPU == "hexagonv3") {
4090 Builder.defineMacro("__HEXAGON_V3__");
4091 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4092 if(Opts.HexagonQdsp6Compat) {
4093 Builder.defineMacro("__QDSP6_V3__");
4094 Builder.defineMacro("__QDSP6_ARCH__", "3");
4095 }
4096 }
4097 else if(CPU == "hexagonv4") {
4098 Builder.defineMacro("__HEXAGON_V4__");
4099 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4100 if(Opts.HexagonQdsp6Compat) {
4101 Builder.defineMacro("__QDSP6_V4__");
4102 Builder.defineMacro("__QDSP6_ARCH__", "4");
4103 }
4104 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00004105 else if(CPU == "hexagonv5") {
4106 Builder.defineMacro("__HEXAGON_V5__");
4107 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4108 if(Opts.HexagonQdsp6Compat) {
4109 Builder.defineMacro("__QDSP6_V5__");
4110 Builder.defineMacro("__QDSP6_ARCH__", "5");
4111 }
4112 }
Tony Linthicum96319392011-12-12 21:14:55 +00004113}
4114
4115const char * const HexagonTargetInfo::GCCRegNames[] = {
4116 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4117 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4118 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4119 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4120 "p0", "p1", "p2", "p3",
4121 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4122};
4123
4124void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4125 unsigned &NumNames) const {
4126 Names = GCCRegNames;
4127 NumNames = llvm::array_lengthof(GCCRegNames);
4128}
4129
4130
4131const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4132 { { "sp" }, "r29" },
4133 { { "fp" }, "r30" },
4134 { { "lr" }, "r31" },
4135 };
4136
4137void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4138 unsigned &NumAliases) const {
4139 Aliases = GCCRegAliases;
4140 NumAliases = llvm::array_lengthof(GCCRegAliases);
4141}
4142
4143
4144const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4145#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4146#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4147 ALL_LANGUAGES },
4148#include "clang/Basic/BuiltinsHexagon.def"
4149};
4150}
4151
4152
Reid Spencer5f016e22007-07-11 17:01:13 +00004153namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004154// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4155class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004156 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4157 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004158 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004159public:
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004160 SparcTargetInfo(const std::string &triple) : TargetInfo(triple) {}
4161
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004162 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00004163 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004164 bool Enabled) const {
4165 if (Name == "soft-float")
4166 Features[Name] = Enabled;
4167 else
4168 return false;
4169
4170 return true;
4171 }
4172 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
4173 SoftFloat = false;
4174 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4175 if (Features[i] == "+soft-float")
4176 SoftFloat = true;
4177 }
Chris Lattner33328642009-03-20 15:52:06 +00004178 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004179 MacroBuilder &Builder) const {
4180 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004181 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004182
4183 if (SoftFloat)
4184 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004185 }
Douglas Gregore727d212012-01-30 06:38:25 +00004186
4187 virtual bool hasFeature(StringRef Feature) const {
4188 return llvm::StringSwitch<bool>(Feature)
4189 .Case("softfloat", SoftFloat)
4190 .Case("sparc", true)
4191 .Default(false);
4192 }
4193
Gabor Greif26658672008-02-21 16:29:08 +00004194 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4195 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004196 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004197 }
Meador Ingec5613b22012-06-16 03:34:49 +00004198 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4199 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004200 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004201 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004202 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004203 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004204 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004205 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004206 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004207 // FIXME: Implement!
4208 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004209 }
4210 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004211 // FIXME: Implement!
4212 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004213 }
4214};
4215
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004216const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004217 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4218 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4219 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4220 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4221};
4222
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004223void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4224 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004225 Names = GCCRegNames;
4226 NumNames = llvm::array_lengthof(GCCRegNames);
4227}
4228
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004229const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004230 { { "g0" }, "r0" },
4231 { { "g1" }, "r1" },
4232 { { "g2" }, "r2" },
4233 { { "g3" }, "r3" },
4234 { { "g4" }, "r4" },
4235 { { "g5" }, "r5" },
4236 { { "g6" }, "r6" },
4237 { { "g7" }, "r7" },
4238 { { "o0" }, "r8" },
4239 { { "o1" }, "r9" },
4240 { { "o2" }, "r10" },
4241 { { "o3" }, "r11" },
4242 { { "o4" }, "r12" },
4243 { { "o5" }, "r13" },
4244 { { "o6", "sp" }, "r14" },
4245 { { "o7" }, "r15" },
4246 { { "l0" }, "r16" },
4247 { { "l1" }, "r17" },
4248 { { "l2" }, "r18" },
4249 { { "l3" }, "r19" },
4250 { { "l4" }, "r20" },
4251 { { "l5" }, "r21" },
4252 { { "l6" }, "r22" },
4253 { { "l7" }, "r23" },
4254 { { "i0" }, "r24" },
4255 { { "i1" }, "r25" },
4256 { { "i2" }, "r26" },
4257 { { "i3" }, "r27" },
4258 { { "i4" }, "r28" },
4259 { { "i5" }, "r29" },
4260 { { "i6", "fp" }, "r30" },
4261 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004262};
4263
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004264void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4265 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004266 Aliases = GCCRegAliases;
4267 NumAliases = llvm::array_lengthof(GCCRegAliases);
4268}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004269
4270// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4271class SparcV8TargetInfo : public SparcTargetInfo {
4272public:
4273 SparcV8TargetInfo(const std::string& triple) : SparcTargetInfo(triple) {
4274 // FIXME: Support Sparc quad-precision long double?
4275 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4276 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4277 }
4278
4279 virtual void getTargetDefines(const LangOptions &Opts,
4280 MacroBuilder &Builder) const {
4281 SparcTargetInfo::getTargetDefines(Opts, Builder);
4282 Builder.defineMacro("__sparcv8");
4283 }
4284};
4285
4286// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4287class SparcV9TargetInfo : public SparcTargetInfo {
4288public:
4289 SparcV9TargetInfo(const std::string& triple) : SparcTargetInfo(triple) {
4290 // FIXME: Support Sparc quad-precision long double?
4291 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4292 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
4293 }
4294
4295 virtual void getTargetDefines(const LangOptions &Opts,
4296 MacroBuilder &Builder) const {
4297 SparcTargetInfo::getTargetDefines(Opts, Builder);
4298 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004299 Builder.defineMacro("__arch64__");
4300 // Solaris and its derivative AuroraUX don't need these variants, but the
4301 // BSDs do.
4302 if (getTriple().getOS() != llvm::Triple::Solaris &&
4303 getTriple().getOS() != llvm::Triple::AuroraUX) {
4304 Builder.defineMacro("__sparc64__");
4305 Builder.defineMacro("__sparc_v9__");
4306 Builder.defineMacro("__sparcv9__");
4307 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004308 }
4309};
4310
Gabor Greif26658672008-02-21 16:29:08 +00004311} // end anonymous namespace.
4312
Eli Friedman01b86682008-08-20 07:28:14 +00004313namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004314class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4315public:
4316 AuroraUXSparcV8TargetInfo(const std::string& triple) :
4317 AuroraUXTargetInfo<SparcV8TargetInfo>(triple) {
4318 SizeType = UnsignedInt;
4319 PtrDiffType = SignedInt;
4320 }
4321};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004322class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004323public:
4324 SolarisSparcV8TargetInfo(const std::string& triple) :
Torok Edwin5f6c1942009-06-30 17:10:35 +00004325 SolarisTargetInfo<SparcV8TargetInfo>(triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004326 SizeType = UnsignedInt;
4327 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004328 }
4329};
4330} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004331
Chris Lattner2621fd12008-05-08 05:58:21 +00004332namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004333 class SystemZTargetInfo : public TargetInfo {
4334 static const char *const GCCRegNames[];
4335
4336 public:
4337 SystemZTargetInfo(const std::string& triple) : TargetInfo(triple) {
4338 TLSSupported = true;
4339 IntWidth = IntAlign = 32;
4340 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4341 PointerWidth = PointerAlign = 64;
4342 LongDoubleWidth = 128;
4343 LongDoubleAlign = 64;
4344 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4345 MinGlobalAlign = 16;
4346 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4347 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4348 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4349 }
4350 virtual void getTargetDefines(const LangOptions &Opts,
4351 MacroBuilder &Builder) const {
4352 Builder.defineMacro("__s390__");
4353 Builder.defineMacro("__s390x__");
4354 Builder.defineMacro("__zarch__");
4355 Builder.defineMacro("__LONG_DOUBLE_128__");
4356 }
4357 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4358 unsigned &NumRecords) const {
4359 // FIXME: Implement.
4360 Records = 0;
4361 NumRecords = 0;
4362 }
4363
4364 virtual void getGCCRegNames(const char *const *&Names,
4365 unsigned &NumNames) const;
4366 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4367 unsigned &NumAliases) const {
4368 // No aliases.
4369 Aliases = 0;
4370 NumAliases = 0;
4371 }
4372 virtual bool validateAsmConstraint(const char *&Name,
4373 TargetInfo::ConstraintInfo &info) const;
4374 virtual const char *getClobbers() const {
4375 // FIXME: Is this really right?
4376 return "";
4377 }
4378 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4379 return TargetInfo::SystemZBuiltinVaList;
4380 }
4381 };
4382
4383 const char *const SystemZTargetInfo::GCCRegNames[] = {
4384 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4385 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4386 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4387 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4388 };
4389
4390 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4391 unsigned &NumNames) const {
4392 Names = GCCRegNames;
4393 NumNames = llvm::array_lengthof(GCCRegNames);
4394 }
4395
4396 bool SystemZTargetInfo::
4397 validateAsmConstraint(const char *&Name,
4398 TargetInfo::ConstraintInfo &Info) const {
4399 switch (*Name) {
4400 default:
4401 return false;
4402
4403 case 'a': // Address register
4404 case 'd': // Data register (equivalent to 'r')
4405 case 'f': // Floating-point register
4406 Info.setAllowsRegister();
4407 return true;
4408
4409 case 'I': // Unsigned 8-bit constant
4410 case 'J': // Unsigned 12-bit constant
4411 case 'K': // Signed 16-bit constant
4412 case 'L': // Signed 20-bit displacement (on all targets we support)
4413 case 'M': // 0x7fffffff
4414 return true;
4415
4416 case 'Q': // Memory with base and unsigned 12-bit displacement
4417 case 'R': // Likewise, plus an index
4418 case 'S': // Memory with base and signed 20-bit displacement
4419 case 'T': // Likewise, plus an index
4420 Info.setAllowsMemory();
4421 return true;
4422 }
4423 }
4424}
4425
4426namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004427 class MSP430TargetInfo : public TargetInfo {
4428 static const char * const GCCRegNames[];
4429 public:
4430 MSP430TargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004431 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004432 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004433 IntWidth = 16; IntAlign = 16;
4434 LongWidth = 32; LongLongWidth = 64;
4435 LongAlign = LongLongAlign = 16;
4436 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004437 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004438 SizeType = UnsignedInt;
4439 IntMaxType = SignedLong;
4440 UIntMaxType = UnsignedLong;
4441 IntPtrType = SignedShort;
4442 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004443 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004444 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004445 }
4446 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004447 MacroBuilder &Builder) const {
4448 Builder.defineMacro("MSP430");
4449 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004450 // FIXME: defines for different 'flavours' of MCU
4451 }
4452 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4453 unsigned &NumRecords) const {
4454 // FIXME: Implement.
4455 Records = 0;
4456 NumRecords = 0;
4457 }
Douglas Gregore727d212012-01-30 06:38:25 +00004458 virtual bool hasFeature(StringRef Feature) const {
4459 return Feature == "msp430";
4460 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004461 virtual void getGCCRegNames(const char * const *&Names,
4462 unsigned &NumNames) const;
4463 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4464 unsigned &NumAliases) const {
4465 // No aliases.
4466 Aliases = 0;
4467 NumAliases = 0;
4468 }
4469 virtual bool validateAsmConstraint(const char *&Name,
4470 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004471 // No target constraints for now.
4472 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004473 }
4474 virtual const char *getClobbers() const {
4475 // FIXME: Is this really right?
4476 return "";
4477 }
Meador Ingec5613b22012-06-16 03:34:49 +00004478 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004479 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004480 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004481 }
4482 };
4483
4484 const char * const MSP430TargetInfo::GCCRegNames[] = {
4485 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4486 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4487 };
4488
4489 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4490 unsigned &NumNames) const {
4491 Names = GCCRegNames;
4492 NumNames = llvm::array_lengthof(GCCRegNames);
4493 }
4494}
4495
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004496namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004497
Mike Stump1eb44332009-09-09 15:08:12 +00004498 // LLVM and Clang cannot be used directly to output native binaries for
4499 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004500 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004501 //
4502 // TCE uses the llvm bitcode as input and uses it for generating customized
4503 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004504 // publicly available in http://tce.cs.tut.fi
4505
Eli Friedman209f5bb2011-10-07 19:51:42 +00004506 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4507 3, // opencl_global
4508 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004509 5, // opencl_constant
4510 0, // cuda_device
4511 0, // cuda_constant
4512 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004513 };
4514
Eli Friedmanb63decf2009-08-19 20:47:07 +00004515 class TCETargetInfo : public TargetInfo{
4516 public:
4517 TCETargetInfo(const std::string& triple) : TargetInfo(triple) {
4518 TLSSupported = false;
4519 IntWidth = 32;
4520 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004521 PointerWidth = 32;
4522 IntAlign = 32;
4523 LongAlign = LongLongAlign = 32;
4524 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004525 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004526 SizeType = UnsignedInt;
4527 IntMaxType = SignedLong;
4528 UIntMaxType = UnsignedLong;
4529 IntPtrType = SignedInt;
4530 PtrDiffType = SignedInt;
4531 FloatWidth = 32;
4532 FloatAlign = 32;
4533 DoubleWidth = 32;
4534 DoubleAlign = 32;
4535 LongDoubleWidth = 32;
4536 LongDoubleAlign = 32;
4537 FloatFormat = &llvm::APFloat::IEEEsingle;
4538 DoubleFormat = &llvm::APFloat::IEEEsingle;
4539 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004540 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4541 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004542 "f32:32:32-f64:32:32-v64:32:32-"
4543 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004544 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004545 }
4546
4547 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004548 MacroBuilder &Builder) const {
4549 DefineStd(Builder, "tce", Opts);
4550 Builder.defineMacro("__TCE__");
4551 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004552 }
Douglas Gregore727d212012-01-30 06:38:25 +00004553 virtual bool hasFeature(StringRef Feature) const {
4554 return Feature == "tce";
4555 }
4556
Eli Friedmanb63decf2009-08-19 20:47:07 +00004557 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4558 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004559 virtual const char *getClobbers() const {
4560 return "";
4561 }
Meador Ingec5613b22012-06-16 03:34:49 +00004562 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4563 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004564 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004565 virtual void getGCCRegNames(const char * const *&Names,
4566 unsigned &NumNames) const {}
4567 virtual bool validateAsmConstraint(const char *&Name,
4568 TargetInfo::ConstraintInfo &info) const {
4569 return true;
4570 }
4571 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4572 unsigned &NumAliases) const {}
4573 };
4574}
4575
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004576namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004577class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004578 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004579 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004580 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004581 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004582 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004583 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004584 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004585 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004586 enum DspRevEnum {
4587 NoDSP, DSP1, DSP2
4588 } DspRev;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004589
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004590protected:
4591 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004592
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004593public:
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004594 MipsTargetInfoBase(const std::string& triple,
4595 const std::string& ABIStr,
4596 const std::string& CPUStr)
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004597 : TargetInfo(triple),
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004598 CPU(CPUStr),
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004599 IsMips16(false),
Simon Atanasyan321ae792013-04-14 14:07:51 +00004600 IsMicromips(false),
Simon Atanasyand96e3152013-04-14 14:07:30 +00004601 IsSingleFloat(false),
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004602 FloatABI(HardFloat),
Simon Atanasyana1b62272012-07-05 20:16:22 +00004603 DspRev(NoDSP),
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004604 ABI(ABIStr)
4605 {}
4606
Eric Christophered734732010-03-02 02:41:08 +00004607 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004608 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004609 virtual bool setCPU(const std::string &Name) {
4610 CPU = Name;
4611 return true;
4612 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004613 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004614 Features[ABI] = true;
4615 Features[CPU] = true;
4616 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004617
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004618 virtual void getTargetDefines(const LangOptions &Opts,
4619 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004620 DefineStd(Builder, "mips", Opts);
4621 Builder.defineMacro("_mips");
4622 Builder.defineMacro("__REGISTER_PREFIX__", "");
4623
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004624 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004625 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004626 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004627 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004628 case SoftFloat:
4629 Builder.defineMacro("__mips_soft_float", Twine(1));
4630 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004631 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004632
Simon Atanasyand96e3152013-04-14 14:07:30 +00004633 if (IsSingleFloat)
4634 Builder.defineMacro("__mips_single_float", Twine(1));
4635
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004636 if (IsMips16)
4637 Builder.defineMacro("__mips16", Twine(1));
4638
Simon Atanasyan321ae792013-04-14 14:07:51 +00004639 if (IsMicromips)
4640 Builder.defineMacro("__mips_micromips", Twine(1));
4641
Simon Atanasyana1b62272012-07-05 20:16:22 +00004642 switch (DspRev) {
4643 default:
4644 break;
4645 case DSP1:
4646 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4647 Builder.defineMacro("__mips_dsp", Twine(1));
4648 break;
4649 case DSP2:
4650 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4651 Builder.defineMacro("__mips_dspr2", Twine(1));
4652 Builder.defineMacro("__mips_dsp", Twine(1));
4653 break;
4654 }
4655
Simon Atanasyan90913892012-04-05 19:28:31 +00004656 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4657 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4658 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004659
4660 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4661 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004662 }
4663
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004664 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4665 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004666 Records = BuiltinInfo;
4667 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004668 }
Douglas Gregore727d212012-01-30 06:38:25 +00004669 virtual bool hasFeature(StringRef Feature) const {
4670 return Feature == "mips";
4671 }
Meador Ingec5613b22012-06-16 03:34:49 +00004672 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4673 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004674 }
4675 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004676 unsigned &NumNames) const {
4677 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004678 // CPU register names
4679 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004680 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4681 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4682 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004683 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4684 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004685 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4686 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4687 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4688 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004689 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004690 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4691 "$fcc5","$fcc6","$fcc7"
4692 };
4693 Names = GCCRegNames;
4694 NumNames = llvm::array_lengthof(GCCRegNames);
4695 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004696 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004697 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004698 virtual bool validateAsmConstraint(const char *&Name,
4699 TargetInfo::ConstraintInfo &Info) const {
4700 switch (*Name) {
4701 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004702 return false;
4703
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004704 case 'r': // CPU registers.
4705 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4706 case 'y': // Equivalent to "r", backwards compatibility only.
4707 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004708 case 'c': // $25 for indirect jumps
4709 case 'l': // lo register
4710 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004711 Info.setAllowsRegister();
4712 return true;
Jack Carter97102302013-03-05 19:10:54 +00004713 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004714 Info.setAllowsMemory();
4715 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004716 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004717 }
4718
4719 virtual const char *getClobbers() const {
4720 // FIXME: Implement!
4721 return "";
4722 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004723
4724 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4725 StringRef Name,
4726 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004727 if (Name == "soft-float" || Name == "single-float" ||
4728 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4729 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004730 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyan321ae792013-04-14 14:07:51 +00004731 Name == "mips16" || Name == "micromips" ||
4732 Name == "dsp" || Name == "dspr2") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004733 Features[Name] = Enabled;
4734 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004735 } else if (Name == "32") {
4736 Features["o32"] = Enabled;
4737 return true;
4738 } else if (Name == "64") {
4739 Features["n64"] = Enabled;
4740 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004741 }
4742 return false;
4743 }
4744
4745 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004746 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004747 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004748 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004749 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004750 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004751
4752 for (std::vector<std::string>::iterator it = Features.begin(),
4753 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004754 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004755 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004756 else if (*it == "+soft-float")
4757 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004758 else if (*it == "+mips16")
4759 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004760 else if (*it == "+micromips")
4761 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004762 else if (*it == "+dsp")
4763 DspRev = std::max(DspRev, DSP1);
4764 else if (*it == "+dspr2")
4765 DspRev = std::max(DspRev, DSP2);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004766 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004767
4768 // Remove front-end specific option.
4769 std::vector<std::string>::iterator it =
4770 std::find(Features.begin(), Features.end(), "+soft-float");
4771 if (it != Features.end())
4772 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004773 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004774
4775 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4776 if (RegNo == 0) return 4;
4777 if (RegNo == 1) return 5;
4778 return -1;
4779 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004780};
4781
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004782const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4783#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4784#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4785 ALL_LANGUAGES },
4786#include "clang/Basic/BuiltinsMips.def"
4787};
4788
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004789class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004790public:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004791 Mips32TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004792 MipsTargetInfoBase(triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004793 SizeType = UnsignedInt;
4794 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004795 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004796 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004797 virtual bool setABI(const std::string &Name) {
4798 if ((Name == "o32") || (Name == "eabi")) {
4799 ABI = Name;
4800 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004801 } else if (Name == "32") {
4802 ABI = "o32";
4803 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004804 } else
4805 return false;
4806 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004807 virtual void getTargetDefines(const LangOptions &Opts,
4808 MacroBuilder &Builder) const {
4809 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004810
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004811 if (ABI == "o32") {
4812 Builder.defineMacro("__mips_o32");
4813 Builder.defineMacro("_ABIO32", "1");
4814 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4815 }
4816 else if (ABI == "eabi")
4817 Builder.defineMacro("__mips_eabi");
4818 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004819 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004820 }
4821 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4822 unsigned &NumAliases) const {
4823 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4824 { { "at" }, "$1" },
4825 { { "v0" }, "$2" },
4826 { { "v1" }, "$3" },
4827 { { "a0" }, "$4" },
4828 { { "a1" }, "$5" },
4829 { { "a2" }, "$6" },
4830 { { "a3" }, "$7" },
4831 { { "t0" }, "$8" },
4832 { { "t1" }, "$9" },
4833 { { "t2" }, "$10" },
4834 { { "t3" }, "$11" },
4835 { { "t4" }, "$12" },
4836 { { "t5" }, "$13" },
4837 { { "t6" }, "$14" },
4838 { { "t7" }, "$15" },
4839 { { "s0" }, "$16" },
4840 { { "s1" }, "$17" },
4841 { { "s2" }, "$18" },
4842 { { "s3" }, "$19" },
4843 { { "s4" }, "$20" },
4844 { { "s5" }, "$21" },
4845 { { "s6" }, "$22" },
4846 { { "s7" }, "$23" },
4847 { { "t8" }, "$24" },
4848 { { "t9" }, "$25" },
4849 { { "k0" }, "$26" },
4850 { { "k1" }, "$27" },
4851 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004852 { { "sp","$sp" }, "$29" },
4853 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004854 { { "ra" }, "$31" }
4855 };
4856 Aliases = GCCRegAliases;
4857 NumAliases = llvm::array_lengthof(GCCRegAliases);
4858 }
4859};
4860
4861class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4862public:
4863 Mips32EBTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
4864 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004865 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004866 }
4867 virtual void getTargetDefines(const LangOptions &Opts,
4868 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004869 DefineStd(Builder, "MIPSEB", Opts);
4870 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004871 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004872 }
4873};
4874
4875class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4876public:
4877 Mips32ELTargetInfo(const std::string& triple) : Mips32TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004878 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004879 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:32-i16:16:32-i32:32:32-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004880 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004881 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004882 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004883 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004884 DefineStd(Builder, "MIPSEL", Opts);
4885 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004886 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004887 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004888};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004889
4890class Mips64TargetInfoBase : public MipsTargetInfoBase {
4891 virtual void SetDescriptionString(const std::string &Name) = 0;
4892public:
4893 Mips64TargetInfoBase(const std::string& triple) :
Simon Atanasyan10e1629d2012-04-12 19:59:24 +00004894 MipsTargetInfoBase(triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004895 LongWidth = LongAlign = 64;
4896 PointerWidth = PointerAlign = 64;
4897 LongDoubleWidth = LongDoubleAlign = 128;
4898 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004899 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4900 LongDoubleWidth = LongDoubleAlign = 64;
4901 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4902 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004903 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004904 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004905 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004906 virtual bool setABI(const std::string &Name) {
4907 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004908 if (Name == "n32") {
4909 LongWidth = LongAlign = 32;
4910 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004911 ABI = Name;
4912 return true;
4913 } else if (Name == "n64") {
4914 ABI = Name;
4915 return true;
4916 } else if (Name == "64") {
4917 ABI = "n64";
4918 return true;
4919 } else
4920 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004921 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004922 virtual void getTargetDefines(const LangOptions &Opts,
4923 MacroBuilder &Builder) const {
4924 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004925
Simon Atanasyan600a5132012-08-29 20:50:11 +00004926 Builder.defineMacro("__mips64");
4927 Builder.defineMacro("__mips64__");
4928
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004929 if (ABI == "n32") {
4930 Builder.defineMacro("__mips_n32");
4931 Builder.defineMacro("_ABIN32", "2");
4932 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4933 }
4934 else if (ABI == "n64") {
4935 Builder.defineMacro("__mips_n64");
4936 Builder.defineMacro("_ABI64", "3");
4937 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4938 }
4939 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004940 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004941 }
4942 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4943 unsigned &NumAliases) const {
4944 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4945 { { "at" }, "$1" },
4946 { { "v0" }, "$2" },
4947 { { "v1" }, "$3" },
4948 { { "a0" }, "$4" },
4949 { { "a1" }, "$5" },
4950 { { "a2" }, "$6" },
4951 { { "a3" }, "$7" },
4952 { { "a4" }, "$8" },
4953 { { "a5" }, "$9" },
4954 { { "a6" }, "$10" },
4955 { { "a7" }, "$11" },
4956 { { "t0" }, "$12" },
4957 { { "t1" }, "$13" },
4958 { { "t2" }, "$14" },
4959 { { "t3" }, "$15" },
4960 { { "s0" }, "$16" },
4961 { { "s1" }, "$17" },
4962 { { "s2" }, "$18" },
4963 { { "s3" }, "$19" },
4964 { { "s4" }, "$20" },
4965 { { "s5" }, "$21" },
4966 { { "s6" }, "$22" },
4967 { { "s7" }, "$23" },
4968 { { "t8" }, "$24" },
4969 { { "t9" }, "$25" },
4970 { { "k0" }, "$26" },
4971 { { "k1" }, "$27" },
4972 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004973 { { "sp","$sp" }, "$29" },
4974 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004975 { { "ra" }, "$31" }
4976 };
4977 Aliases = GCCRegAliases;
4978 NumAliases = llvm::array_lengthof(GCCRegAliases);
4979 }
4980};
4981
4982class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4983 virtual void SetDescriptionString(const std::string &Name) {
4984 // Change DescriptionString only if ABI is n32.
4985 if (Name == "n32")
4986 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 +00004987 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004988 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004989 }
4990public:
4991 Mips64EBTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
4992 // Default ABI is n64.
4993 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 +00004994 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004995 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004996 }
4997 virtual void getTargetDefines(const LangOptions &Opts,
4998 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004999 DefineStd(Builder, "MIPSEB", Opts);
5000 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005001 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005002 }
5003};
5004
5005class Mips64ELTargetInfo : public Mips64TargetInfoBase {
5006 virtual void SetDescriptionString(const std::string &Name) {
5007 // Change DescriptionString only if ABI is n32.
5008 if (Name == "n32")
5009 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 +00005010 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005011 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005012 }
5013public:
5014 Mips64ELTargetInfo(const std::string& triple) : Mips64TargetInfoBase(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005015 // Default ABI is n64.
5016 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005017 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 +00005018 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00005019 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005020 }
5021 virtual void getTargetDefines(const LangOptions &Opts,
5022 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005023 DefineStd(Builder, "MIPSEL", Opts);
5024 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005025 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005026 }
5027};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005028} // end anonymous namespace.
5029
Ivan Krasinef05abd2011-08-24 20:22:22 +00005030namespace {
5031class PNaClTargetInfo : public TargetInfo {
5032public:
5033 PNaClTargetInfo(const std::string& triple) : TargetInfo(triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005034 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005035 this->UserLabelPrefix = "";
5036 this->LongAlign = 32;
5037 this->LongWidth = 32;
5038 this->PointerAlign = 32;
5039 this->PointerWidth = 32;
5040 this->IntMaxType = TargetInfo::SignedLongLong;
5041 this->UIntMaxType = TargetInfo::UnsignedLongLong;
5042 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005043 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005044 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005045 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005046 this->SizeType = TargetInfo::UnsignedInt;
5047 this->PtrDiffType = TargetInfo::SignedInt;
5048 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00005049 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00005050 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
5051 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
5052 }
5053
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005054 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00005055 }
5056 virtual void getArchDefines(const LangOptions &Opts,
5057 MacroBuilder &Builder) const {
5058 Builder.defineMacro("__le32__");
5059 Builder.defineMacro("__pnacl__");
5060 }
5061 virtual void getTargetDefines(const LangOptions &Opts,
5062 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00005063 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00005064 getArchDefines(Opts, Builder);
5065 }
Douglas Gregore727d212012-01-30 06:38:25 +00005066 virtual bool hasFeature(StringRef Feature) const {
5067 return Feature == "pnacl";
5068 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00005069 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5070 unsigned &NumRecords) const {
5071 }
Meador Ingec5613b22012-06-16 03:34:49 +00005072 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5073 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005074 }
5075 virtual void getGCCRegNames(const char * const *&Names,
5076 unsigned &NumNames) const;
5077 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5078 unsigned &NumAliases) const;
5079 virtual bool validateAsmConstraint(const char *&Name,
5080 TargetInfo::ConstraintInfo &Info) const {
5081 return false;
5082 }
5083
5084 virtual const char *getClobbers() const {
5085 return "";
5086 }
5087};
5088
5089void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
5090 unsigned &NumNames) const {
5091 Names = NULL;
5092 NumNames = 0;
5093}
5094
5095void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5096 unsigned &NumAliases) const {
5097 Aliases = NULL;
5098 NumAliases = 0;
5099}
5100} // end anonymous namespace.
5101
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005102namespace {
5103 static const unsigned SPIRAddrSpaceMap[] = {
5104 1, // opencl_global
5105 3, // opencl_local
5106 2, // opencl_constant
5107 0, // cuda_device
5108 0, // cuda_constant
5109 0 // cuda_shared
5110 };
5111 class SPIRTargetInfo : public TargetInfo {
5112 static const char * const GCCRegNames[];
5113 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005114 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005115 public:
5116 SPIRTargetInfo(const std::string& triple) : TargetInfo(triple) {
5117 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5118 "SPIR target must use unknown OS");
5119 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5120 "SPIR target must use unknown environment type");
5121 BigEndian = false;
5122 TLSSupported = false;
5123 LongWidth = LongAlign = 64;
5124 AddrSpaceMap = &SPIRAddrSpaceMap;
5125 // Define available target features
5126 // These must be defined in sorted order!
5127 NoAsmVariants = true;
5128 }
5129 virtual void getTargetDefines(const LangOptions &Opts,
5130 MacroBuilder &Builder) const {
5131 DefineStd(Builder, "SPIR", Opts);
5132 }
5133 virtual bool hasFeature(StringRef Feature) const {
5134 return Feature == "spir";
5135 }
5136
5137 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5138 unsigned &NumRecords) const {}
5139 virtual const char *getClobbers() const {
5140 return "";
5141 }
5142 virtual void getGCCRegNames(const char * const *&Names,
5143 unsigned &NumNames) const {}
5144 virtual bool validateAsmConstraint(const char *&Name,
5145 TargetInfo::ConstraintInfo &info) const {
5146 return true;
5147 }
5148 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5149 unsigned &NumAliases) const {}
5150 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5151 return TargetInfo::VoidPtrBuiltinVaList;
5152 }
5153 };
5154
5155
5156 class SPIR32TargetInfo : public SPIRTargetInfo {
5157 public:
5158 SPIR32TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
5159 PointerWidth = PointerAlign = 32;
5160 SizeType = TargetInfo::UnsignedInt;
5161 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5162 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005163 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005164 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5165 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5166 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005167 }
5168 virtual void getTargetDefines(const LangOptions &Opts,
5169 MacroBuilder &Builder) const {
5170 DefineStd(Builder, "SPIR32", Opts);
5171 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005172 };
5173
5174 class SPIR64TargetInfo : public SPIRTargetInfo {
5175 public:
5176 SPIR64TargetInfo(const std::string& triple) : SPIRTargetInfo(triple) {
5177 PointerWidth = PointerAlign = 64;
5178 SizeType = TargetInfo::UnsignedLong;
5179 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5180 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005181 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005182 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5183 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5184 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005185 }
5186 virtual void getTargetDefines(const LangOptions &Opts,
5187 MacroBuilder &Builder) const {
5188 DefineStd(Builder, "SPIR64", Opts);
5189 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005190 };
5191}
5192
Ivan Krasinef05abd2011-08-24 20:22:22 +00005193
Reid Spencer5f016e22007-07-11 17:01:13 +00005194//===----------------------------------------------------------------------===//
5195// Driver code
5196//===----------------------------------------------------------------------===//
5197
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005198static TargetInfo *AllocateTarget(const std::string &T) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005199 llvm::Triple Triple(T);
5200 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005201
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005202 switch (Triple.getArch()) {
5203 default:
5204 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005205
Tony Linthicum96319392011-12-12 21:14:55 +00005206 case llvm::Triple::hexagon:
5207 return new HexagonTargetInfo(T);
5208
Tim Northoverc264e162013-01-31 12:13:10 +00005209 case llvm::Triple::aarch64:
5210 switch (os) {
5211 case llvm::Triple::Linux:
5212 return new LinuxTargetInfo<AArch64TargetInfo>(T);
5213 default:
5214 return new AArch64TargetInfo(T);
5215 }
5216
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005217 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005218 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005219 if (Triple.isOSDarwin())
5220 return new DarwinARMTargetInfo(T);
5221
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005222 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005223 case llvm::Triple::Linux:
5224 return new LinuxTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005225 case llvm::Triple::FreeBSD:
Torok Edwin5f6c1942009-06-30 17:10:35 +00005226 return new FreeBSDTargetInfo<ARMTargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005227 case llvm::Triple::NetBSD:
5228 return new NetBSDTargetInfo<ARMTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005229 case llvm::Triple::OpenBSD:
5230 return new OpenBSDTargetInfo<ARMTargetInfo>(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005231 case llvm::Triple::Bitrig:
5232 return new BitrigTargetInfo<ARMTargetInfo>(T);
Douglas Gregordca52262011-07-01 22:41:14 +00005233 case llvm::Triple::RTEMS:
5234 return new RTEMSTargetInfo<ARMTargetInfo>(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005235 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005236 return new NaClTargetInfo<ARMTargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005237 default:
5238 return new ARMTargetInfo(T);
5239 }
Eli Friedman61538a72008-05-20 14:21:01 +00005240
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005241 case llvm::Triple::msp430:
5242 return new MSP430TargetInfo(T);
Eli Friedman61538a72008-05-20 14:21:01 +00005243
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005244 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005245 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005246 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005247 return new LinuxTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005248 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005249 return new RTEMSTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005250 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005251 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005252 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005253 return new NetBSDTargetInfo<Mips32EBTargetInfo>(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005254 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005255 return new Mips32EBTargetInfo(T);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005256 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005257
5258 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005259 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005260 case llvm::Triple::Linux:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005261 return new LinuxTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005262 case llvm::Triple::RTEMS:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005263 return new RTEMSTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005264 case llvm::Triple::FreeBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005265 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005266 case llvm::Triple::NetBSD:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005267 return new NetBSDTargetInfo<Mips32ELTargetInfo>(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005268 default:
Akira Hatanakab6a37b32011-09-20 19:00:23 +00005269 return new Mips32ELTargetInfo(T);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005270 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005271
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005272 case llvm::Triple::mips64:
5273 switch (os) {
5274 case llvm::Triple::Linux:
5275 return new LinuxTargetInfo<Mips64EBTargetInfo>(T);
5276 case llvm::Triple::RTEMS:
5277 return new RTEMSTargetInfo<Mips64EBTargetInfo>(T);
5278 case llvm::Triple::FreeBSD:
5279 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(T);
5280 case llvm::Triple::NetBSD:
5281 return new NetBSDTargetInfo<Mips64EBTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005282 case llvm::Triple::OpenBSD:
5283 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005284 default:
5285 return new Mips64EBTargetInfo(T);
5286 }
5287
5288 case llvm::Triple::mips64el:
5289 switch (os) {
5290 case llvm::Triple::Linux:
5291 return new LinuxTargetInfo<Mips64ELTargetInfo>(T);
5292 case llvm::Triple::RTEMS:
5293 return new RTEMSTargetInfo<Mips64ELTargetInfo>(T);
5294 case llvm::Triple::FreeBSD:
5295 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(T);
5296 case llvm::Triple::NetBSD:
5297 return new NetBSDTargetInfo<Mips64ELTargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005298 case llvm::Triple::OpenBSD:
5299 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(T);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005300 default:
5301 return new Mips64ELTargetInfo(T);
5302 }
5303
Ivan Krasinef05abd2011-08-24 20:22:22 +00005304 case llvm::Triple::le32:
5305 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005306 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005307 return new NaClTargetInfo<PNaClTargetInfo>(T);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005308 default:
5309 return NULL;
5310 }
5311
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005312 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005313 if (Triple.isOSDarwin())
Roman Divackyc81f2a22011-01-06 08:27:10 +00005314 return new DarwinPPC32TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005315 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005316 case llvm::Triple::Linux:
5317 return new LinuxTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005318 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00005319 return new FreeBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005320 case llvm::Triple::NetBSD:
5321 return new NetBSDTargetInfo<PPC32TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005322 case llvm::Triple::OpenBSD:
5323 return new OpenBSDTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005324 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00005325 return new RTEMSTargetInfo<PPC32TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005326 default:
5327 return new PPC32TargetInfo(T);
5328 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005329
5330 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005331 if (Triple.isOSDarwin())
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00005332 return new DarwinPPC64TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005333 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005334 case llvm::Triple::Linux:
5335 return new LinuxTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005336 case llvm::Triple::Lv2:
John Thompson3f6918a2009-11-19 17:18:50 +00005337 return new PS3PPUTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005338 case llvm::Triple::FreeBSD:
Chris Lattnere03ae302010-02-16 18:14:57 +00005339 return new FreeBSDTargetInfo<PPC64TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005340 case llvm::Triple::NetBSD:
5341 return new NetBSDTargetInfo<PPC64TargetInfo>(T);
5342 default:
5343 return new PPC64TargetInfo(T);
5344 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005345
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005346 case llvm::Triple::nvptx:
5347 return new NVPTX32TargetInfo(T);
5348 case llvm::Triple::nvptx64:
5349 return new NVPTX64TargetInfo(T);
5350
Chris Lattner9cbeb632010-03-06 21:21:27 +00005351 case llvm::Triple::mblaze:
5352 return new MBlazeTargetInfo(T);
5353
Eli Friedman6505a292012-10-12 23:32:00 +00005354 case llvm::Triple::r600:
5355 return new R600TargetInfo(T);
5356
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005357 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005358 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005359 case llvm::Triple::Linux:
5360 return new LinuxTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005361 case llvm::Triple::AuroraUX:
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005362 return new AuroraUXSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005363 case llvm::Triple::Solaris:
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005364 return new SolarisSparcV8TargetInfo(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005365 case llvm::Triple::NetBSD:
5366 return new NetBSDTargetInfo<SparcV8TargetInfo>(T);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005367 case llvm::Triple::OpenBSD:
5368 return new OpenBSDTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005369 case llvm::Triple::RTEMS:
Douglas Gregordca52262011-07-01 22:41:14 +00005370 return new RTEMSTargetInfo<SparcV8TargetInfo>(T);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005371 default:
5372 return new SparcV8TargetInfo(T);
5373 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005374
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005375 case llvm::Triple::sparcv9:
5376 switch (os) {
5377 case llvm::Triple::Linux:
5378 return new LinuxTargetInfo<SparcV9TargetInfo>(T);
5379 case llvm::Triple::AuroraUX:
5380 return new AuroraUXTargetInfo<SparcV9TargetInfo>(T);
5381 case llvm::Triple::Solaris:
5382 return new SolarisTargetInfo<SparcV9TargetInfo>(T);
5383 case llvm::Triple::NetBSD:
5384 return new NetBSDTargetInfo<SparcV9TargetInfo>(T);
5385 case llvm::Triple::OpenBSD:
5386 return new OpenBSDTargetInfo<SparcV9TargetInfo>(T);
5387 case llvm::Triple::FreeBSD:
5388 return new FreeBSDTargetInfo<SparcV9TargetInfo>(T);
5389 default:
5390 return new SparcV9TargetInfo(T);
5391 }
5392
Ulrich Weigandb8409212013-05-06 16:26:41 +00005393 case llvm::Triple::systemz:
5394 switch (os) {
5395 case llvm::Triple::Linux:
5396 return new LinuxTargetInfo<SystemZTargetInfo>(T);
5397 default:
5398 return new SystemZTargetInfo(T);
5399 }
5400
Eli Friedmanb63decf2009-08-19 20:47:07 +00005401 case llvm::Triple::tce:
5402 return new TCETargetInfo(T);
5403
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005404 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005405 if (Triple.isOSDarwin())
5406 return new DarwinI386TargetInfo(T);
5407
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005408 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005409 case llvm::Triple::AuroraUX:
5410 return new AuroraUXTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005411 case llvm::Triple::Linux:
5412 return new LinuxTargetInfo<X86_32TargetInfo>(T);
5413 case llvm::Triple::DragonFly:
5414 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(T);
5415 case llvm::Triple::NetBSD:
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00005416 return new NetBSDI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005417 case llvm::Triple::OpenBSD:
5418 return new OpenBSDI386TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005419 case llvm::Triple::Bitrig:
5420 return new BitrigI386TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005421 case llvm::Triple::FreeBSD:
5422 return new FreeBSDTargetInfo<X86_32TargetInfo>(T);
Chris Lattner38e317d2010-07-07 16:01:42 +00005423 case llvm::Triple::Minix:
5424 return new MinixTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005425 case llvm::Triple::Solaris:
5426 return new SolarisTargetInfo<X86_32TargetInfo>(T);
5427 case llvm::Triple::Cygwin:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005428 return new CygwinX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005429 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005430 return new MinGWX86_32TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005431 case llvm::Triple::Win32:
Michael J. Spencera764e832010-10-21 08:22:51 +00005432 return new VisualStudioWindowsX86_32TargetInfo(T);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005433 case llvm::Triple::Haiku:
5434 return new HaikuX86_32TargetInfo(T);
Douglas Gregordca52262011-07-01 22:41:14 +00005435 case llvm::Triple::RTEMS:
5436 return new RTEMSX86_32TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005437 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005438 return new NaClTargetInfo<X86_32TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005439 default:
5440 return new X86_32TargetInfo(T);
5441 }
5442
5443 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005444 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
5445 return new DarwinX86_64TargetInfo(T);
5446
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005447 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005448 case llvm::Triple::AuroraUX:
5449 return new AuroraUXTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005450 case llvm::Triple::Linux:
5451 return new LinuxTargetInfo<X86_64TargetInfo>(T);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005452 case llvm::Triple::DragonFly:
5453 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005454 case llvm::Triple::NetBSD:
5455 return new NetBSDTargetInfo<X86_64TargetInfo>(T);
5456 case llvm::Triple::OpenBSD:
5457 return new OpenBSDX86_64TargetInfo(T);
Eli Friedman42f74f22012-08-08 23:57:20 +00005458 case llvm::Triple::Bitrig:
5459 return new BitrigX86_64TargetInfo(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005460 case llvm::Triple::FreeBSD:
5461 return new FreeBSDTargetInfo<X86_64TargetInfo>(T);
5462 case llvm::Triple::Solaris:
5463 return new SolarisTargetInfo<X86_64TargetInfo>(T);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005464 case llvm::Triple::MinGW32:
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005465 return new MinGWX86_64TargetInfo(T);
5466 case llvm::Triple::Win32: // This is what Triple.h supports now.
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005467 return new VisualStudioWindowsX86_64TargetInfo(T);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005468 case llvm::Triple::NaCl:
Derek Schuff7da46f92012-10-11 16:55:58 +00005469 return new NaClTargetInfo<X86_64TargetInfo>(T);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005470 default:
5471 return new X86_64TargetInfo(T);
5472 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005473
5474 case llvm::Triple::spir: {
5475 llvm::Triple Triple(T);
5476 if (Triple.getOS() != llvm::Triple::UnknownOS ||
5477 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
5478 return NULL;
5479 return new SPIR32TargetInfo(T);
5480 }
5481 case llvm::Triple::spir64: {
5482 llvm::Triple Triple(T);
5483 if (Triple.getOS() != llvm::Triple::UnknownOS ||
5484 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
5485 return NULL;
5486 return new SPIR64TargetInfo(T);
5487 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005488 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005489}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005490
5491/// CreateTargetInfo - Return the target info object for the specified target
5492/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005493TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005494 TargetOptions *Opts) {
5495 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005496
5497 // Construct the target
Dylan Noblesmith6f42b622012-02-05 02:12:40 +00005498 OwningPtr<TargetInfo> Target(AllocateTarget(Triple.str()));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005499 if (!Target) {
5500 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5501 return 0;
5502 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005503 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005504
Daniel Dunbareac7c532009-12-18 18:42:37 +00005505 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005506 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5507 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005508 return 0;
5509 }
5510
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005511 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005512 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5513 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005514 return 0;
5515 }
5516
Charles Davis98b7c5c2010-06-11 01:06:47 +00005517 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005518 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5519 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005520 return 0;
5521 }
5522
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005523 // Compute the default target features, we need the target to handle this
5524 // because features may have dependencies on one another.
5525 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005526 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005527
5528 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005529 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005530 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005531 it = Opts->FeaturesAsWritten.begin(),
5532 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005533 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005534 const char *Name = it->c_str();
5535
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005536 if (Name[0] != '+')
5537 continue;
5538
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005539 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005540 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
5541 Diags.Report(diag::err_target_invalid_feature) << Name;
5542 return 0;
5543 }
5544 }
5545
5546 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005547 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005548 it = Opts->FeaturesAsWritten.begin(),
5549 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005550 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005551 const char *Name = it->c_str();
5552
5553 if (Name[0] == '+')
5554 continue;
5555
5556 // Apply the feature via the target.
5557 if (Name[0] != '-' ||
5558 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005559 Diags.Report(diag::err_target_invalid_feature) << Name;
5560 return 0;
5561 }
5562 }
5563
5564 // Add the features to the compile options.
5565 //
5566 // FIXME: If we are completely confident that we have the right set, we only
5567 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005568 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005569 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5570 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005571 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
5572 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005573
5574 return Target.take();
5575}