blob: c4772723e909c13730b2b0530fbb935ce524145b [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:
Benjamin Kramer9df08232013-06-29 16:37:14 +000076 OSTargetInfo(const llvm::Triple &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) {
Bob Wilsond588f5c2013-08-19 20:23:37 +000091 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramera9992772010-01-09 17:55:51 +000092 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:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000182 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
183 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
184 this->MCountName = "\01mcount";
185 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000186
Chris Lattner5f9e2722011-07-23 10:55:15 +0000187 virtual std::string isValidSectionSpecifier(StringRef SR) const {
Chris Lattner797c3c42009-08-10 19:03:04 +0000188 // Let MCSectionMachO validate this.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000189 StringRef Segment, Section;
Chris Lattner797c3c42009-08-10 19:03:04 +0000190 unsigned TAA, StubSize;
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000191 bool HasTAA;
Chris Lattner797c3c42009-08-10 19:03:04 +0000192 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar9ae186f2011-03-19 02:06:21 +0000193 TAA, HasTAA, StubSize);
Chris Lattner797c3c42009-08-10 19:03:04 +0000194 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000195
Anders Carlsson18af3682010-06-08 22:47:50 +0000196 virtual const char *getStaticInitSectionSpecifier() const {
197 // FIXME: We should return 0 when building kexts.
198 return "__TEXT,__StaticInit,regular,pure_instructions";
199 }
Michael J. Spencer20249a12010-10-21 03:16:25 +0000200
John McCall41887602012-01-29 01:20:30 +0000201 /// Darwin does not support protected visibility. Darwin's "default"
202 /// is very similar to ELF's "protected"; Darwin requires a "weak"
203 /// attribute on declarations that can be dynamically replaced.
204 virtual bool hasProtectedVisibility() const {
205 return false;
206 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000207};
208
Chris Lattner797c3c42009-08-10 19:03:04 +0000209
Torok Edwin5f6c1942009-06-30 17:10:35 +0000210// DragonFlyBSD Target
211template<typename Target>
212class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
213protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000214 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000215 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000216 // DragonFly defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000217 Builder.defineMacro("__DragonFly__");
218 Builder.defineMacro("__DragonFly_cc_version", "100001");
219 Builder.defineMacro("__ELF__");
220 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
221 Builder.defineMacro("__tune_i386__");
222 DefineStd(Builder, "unix", Opts);
Torok Edwin5f6c1942009-06-30 17:10:35 +0000223 }
224public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000225 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
226 : OSTargetInfo<Target>(Triple) {
227 this->UserLabelPrefix = "";
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000228
Benjamin Kramer9df08232013-06-29 16:37:14 +0000229 switch (Triple.getArch()) {
230 default:
231 case llvm::Triple::x86:
232 case llvm::Triple::x86_64:
233 this->MCountName = ".mcount";
234 break;
235 }
Eli Friedmanb089c4d2012-02-10 23:02:29 +0000236 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000237};
238
239// FreeBSD Target
240template<typename Target>
241class FreeBSDTargetInfo : public OSTargetInfo<Target> {
242protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000243 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000244 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000245 // FreeBSD defines; list based off of gcc output
246
Benjamin Kramer474202f2011-10-18 10:10:08 +0000247 unsigned Release = Triple.getOSMajorVersion();
248 if (Release == 0U)
249 Release = 8;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000250
Benjamin Kramer474202f2011-10-18 10:10:08 +0000251 Builder.defineMacro("__FreeBSD__", Twine(Release));
252 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramera9992772010-01-09 17:55:51 +0000253 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
254 DefineStd(Builder, "unix", Opts);
255 Builder.defineMacro("__ELF__");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000256 }
257public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000258 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
259 this->UserLabelPrefix = "";
Roman Divackybe4c8702011-02-10 16:52:03 +0000260
Benjamin Kramer9df08232013-06-29 16:37:14 +0000261 switch (Triple.getArch()) {
262 default:
263 case llvm::Triple::x86:
264 case llvm::Triple::x86_64:
265 this->MCountName = ".mcount";
266 break;
267 case llvm::Triple::mips:
268 case llvm::Triple::mipsel:
269 case llvm::Triple::ppc:
270 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000271 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000272 this->MCountName = "_mcount";
273 break;
274 case llvm::Triple::arm:
275 this->MCountName = "__mcount";
276 break;
Duncan Sands1e90faf2009-07-08 13:55:08 +0000277 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000278 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000279};
280
Chris Lattner38e317d2010-07-07 16:01:42 +0000281// Minix Target
282template<typename Target>
283class MinixTargetInfo : public OSTargetInfo<Target> {
284protected:
285 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
286 MacroBuilder &Builder) const {
287 // Minix defines
288
289 Builder.defineMacro("__minix", "3");
290 Builder.defineMacro("_EM_WSIZE", "4");
291 Builder.defineMacro("_EM_PSIZE", "4");
292 Builder.defineMacro("_EM_SSIZE", "2");
293 Builder.defineMacro("_EM_LSIZE", "4");
294 Builder.defineMacro("_EM_FSIZE", "4");
295 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman6d402dc2011-12-08 23:54:21 +0000296 Builder.defineMacro("__ELF__");
Chris Lattner38e317d2010-07-07 16:01:42 +0000297 DefineStd(Builder, "unix", Opts);
298 }
299public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000300 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
301 this->UserLabelPrefix = "";
302 }
Chris Lattner38e317d2010-07-07 16:01:42 +0000303};
304
Torok Edwin5f6c1942009-06-30 17:10:35 +0000305// Linux target
306template<typename Target>
307class LinuxTargetInfo : public OSTargetInfo<Target> {
308protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000309 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000310 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000311 // Linux defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000312 DefineStd(Builder, "unix", Opts);
313 DefineStd(Builder, "linux", Opts);
314 Builder.defineMacro("__gnu_linux__");
315 Builder.defineMacro("__ELF__");
Logan Chien94a71422012-09-02 09:30:11 +0000316 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov32064032012-04-26 12:08:09 +0000317 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000318 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000319 Builder.defineMacro("_REENTRANT");
Douglas Gregor2b003fd2010-04-21 05:52:38 +0000320 if (Opts.CPlusPlus)
321 Builder.defineMacro("_GNU_SOURCE");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000322 }
323public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000324 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000325 this->UserLabelPrefix = "";
Douglas Gregor12e84642011-01-12 21:19:25 +0000326 this->WIntType = TargetInfo::UnsignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000327 }
Benjamin Kramer86d18c52011-10-15 17:53:33 +0000328
329 virtual const char *getStaticInitSectionSpecifier() const {
330 return ".text.startup";
331 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000332};
333
Chris Lattnerb62bb282009-07-13 20:29:08 +0000334// NetBSD Target
335template<typename Target>
336class NetBSDTargetInfo : public OSTargetInfo<Target> {
337protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000338 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000339 MacroBuilder &Builder) const {
Chris Lattnerb62bb282009-07-13 20:29:08 +0000340 // NetBSD defines; list based off of gcc output
Benjamin Kramera9992772010-01-09 17:55:51 +0000341 Builder.defineMacro("__NetBSD__");
342 Builder.defineMacro("__unix__");
343 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000344 if (Opts.POSIXThreads)
Benjamin Kramera9992772010-01-09 17:55:51 +0000345 Builder.defineMacro("_POSIX_THREADS");
Chris Lattnerb62bb282009-07-13 20:29:08 +0000346 }
347public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000348 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
349 this->UserLabelPrefix = "";
350 }
Chris Lattnerb62bb282009-07-13 20:29:08 +0000351};
352
Torok Edwin5f6c1942009-06-30 17:10:35 +0000353// OpenBSD Target
354template<typename Target>
355class OpenBSDTargetInfo : public OSTargetInfo<Target> {
356protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000357 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000358 MacroBuilder &Builder) const {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000359 // OpenBSD defines; list based off of gcc output
360
Benjamin Kramera9992772010-01-09 17:55:51 +0000361 Builder.defineMacro("__OpenBSD__");
362 DefineStd(Builder, "unix", Opts);
363 Builder.defineMacro("__ELF__");
Daniel Dunbar5345c392009-09-03 04:54:28 +0000364 if (Opts.POSIXThreads)
Chris Lattner4ddcf3b2012-04-25 06:12:24 +0000365 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000366 }
367public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000368 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
369 this->UserLabelPrefix = "";
370 this->TLSSupported = false;
Eli Friedman62d829a2011-12-15 02:15:56 +0000371
Eli Friedman62d829a2011-12-15 02:15:56 +0000372 switch (Triple.getArch()) {
373 default:
374 case llvm::Triple::x86:
375 case llvm::Triple::x86_64:
376 case llvm::Triple::arm:
Eric Christopher825d3862012-11-14 22:08:59 +0000377 case llvm::Triple::sparc:
Eli Friedman62d829a2011-12-15 02:15:56 +0000378 this->MCountName = "__mcount";
379 break;
380 case llvm::Triple::mips64:
381 case llvm::Triple::mips64el:
382 case llvm::Triple::ppc:
Eric Christopher825d3862012-11-14 22:08:59 +0000383 case llvm::Triple::sparcv9:
Eli Friedman62d829a2011-12-15 02:15:56 +0000384 this->MCountName = "_mcount";
385 break;
386 }
387 }
Torok Edwin5f6c1942009-06-30 17:10:35 +0000388};
389
Eli Friedman42f74f22012-08-08 23:57:20 +0000390// Bitrig Target
391template<typename Target>
392class BitrigTargetInfo : public OSTargetInfo<Target> {
393protected:
394 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
395 MacroBuilder &Builder) const {
396 // Bitrig defines; list based off of gcc output
397
398 Builder.defineMacro("__Bitrig__");
399 DefineStd(Builder, "unix", Opts);
400 Builder.defineMacro("__ELF__");
401 if (Opts.POSIXThreads)
402 Builder.defineMacro("_REENTRANT");
403 }
404public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000405 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
406 this->UserLabelPrefix = "";
407 this->TLSSupported = false;
408 this->MCountName = "__mcount";
Eli Friedman42f74f22012-08-08 23:57:20 +0000409 }
410};
411
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000412// PSP Target
413template<typename Target>
414class PSPTargetInfo : public OSTargetInfo<Target> {
415protected:
416 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000417 MacroBuilder &Builder) const {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000418 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramera9992772010-01-09 17:55:51 +0000419 Builder.defineMacro("PSP");
420 Builder.defineMacro("_PSP");
421 Builder.defineMacro("__psp__");
422 Builder.defineMacro("__ELF__");
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000423 }
424public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000425 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan84423a82009-11-15 10:22:07 +0000426 this->UserLabelPrefix = "";
427 }
428};
429
John Thompson3f6918a2009-11-19 17:18:50 +0000430// PS3 PPU Target
431template<typename Target>
432class PS3PPUTargetInfo : public OSTargetInfo<Target> {
433protected:
434 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000435 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000436 // PS3 PPU defines.
John Thompsonfb457972010-03-25 16:18:32 +0000437 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000438 Builder.defineMacro("__PPU__");
439 Builder.defineMacro("__CELLOS_LV2__");
440 Builder.defineMacro("__ELF__");
441 Builder.defineMacro("__LP32__");
John Thompson8e6065a2010-06-24 22:44:13 +0000442 Builder.defineMacro("_ARCH_PPC64");
443 Builder.defineMacro("__powerpc64__");
John Thompson3f6918a2009-11-19 17:18:50 +0000444 }
445public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000446 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000447 this->UserLabelPrefix = "";
Nick Lewycky99520702011-12-16 22:32:39 +0000448 this->LongWidth = this->LongAlign = 32;
449 this->PointerWidth = this->PointerAlign = 32;
John Thompson8e6065a2010-06-24 22:44:13 +0000450 this->IntMaxType = TargetInfo::SignedLongLong;
451 this->UIntMaxType = TargetInfo::UnsignedLongLong;
452 this->Int64Type = TargetInfo::SignedLongLong;
John Thompsonec387af2009-12-18 14:21:08 +0000453 this->SizeType = TargetInfo::UnsignedInt;
John Thompson8e6065a2010-06-24 22:44:13 +0000454 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 +0000455 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
John Thompson3f6918a2009-11-19 17:18:50 +0000456 }
457};
458
459// FIXME: Need a real SPU target.
460// PS3 SPU Target
461template<typename Target>
462class PS3SPUTargetInfo : public OSTargetInfo<Target> {
463protected:
464 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000465 MacroBuilder &Builder) const {
John Thompson3f6918a2009-11-19 17:18:50 +0000466 // PS3 PPU defines.
Benjamin Kramera9992772010-01-09 17:55:51 +0000467 Builder.defineMacro("__SPU__");
468 Builder.defineMacro("__ELF__");
John Thompson3f6918a2009-11-19 17:18:50 +0000469 }
470public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000471 PS3SPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompson3f6918a2009-11-19 17:18:50 +0000472 this->UserLabelPrefix = "";
473 }
474};
475
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000476// AuroraUX target
477template<typename Target>
478class AuroraUXTargetInfo : public OSTargetInfo<Target> {
479protected:
480 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000481 MacroBuilder &Builder) const {
482 DefineStd(Builder, "sun", Opts);
483 DefineStd(Builder, "unix", Opts);
484 Builder.defineMacro("__ELF__");
485 Builder.defineMacro("__svr4__");
486 Builder.defineMacro("__SVR4");
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000487 }
488public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000489 AuroraUXTargetInfo(const llvm::Triple &Triple)
490 : OSTargetInfo<Target>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +0000491 this->UserLabelPrefix = "";
492 this->WCharType = this->SignedLong;
493 // FIXME: WIntType should be SignedLong
494 }
495};
496
Torok Edwin5f6c1942009-06-30 17:10:35 +0000497// Solaris target
498template<typename Target>
499class SolarisTargetInfo : public OSTargetInfo<Target> {
500protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +0000501 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +0000502 MacroBuilder &Builder) const {
503 DefineStd(Builder, "sun", Opts);
504 DefineStd(Builder, "unix", Opts);
505 Builder.defineMacro("__ELF__");
506 Builder.defineMacro("__svr4__");
507 Builder.defineMacro("__SVR4");
David Chisnall165329c2012-02-28 17:10:04 +0000508 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
509 // newer, but to 500 for everything else. feature_test.h has a check to
510 // ensure that you are not using C99 with an old version of X/Open or C89
511 // with a new version.
512 if (Opts.C99 || Opts.C11)
513 Builder.defineMacro("_XOPEN_SOURCE", "600");
514 else
515 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnallb4f0bd62012-03-02 10:49:52 +0000516 if (Opts.CPlusPlus)
David Chisnall165329c2012-02-28 17:10:04 +0000517 Builder.defineMacro("__C99FEATURES__");
David Chisnall48fad492012-02-17 18:35:11 +0000518 Builder.defineMacro("_LARGEFILE_SOURCE");
519 Builder.defineMacro("_LARGEFILE64_SOURCE");
520 Builder.defineMacro("__EXTENSIONS__");
David Chisnall165329c2012-02-28 17:10:04 +0000521 Builder.defineMacro("_REENTRANT");
Torok Edwin5f6c1942009-06-30 17:10:35 +0000522 }
523public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000524 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwin5f6c1942009-06-30 17:10:35 +0000525 this->UserLabelPrefix = "";
David Chisnallfb027842012-03-28 18:04:14 +0000526 this->WCharType = this->SignedInt;
Torok Edwin5f6c1942009-06-30 17:10:35 +0000527 // FIXME: WIntType should be SignedLong
528 }
529};
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000530
531// Windows target
532template<typename Target>
533class WindowsTargetInfo : public OSTargetInfo<Target> {
534protected:
535 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
536 MacroBuilder &Builder) const {
Michael J. Spencera764e832010-10-21 08:22:51 +0000537 Builder.defineMacro("_WIN32");
538 }
539 void getVisualStudioDefines(const LangOptions &Opts,
540 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000541 if (Opts.CPlusPlus) {
542 if (Opts.RTTI)
543 Builder.defineMacro("_CPPRTTI");
544
545 if (Opts.Exceptions)
546 Builder.defineMacro("_CPPUNWIND");
547 }
548
549 if (!Opts.CharIsSigned)
550 Builder.defineMacro("_CHAR_UNSIGNED");
551
552 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
553 // but it works for now.
554 if (Opts.POSIXThreads)
555 Builder.defineMacro("_MT");
Michael J. Spencera764e832010-10-21 08:22:51 +0000556
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000557 if (Opts.MSCVersion != 0)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000558 Builder.defineMacro("_MSC_VER", Twine(Opts.MSCVersion));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000559
Francois Pichet62ec1f22011-09-17 17:15:52 +0000560 if (Opts.MicrosoftExt) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000561 Builder.defineMacro("_MSC_EXTENSIONS");
562
Richard Smith80ad52f2013-01-02 11:42:31 +0000563 if (Opts.CPlusPlus11) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000564 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
565 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
566 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
567 }
568 }
569
570 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000571 }
572
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000573public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000574 WindowsTargetInfo(const llvm::Triple &Triple)
575 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencerdae4ac42010-10-21 05:21:48 +0000576};
577
Derek Schuff7da46f92012-10-11 16:55:58 +0000578template <typename Target>
579class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramer9df08232013-06-29 16:37:14 +0000580protected:
Derek Schuff7da46f92012-10-11 16:55:58 +0000581 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
582 MacroBuilder &Builder) const {
583 if (Opts.POSIXThreads)
584 Builder.defineMacro("_REENTRANT");
585 if (Opts.CPlusPlus)
586 Builder.defineMacro("_GNU_SOURCE");
587
588 DefineStd(Builder, "unix", Opts);
589 Builder.defineMacro("__ELF__");
590 Builder.defineMacro("__native_client__");
591 }
Benjamin Kramer9df08232013-06-29 16:37:14 +0000592
593public:
594 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff7da46f92012-10-11 16:55:58 +0000595 this->UserLabelPrefix = "";
596 this->LongAlign = 32;
597 this->LongWidth = 32;
598 this->PointerAlign = 32;
599 this->PointerWidth = 32;
600 this->IntMaxType = TargetInfo::SignedLongLong;
601 this->UIntMaxType = TargetInfo::UnsignedLongLong;
602 this->Int64Type = TargetInfo::SignedLongLong;
603 this->DoubleAlign = 64;
604 this->LongDoubleWidth = 64;
605 this->LongDoubleAlign = 64;
606 this->SizeType = TargetInfo::UnsignedInt;
607 this->PtrDiffType = TargetInfo::SignedInt;
608 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +0000609 // RegParmMax is inherited from the underlying architecture
Derek Schuff7da46f92012-10-11 16:55:58 +0000610 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
611 this->DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
612 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
613 }
Derek Schuff263366f2012-10-16 22:30:41 +0000614 virtual typename Target::CallingConvCheckResult checkCallingConvention(
615 CallingConv CC) const {
616 return CC == CC_PnaclCall ? Target::CCCR_OK :
617 Target::checkCallingConvention(CC);
618 }
Derek Schuff7da46f92012-10-11 16:55:58 +0000619};
Mike Stump1eb44332009-09-09 15:08:12 +0000620} // end anonymous namespace.
Torok Edwin5f6c1942009-06-30 17:10:35 +0000621
Chris Lattnerd29b6302008-10-05 21:50:58 +0000622//===----------------------------------------------------------------------===//
Eli Friedmane4277982008-08-20 23:11:40 +0000623// Specific target implementations.
624//===----------------------------------------------------------------------===//
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +0000625
Eli Friedmane4277982008-08-20 23:11:40 +0000626namespace {
627// PPC abstract base class
628class PPCTargetInfo : public TargetInfo {
629 static const Builtin::Info BuiltinInfo[];
630 static const char * const GCCRegNames[];
631 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel02a84272012-06-11 22:35:19 +0000632 std::string CPU;
Eli Friedmane4277982008-08-20 23:11:40 +0000633public:
Benjamin Kramer9df08232013-06-29 16:37:14 +0000634 PPCTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000635 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber6e1d2ea2012-01-31 02:07:33 +0000636 LongDoubleWidth = LongDoubleAlign = 128;
637 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
638 }
Eli Friedman15b91762009-06-05 07:05:05 +0000639
Hal Finkel39d5fa12012-07-03 16:51:04 +0000640 /// \brief Flags for architecture specific defines.
641 typedef enum {
642 ArchDefineNone = 0,
643 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
644 ArchDefinePpcgr = 1 << 1,
645 ArchDefinePpcsq = 1 << 2,
646 ArchDefine440 = 1 << 3,
647 ArchDefine603 = 1 << 4,
648 ArchDefine604 = 1 << 5,
649 ArchDefinePwr4 = 1 << 6,
Bill Schmidt2821e182013-02-01 20:23:10 +0000650 ArchDefinePwr5 = 1 << 7,
651 ArchDefinePwr5x = 1 << 8,
652 ArchDefinePwr6 = 1 << 9,
653 ArchDefinePwr6x = 1 << 10,
654 ArchDefinePwr7 = 1 << 11,
655 ArchDefineA2 = 1 << 12,
656 ArchDefineA2q = 1 << 13
Hal Finkel39d5fa12012-07-03 16:51:04 +0000657 } ArchDefineTypes;
658
Bill Schmidt2821e182013-02-01 20:23:10 +0000659 // Note: GCC recognizes the following additional cpus:
660 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
661 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
662 // titan, rs64.
Hal Finkel02a84272012-06-11 22:35:19 +0000663 virtual bool setCPU(const std::string &Name) {
664 bool CPUKnown = llvm::StringSwitch<bool>(Name)
665 .Case("generic", true)
666 .Case("440", true)
667 .Case("450", true)
668 .Case("601", true)
669 .Case("602", true)
670 .Case("603", true)
671 .Case("603e", true)
672 .Case("603ev", true)
673 .Case("604", true)
674 .Case("604e", true)
675 .Case("620", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000676 .Case("630", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000677 .Case("g3", true)
678 .Case("7400", true)
679 .Case("g4", true)
680 .Case("7450", true)
681 .Case("g4+", true)
682 .Case("750", true)
683 .Case("970", true)
684 .Case("g5", true)
685 .Case("a2", true)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000686 .Case("a2q", true)
Hal Finkel7de32962012-09-18 22:25:03 +0000687 .Case("e500mc", true)
688 .Case("e5500", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000689 .Case("power3", true)
690 .Case("pwr3", true)
691 .Case("power4", true)
692 .Case("pwr4", true)
693 .Case("power5", true)
694 .Case("pwr5", true)
695 .Case("power5x", true)
696 .Case("pwr5x", true)
697 .Case("power6", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000698 .Case("pwr6", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000699 .Case("power6x", true)
700 .Case("pwr6x", true)
701 .Case("power7", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000702 .Case("pwr7", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000703 .Case("powerpc", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000704 .Case("ppc", true)
Bill Schmidt2821e182013-02-01 20:23:10 +0000705 .Case("powerpc64", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000706 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000707 .Case("powerpc64le", true)
708 .Case("ppc64le", true)
Hal Finkel02a84272012-06-11 22:35:19 +0000709 .Default(false);
710
711 if (CPUKnown)
712 CPU = Name;
713
714 return CPUKnown;
715 }
716
Eli Friedmane4277982008-08-20 23:11:40 +0000717 virtual void getTargetBuiltins(const Builtin::Info *&Records,
718 unsigned &NumRecords) const {
Reid Spencer5f016e22007-07-11 17:01:13 +0000719 Records = BuiltinInfo;
Eli Friedmane4277982008-08-20 23:11:40 +0000720 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +0000721 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000722
Bob Wilson9f1c49c2012-01-28 18:02:29 +0000723 virtual bool isCLZForZeroUndef() const { return false; }
724
Chris Lattner33328642009-03-20 15:52:06 +0000725 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000726 MacroBuilder &Builder) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000727
Bill Schmidt199402b2013-02-01 02:14:03 +0000728 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
729
730 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
731 StringRef Name,
732 bool Enabled) const;
733
Douglas Gregore727d212012-01-30 06:38:25 +0000734 virtual bool hasFeature(StringRef Feature) const;
735
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000736 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000737 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000738 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000739 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000740 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000741 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000742 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000743 default: return false;
744 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000745 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000746 case 'b': // Base register
747 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000748 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000749 break;
750 // FIXME: The following are added to allow parsing.
751 // I just took a guess at what the actions should be.
752 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000753 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000754 case 'v': // Altivec vector register
755 Info.setAllowsRegister();
756 break;
757 case 'w':
758 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000759 case 'd':// VSX vector register to hold vector double data
760 case 'f':// VSX vector register to hold vector float data
761 case 's':// VSX vector register to hold scalar float data
762 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000763 break;
764 default:
765 return false;
766 }
767 Info.setAllowsRegister();
768 Name++; // Skip over 'w'.
769 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000770 case 'h': // `MQ', `CTR', or `LINK' register
771 case 'q': // `MQ' register
772 case 'c': // `CTR' register
773 case 'l': // `LINK' register
774 case 'x': // `CR' register (condition register) number 0
775 case 'y': // `CR' register (condition register)
776 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000777 Info.setAllowsRegister();
778 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000779 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000780 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000781 // (use `L' instead for SImode constants)
782 case 'K': // Unsigned 16-bit constant
783 case 'L': // Signed 16-bit constant shifted left 16 bits
784 case 'M': // Constant larger than 31
785 case 'N': // Exact power of 2
786 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000787 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000788 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000789 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000790 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000791 break;
792 case 'm': // Memory operand. Note that on PowerPC targets, m can
793 // include addresses that update the base register. It
794 // is therefore only safe to use `m' in an asm statement
795 // if that asm statement accesses the operand exactly once.
796 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000797 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000798 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000799 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000800 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000801 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
802 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000803 // register to be updated.
804 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000805 if (Name[1] != 's')
806 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000807 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000808 // include any automodification of the base register. Unlike
809 // `m', this constraint can be used in asm statements that
810 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000811 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000812 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000813 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000814 break;
815 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000816 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000817 case 'Z': // Memory operand that is an indexed or indirect from a
818 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000819 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000820 Info.setAllowsMemory();
821 Info.setAllowsRegister();
822 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000823 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000824 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000825 // register (`p' is preferable for asm statements)
826 case 'S': // Constant suitable as a 64-bit mask operand
827 case 'T': // Constant suitable as a 32-bit mask operand
828 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000829 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000830 // instructions
831 case 'W': // Vector constant that does not require memory
832 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000833 break;
834 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000835 }
John Thompson8e6065a2010-06-24 22:44:13 +0000836 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000837 }
Eli Friedmane4277982008-08-20 23:11:40 +0000838 virtual const char *getClobbers() const {
839 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000840 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000841 int getEHDataRegisterNumber(unsigned RegNo) const {
842 if (RegNo == 0) return 3;
843 if (RegNo == 1) return 4;
844 return -1;
845 }
Eli Friedmane4277982008-08-20 23:11:40 +0000846};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000847
Eli Friedmane4277982008-08-20 23:11:40 +0000848const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000849#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000850#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000851 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000852#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000853};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000854
855
Chris Lattnerc0f59212009-03-02 22:27:17 +0000856/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
857/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000858void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000859 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000860 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000861 Builder.defineMacro("__ppc__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000862 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000863 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000864 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000865 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000866 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000867 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000868 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000869 Builder.defineMacro("__ppc64__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000870 Builder.defineMacro("__PPC64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000871 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000872
Chris Lattnerc0f59212009-03-02 22:27:17 +0000873 // Target properties.
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000874 if (getTriple().getArch() == llvm::Triple::ppc64le) {
875 Builder.defineMacro("_LITTLE_ENDIAN");
876 Builder.defineMacro("__LITTLE_ENDIAN__");
877 } else {
878 if (getTriple().getOS() != llvm::Triple::NetBSD &&
879 getTriple().getOS() != llvm::Triple::OpenBSD)
880 Builder.defineMacro("_BIG_ENDIAN");
881 Builder.defineMacro("__BIG_ENDIAN__");
882 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000883
Chris Lattnerc0f59212009-03-02 22:27:17 +0000884 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000885 Builder.defineMacro("__NATURAL_ALIGNMENT__");
886 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000887
Chris Lattnerc0f59212009-03-02 22:27:17 +0000888 // FIXME: Should be controlled by command line option.
Roman Divackyb2f6f472013-07-03 19:45:54 +0000889 if (LongDoubleWidth == 128)
890 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000891
John Thompson3f6918a2009-11-19 17:18:50 +0000892 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000893 Builder.defineMacro("__VEC__", "10206");
894 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000895 }
Hal Finkel02a84272012-06-11 22:35:19 +0000896
897 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000898 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
899 .Case("440", ArchDefineName)
900 .Case("450", ArchDefineName | ArchDefine440)
901 .Case("601", ArchDefineName)
902 .Case("602", ArchDefineName | ArchDefinePpcgr)
903 .Case("603", ArchDefineName | ArchDefinePpcgr)
904 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
905 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
906 .Case("604", ArchDefineName | ArchDefinePpcgr)
907 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
908 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000909 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000910 .Case("7400", ArchDefineName | ArchDefinePpcgr)
911 .Case("7450", ArchDefineName | ArchDefinePpcgr)
912 .Case("750", ArchDefineName | ArchDefinePpcgr)
913 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
914 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000915 .Case("a2", ArchDefineA2)
916 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000917 .Case("pwr3", ArchDefinePpcgr)
918 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
919 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
920 | ArchDefinePpcsq)
921 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
922 | ArchDefinePpcgr | ArchDefinePpcsq)
923 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
924 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
925 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
926 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
927 | ArchDefinePpcsq)
928 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
929 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
930 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
931 .Case("power3", ArchDefinePpcgr)
932 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
933 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
934 | ArchDefinePpcsq)
935 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
936 | ArchDefinePpcgr | ArchDefinePpcsq)
937 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
938 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
939 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
940 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
941 | ArchDefinePpcsq)
942 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
943 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
944 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000945 .Default(ArchDefineNone);
946
947 if (defs & ArchDefineName)
948 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
949 if (defs & ArchDefinePpcgr)
950 Builder.defineMacro("_ARCH_PPCGR");
951 if (defs & ArchDefinePpcsq)
952 Builder.defineMacro("_ARCH_PPCSQ");
953 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000954 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000955 if (defs & ArchDefine603)
956 Builder.defineMacro("_ARCH_603");
957 if (defs & ArchDefine604)
958 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000959 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000960 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000961 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000962 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000963 if (defs & ArchDefinePwr5x)
964 Builder.defineMacro("_ARCH_PWR5X");
965 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000966 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000967 if (defs & ArchDefinePwr6x)
968 Builder.defineMacro("_ARCH_PWR6X");
969 if (defs & ArchDefinePwr7)
970 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000971 if (defs & ArchDefineA2)
972 Builder.defineMacro("_ARCH_A2");
973 if (defs & ArchDefineA2q) {
974 Builder.defineMacro("_ARCH_A2Q");
975 Builder.defineMacro("_ARCH_QP");
976 }
977
978 if (getTriple().getVendor() == llvm::Triple::BGQ) {
979 Builder.defineMacro("__bg__");
980 Builder.defineMacro("__THW_BLUEGENE__");
981 Builder.defineMacro("__bgq__");
982 Builder.defineMacro("__TOS_BGQ__");
983 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000984
985 // FIXME: The following are not yet generated here by Clang, but are
986 // generated by GCC:
987 //
988 // _SOFT_FLOAT_
989 // __RECIP_PRECISION__
990 // __APPLE_ALTIVEC__
991 // __VSX__
992 // __RECIP__
993 // __RECIPF__
994 // __RSQRTE__
995 // __RSQRTEF__
996 // _SOFT_DOUBLE_
997 // __NO_LWSYNC__
998 // __HAVE_BSWAP__
999 // __LONGDOUBLE128
1000 // __CMODEL_MEDIUM__
1001 // __CMODEL_LARGE__
1002 // _CALL_SYSV
1003 // _CALL_DARWIN
1004 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001005}
1006
1007void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1008 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1009 .Case("7400", true)
1010 .Case("g4", true)
1011 .Case("7450", true)
1012 .Case("g4+", true)
1013 .Case("970", true)
1014 .Case("g5", true)
1015 .Case("pwr6", true)
1016 .Case("pwr7", true)
1017 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001018 .Case("ppc64le", true)
Bill Schmidt199402b2013-02-01 02:14:03 +00001019 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001020
1021 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001022}
1023
1024bool PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1025 StringRef Name,
1026 bool Enabled) const {
Hal Finkelfe6b2712013-03-30 13:47:44 +00001027 if (Name == "altivec" || Name == "fprnd" || Name == "mfocrf" ||
1028 Name == "popcntd" || Name == "qpx") {
Bill Schmidt199402b2013-02-01 02:14:03 +00001029 Features[Name] = Enabled;
1030 return true;
Hal Finkel02a84272012-06-11 22:35:19 +00001031 }
Bill Schmidt199402b2013-02-01 02:14:03 +00001032
1033 return false;
Chris Lattnerc0f59212009-03-02 22:27:17 +00001034}
1035
Douglas Gregore727d212012-01-30 06:38:25 +00001036bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1037 return Feature == "powerpc";
1038}
Chris Lattner393ff042008-04-21 18:56:49 +00001039
Douglas Gregore727d212012-01-30 06:38:25 +00001040
Eli Friedmane4277982008-08-20 23:11:40 +00001041const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001042 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1043 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1044 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1045 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1046 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1047 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1048 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1049 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001050 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001051 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001052 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001053 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1054 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1055 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1056 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001057 "vrsave", "vscr",
1058 "spe_acc", "spefscr",
1059 "sfp"
1060};
Reid Spencer5f016e22007-07-11 17:01:13 +00001061
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001062void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001063 unsigned &NumNames) const {
1064 Names = GCCRegNames;
1065 NumNames = llvm::array_lengthof(GCCRegNames);
1066}
Reid Spencer5f016e22007-07-11 17:01:13 +00001067
Eli Friedmane4277982008-08-20 23:11:40 +00001068const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1069 // While some of these aliases do map to different registers
1070 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001071 { { "0" }, "r0" },
1072 { { "1"}, "r1" },
1073 { { "2" }, "r2" },
1074 { { "3" }, "r3" },
1075 { { "4" }, "r4" },
1076 { { "5" }, "r5" },
1077 { { "6" }, "r6" },
1078 { { "7" }, "r7" },
1079 { { "8" }, "r8" },
1080 { { "9" }, "r9" },
1081 { { "10" }, "r10" },
1082 { { "11" }, "r11" },
1083 { { "12" }, "r12" },
1084 { { "13" }, "r13" },
1085 { { "14" }, "r14" },
1086 { { "15" }, "r15" },
1087 { { "16" }, "r16" },
1088 { { "17" }, "r17" },
1089 { { "18" }, "r18" },
1090 { { "19" }, "r19" },
1091 { { "20" }, "r20" },
1092 { { "21" }, "r21" },
1093 { { "22" }, "r22" },
1094 { { "23" }, "r23" },
1095 { { "24" }, "r24" },
1096 { { "25" }, "r25" },
1097 { { "26" }, "r26" },
1098 { { "27" }, "r27" },
1099 { { "28" }, "r28" },
1100 { { "29" }, "r29" },
1101 { { "30" }, "r30" },
1102 { { "31" }, "r31" },
1103 { { "fr0" }, "f0" },
1104 { { "fr1" }, "f1" },
1105 { { "fr2" }, "f2" },
1106 { { "fr3" }, "f3" },
1107 { { "fr4" }, "f4" },
1108 { { "fr5" }, "f5" },
1109 { { "fr6" }, "f6" },
1110 { { "fr7" }, "f7" },
1111 { { "fr8" }, "f8" },
1112 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001113 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001114 { { "fr11" }, "f11" },
1115 { { "fr12" }, "f12" },
1116 { { "fr13" }, "f13" },
1117 { { "fr14" }, "f14" },
1118 { { "fr15" }, "f15" },
1119 { { "fr16" }, "f16" },
1120 { { "fr17" }, "f17" },
1121 { { "fr18" }, "f18" },
1122 { { "fr19" }, "f19" },
1123 { { "fr20" }, "f20" },
1124 { { "fr21" }, "f21" },
1125 { { "fr22" }, "f22" },
1126 { { "fr23" }, "f23" },
1127 { { "fr24" }, "f24" },
1128 { { "fr25" }, "f25" },
1129 { { "fr26" }, "f26" },
1130 { { "fr27" }, "f27" },
1131 { { "fr28" }, "f28" },
1132 { { "fr29" }, "f29" },
1133 { { "fr30" }, "f30" },
1134 { { "fr31" }, "f31" },
1135 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001136};
1137
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001138void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001139 unsigned &NumAliases) const {
1140 Aliases = GCCRegAliases;
1141 NumAliases = llvm::array_lengthof(GCCRegAliases);
1142}
1143} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001144
1145namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001146class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001147public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001148 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001149 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 +00001150 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001151
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001152 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001153 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001154 case llvm::Triple::FreeBSD:
1155 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001156 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001157 PtrDiffType = SignedInt;
1158 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001159 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001160 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001161 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001162 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001163
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001164 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1165 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001166 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001167 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001168
1169 // PPC32 supports atomics up to 4 bytes.
1170 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001171 }
1172
Meador Ingec5613b22012-06-16 03:34:49 +00001173 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001174 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001175 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001176 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001177};
1178} // end anonymous namespace.
1179
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001180// Note: ABI differences may eventually require us to have a separate
1181// TargetInfo for little endian.
Reid Spencer5f016e22007-07-11 17:01:13 +00001182namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001183class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001184public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001185 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001186 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001187 IntMaxType = SignedLong;
1188 UIntMaxType = UnsignedLong;
1189 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001190
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001191 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1192 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001193 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001194 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
Bill Schmidtb1baad62013-07-03 21:03:06 +00001195 "i64:64:64-f32:32:32-f64:64:64-"
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001196 "v128:128:128-n32:64";
1197 } else
1198 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1199 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1200 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001201
1202 // PPC64 supports atomics up to 8 bytes.
1203 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001204 }
Meador Ingec5613b22012-06-16 03:34:49 +00001205 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1206 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001207 }
Eli Friedmane4277982008-08-20 23:11:40 +00001208};
1209} // end anonymous namespace.
1210
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001211
1212namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001213class DarwinPPC32TargetInfo :
1214 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001215public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001216 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1217 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001218 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001219 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
David Fangb5afadd2013-05-16 17:51:48 +00001220 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001221 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001222 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001223 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1224 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001225 }
Meador Ingec5613b22012-06-16 03:34:49 +00001226 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1227 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001228 }
1229};
1230
1231class DarwinPPC64TargetInfo :
1232 public DarwinTargetInfo<PPC64TargetInfo> {
1233public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001234 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1235 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001236 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001237 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001238 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1239 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001240 }
1241};
1242} // end anonymous namespace.
1243
Reid Spencer5f016e22007-07-11 17:01:13 +00001244namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001245 static const unsigned NVPTXAddrSpaceMap[] = {
1246 1, // opencl_global
1247 3, // opencl_local
1248 4, // opencl_constant
1249 1, // cuda_device
1250 4, // cuda_constant
1251 3, // cuda_shared
1252 };
1253 class NVPTXTargetInfo : public TargetInfo {
1254 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001255 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001256 std::vector<StringRef> AvailableFeatures;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001257 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001258 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 BigEndian = false;
1260 TLSSupported = false;
1261 LongWidth = LongAlign = 64;
1262 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001263 // Define available target features
1264 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001265 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001266 }
1267 virtual void getTargetDefines(const LangOptions &Opts,
1268 MacroBuilder &Builder) const {
1269 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001270 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001271 }
1272 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1273 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001274 Records = BuiltinInfo;
1275 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001276 }
1277 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001278 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001279 }
1280
1281 virtual void getGCCRegNames(const char * const *&Names,
1282 unsigned &NumNames) const;
1283 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1284 unsigned &NumAliases) const {
1285 // No aliases.
1286 Aliases = 0;
1287 NumAliases = 0;
1288 }
1289 virtual bool validateAsmConstraint(const char *&Name,
Justin Holewinski0ac428e2013-06-21 18:51:24 +00001290 TargetInfo::ConstraintInfo &Info) const {
1291 switch (*Name) {
1292 default: return false;
1293 case 'c':
1294 case 'h':
1295 case 'r':
1296 case 'l':
1297 case 'f':
1298 case 'd':
1299 Info.setAllowsRegister();
1300 return true;
1301 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001302 }
1303 virtual const char *getClobbers() const {
1304 // FIXME: Is this really right?
1305 return "";
1306 }
Meador Ingec5613b22012-06-16 03:34:49 +00001307 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001308 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001309 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001310 }
1311 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001312 bool Valid = llvm::StringSwitch<bool>(Name)
1313 .Case("sm_20", true)
1314 .Case("sm_21", true)
1315 .Case("sm_30", true)
1316 .Case("sm_35", true)
1317 .Default(false);
1318
1319 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001320 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001321 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
1322 StringRef Name,
1323 bool Enabled) const;
1324 };
1325
1326 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1327#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1328#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1329 ALL_LANGUAGES },
1330#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001331 };
1332
1333 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1334 "r0"
1335 };
1336
1337 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1338 unsigned &NumNames) const {
1339 Names = GCCRegNames;
1340 NumNames = llvm::array_lengthof(GCCRegNames);
1341 }
1342
Justin Holewinski2c585b92012-05-24 17:43:12 +00001343 bool NVPTXTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1344 StringRef Name,
1345 bool Enabled) const {
1346 if(std::binary_search(AvailableFeatures.begin(), AvailableFeatures.end(),
1347 Name)) {
1348 Features[Name] = Enabled;
1349 return true;
1350 } else {
1351 return false;
1352 }
1353 }
1354
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001355 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1356 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001357 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001358 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001359 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001360 DescriptionString
1361 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1362 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1363 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001364 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001365 };
1366
1367 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1368 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001369 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001370 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001371 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001372 DescriptionString
1373 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1374 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1375 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001376 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001377 };
1378}
1379
1380namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001381
1382static const unsigned R600AddrSpaceMap[] = {
1383 1, // opencl_global
1384 3, // opencl_local
1385 2, // opencl_constant
1386 1, // cuda_device
1387 2, // cuda_constant
1388 3 // cuda_shared
1389};
1390
Tom Stellardfd075912013-03-04 17:40:53 +00001391static const char *DescriptionStringR600 =
1392 "e"
1393 "-p:32:32:32"
1394 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1395 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1396 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1397 "-n32:64";
1398
1399static const char *DescriptionStringR600DoubleOps =
1400 "e"
1401 "-p:32:32:32"
1402 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1403 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1404 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1405 "-n32:64";
1406
1407static const char *DescriptionStringSI =
1408 "e"
1409 "-p:64:64:64"
1410 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1411 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1412 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1413 "-n32:64";
1414
Eli Friedman6505a292012-10-12 23:32:00 +00001415class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001416 /// \brief The GPU profiles supported by the R600 target.
1417 enum GPUKind {
1418 GK_NONE,
1419 GK_R600,
1420 GK_R600_DOUBLE_OPS,
1421 GK_R700,
1422 GK_R700_DOUBLE_OPS,
1423 GK_EVERGREEN,
1424 GK_EVERGREEN_DOUBLE_OPS,
1425 GK_NORTHERN_ISLANDS,
1426 GK_CAYMAN,
1427 GK_SOUTHERN_ISLANDS
1428 } GPU;
1429
Eli Friedman6505a292012-10-12 23:32:00 +00001430public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001431 R600TargetInfo(const llvm::Triple &Triple)
1432 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardfd075912013-03-04 17:40:53 +00001433 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001434 AddrSpaceMap = &R600AddrSpaceMap;
1435 }
1436
1437 virtual const char * getClobbers() const {
1438 return "";
1439 }
1440
1441 virtual void getGCCRegNames(const char * const *&Names,
1442 unsigned &numNames) const {
1443 Names = NULL;
1444 numNames = 0;
1445 }
1446
1447 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1448 unsigned &NumAliases) const {
1449 Aliases = NULL;
1450 NumAliases = 0;
1451 }
1452
1453 virtual bool validateAsmConstraint(const char *&Name,
1454 TargetInfo::ConstraintInfo &info) const {
1455 return true;
1456 }
1457
1458 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1459 unsigned &NumRecords) const {
1460 Records = NULL;
1461 NumRecords = 0;
1462 }
1463
1464
1465 virtual void getTargetDefines(const LangOptions &Opts,
1466 MacroBuilder &Builder) const {
1467 Builder.defineMacro("__R600__");
1468 }
1469
1470 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1471 return TargetInfo::CharPtrBuiltinVaList;
1472 }
1473
Tom Stellardfd075912013-03-04 17:40:53 +00001474 virtual bool setCPU(const std::string &Name) {
1475 GPU = llvm::StringSwitch<GPUKind>(Name)
1476 .Case("r600" , GK_R600)
1477 .Case("rv610", GK_R600)
1478 .Case("rv620", GK_R600)
1479 .Case("rv630", GK_R600)
1480 .Case("rv635", GK_R600)
1481 .Case("rs780", GK_R600)
1482 .Case("rs880", GK_R600)
1483 .Case("rv670", GK_R600_DOUBLE_OPS)
1484 .Case("rv710", GK_R700)
1485 .Case("rv730", GK_R700)
1486 .Case("rv740", GK_R700_DOUBLE_OPS)
1487 .Case("rv770", GK_R700_DOUBLE_OPS)
1488 .Case("palm", GK_EVERGREEN)
1489 .Case("cedar", GK_EVERGREEN)
1490 .Case("sumo", GK_EVERGREEN)
1491 .Case("sumo2", GK_EVERGREEN)
1492 .Case("redwood", GK_EVERGREEN)
1493 .Case("juniper", GK_EVERGREEN)
1494 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1495 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1496 .Case("barts", GK_NORTHERN_ISLANDS)
1497 .Case("turks", GK_NORTHERN_ISLANDS)
1498 .Case("caicos", GK_NORTHERN_ISLANDS)
1499 .Case("cayman", GK_CAYMAN)
1500 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001501 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001502 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1503 .Case("verde", GK_SOUTHERN_ISLANDS)
1504 .Case("oland", GK_SOUTHERN_ISLANDS)
1505 .Default(GK_NONE);
1506
1507 if (GPU == GK_NONE) {
1508 return false;
1509 }
1510
1511 // Set the correct data layout
1512 switch (GPU) {
1513 case GK_NONE:
1514 case GK_R600:
1515 case GK_R700:
1516 case GK_EVERGREEN:
1517 case GK_NORTHERN_ISLANDS:
1518 DescriptionString = DescriptionStringR600;
1519 break;
1520 case GK_R600_DOUBLE_OPS:
1521 case GK_R700_DOUBLE_OPS:
1522 case GK_EVERGREEN_DOUBLE_OPS:
1523 case GK_CAYMAN:
1524 DescriptionString = DescriptionStringR600DoubleOps;
1525 break;
1526 case GK_SOUTHERN_ISLANDS:
1527 DescriptionString = DescriptionStringSI;
1528 break;
1529 }
1530
1531 return true;
1532 }
Eli Friedman6505a292012-10-12 23:32:00 +00001533};
1534
1535} // end anonymous namespace
1536
1537namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001538// Namespace for x86 abstract base class
1539const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001540#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001541#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001542 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001543#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001544};
Eli Friedman61538a72008-05-20 14:21:01 +00001545
Nuno Lopes2550d702009-12-23 17:49:57 +00001546static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001547 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1548 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001549 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001550 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1551 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1552 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001553 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001554 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1555 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001556};
1557
Eric Christophercfd323d2011-06-21 00:05:20 +00001558const TargetInfo::AddlRegName AddlRegNames[] = {
1559 { { "al", "ah", "eax", "rax" }, 0 },
1560 { { "bl", "bh", "ebx", "rbx" }, 3 },
1561 { { "cl", "ch", "ecx", "rcx" }, 2 },
1562 { { "dl", "dh", "edx", "rdx" }, 1 },
1563 { { "esi", "rsi" }, 4 },
1564 { { "edi", "rdi" }, 5 },
1565 { { "esp", "rsp" }, 7 },
1566 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001567};
1568
1569// X86 target abstract base class; x86-32 and x86-64 are very close, so
1570// most of the implementation can be shared.
1571class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001572 enum X86SSEEnum {
Craig Toppered218d02013-08-20 07:07:29 +00001573 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2
Chris Lattner84f0ea82009-03-02 22:40:39 +00001574 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001575 enum MMX3DNowEnum {
1576 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1577 } MMX3DNowLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001578
Eric Christophereea12d12010-04-02 23:50:19 +00001579 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001580 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001581 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001582 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001583 bool HasBMI;
1584 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001585 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001586 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001587 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001588 bool HasRDSEED;
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00001589 bool HasSSE4a;
Craig Topper6a511e12011-12-30 07:33:42 +00001590 bool HasFMA4;
Craig Topper2ae95072012-06-03 21:46:30 +00001591 bool HasFMA;
Craig Topperb6af69e2012-06-09 22:24:14 +00001592 bool HasXOP;
Manman Ren146e5a42012-10-11 00:59:55 +00001593 bool HasF16C;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001594
Chandler Carruth499d9722011-09-28 08:55:34 +00001595 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1596 ///
1597 /// Each enumeration represents a particular CPU supported by Clang. These
1598 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1599 enum CPUKind {
1600 CK_Generic,
1601
1602 /// \name i386
1603 /// i386-generation processors.
1604 //@{
1605 CK_i386,
1606 //@}
1607
1608 /// \name i486
1609 /// i486-generation processors.
1610 //@{
1611 CK_i486,
1612 CK_WinChipC6,
1613 CK_WinChip2,
1614 CK_C3,
1615 //@}
1616
1617 /// \name i586
1618 /// i586-generation processors, P5 microarchitecture based.
1619 //@{
1620 CK_i586,
1621 CK_Pentium,
1622 CK_PentiumMMX,
1623 //@}
1624
1625 /// \name i686
1626 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1627 //@{
1628 CK_i686,
1629 CK_PentiumPro,
1630 CK_Pentium2,
1631 CK_Pentium3,
1632 CK_Pentium3M,
1633 CK_PentiumM,
1634 CK_C3_2,
1635
1636 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1637 /// Clang however has some logic to suport this.
1638 // FIXME: Warn, deprecate, and potentially remove this.
1639 CK_Yonah,
1640 //@}
1641
1642 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001643 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001644 //@{
1645 CK_Pentium4,
1646 CK_Pentium4M,
1647 CK_Prescott,
1648 CK_Nocona,
1649 //@}
1650
1651 /// \name Core
1652 /// Core microarchitecture based processors.
1653 //@{
1654 CK_Core2,
1655
1656 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1657 /// codename which GCC no longer accepts as an option to -march, but Clang
1658 /// has some logic for recognizing it.
1659 // FIXME: Warn, deprecate, and potentially remove this.
1660 CK_Penryn,
1661 //@}
1662
1663 /// \name Atom
1664 /// Atom processors
1665 //@{
1666 CK_Atom,
1667 //@}
1668
1669 /// \name Nehalem
1670 /// Nehalem microarchitecture based processors.
1671 //@{
1672 CK_Corei7,
1673 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001674 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001675 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001676 //@}
1677
1678 /// \name K6
1679 /// K6 architecture processors.
1680 //@{
1681 CK_K6,
1682 CK_K6_2,
1683 CK_K6_3,
1684 //@}
1685
1686 /// \name K7
1687 /// K7 architecture processors.
1688 //@{
1689 CK_Athlon,
1690 CK_AthlonThunderbird,
1691 CK_Athlon4,
1692 CK_AthlonXP,
1693 CK_AthlonMP,
1694 //@}
1695
1696 /// \name K8
1697 /// K8 architecture processors.
1698 //@{
1699 CK_Athlon64,
1700 CK_Athlon64SSE3,
1701 CK_AthlonFX,
1702 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001703 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001704 CK_Opteron,
1705 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001706 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001707 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001708
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001709 /// \name Bobcat
1710 /// Bobcat architecture processors.
1711 //@{
1712 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001713 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001714 //@}
1715
1716 /// \name Bulldozer
1717 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001718 //@{
1719 CK_BDVER1,
1720 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001721 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001722
Chandler Carruth499d9722011-09-28 08:55:34 +00001723 /// This specification is deprecated and will be removed in the future.
1724 /// Users should prefer \see CK_K8.
1725 // FIXME: Warn on this when the CPU is set to it.
1726 CK_x86_64,
1727 //@}
1728
1729 /// \name Geode
1730 /// Geode processors.
1731 //@{
1732 CK_Geode
1733 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001734 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001735
Eli Friedman618234a2008-08-20 02:34:37 +00001736public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001737 X86TargetInfo(const llvm::Triple &Triple)
1738 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
1739 HasAES(false), HasPCLMUL(false), HasLZCNT(false), HasRDRND(false),
1740 HasBMI(false), HasBMI2(false), HasPOPCNT(false), HasRTM(false),
1741 HasPRFCHW(false), HasRDSEED(false), HasSSE4a(false), HasFMA4(false),
1742 HasFMA(false), HasXOP(false), HasF16C(false), CPU(CK_Generic) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001743 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001744 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001745 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001746 virtual unsigned getFloatEvalMethod() const {
1747 // X87 evaluates with 80 bits "long double" precision.
1748 return SSELevel == NoSSE ? 2 : 0;
1749 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001750 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1751 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001752 Records = BuiltinInfo;
1753 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001754 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001755 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001756 unsigned &NumNames) const {
1757 Names = GCCRegNames;
1758 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001759 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001760 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001761 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001762 Aliases = 0;
1763 NumAliases = 0;
1764 }
1765 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001766 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001767 Names = AddlRegNames;
1768 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001769 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001770 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001771 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001772 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001773 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001774 return "~{dirflag},~{fpsr},~{flags}";
1775 }
Chris Lattner33328642009-03-20 15:52:06 +00001776 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001777 MacroBuilder &Builder) const;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001778 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001779 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001780 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001781 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001782 virtual bool hasFeature(StringRef Feature) const;
Daniel Dunbarb93292a2009-12-19 03:30:57 +00001783 virtual void HandleTargetFeatures(std::vector<std::string> &Features);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001784 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001785 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001786 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001787 else if (getTriple().getArch() == llvm::Triple::x86 &&
1788 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001789 return "no-mmx";
1790 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001791 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001792 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001793 CPU = llvm::StringSwitch<CPUKind>(Name)
1794 .Case("i386", CK_i386)
1795 .Case("i486", CK_i486)
1796 .Case("winchip-c6", CK_WinChipC6)
1797 .Case("winchip2", CK_WinChip2)
1798 .Case("c3", CK_C3)
1799 .Case("i586", CK_i586)
1800 .Case("pentium", CK_Pentium)
1801 .Case("pentium-mmx", CK_PentiumMMX)
1802 .Case("i686", CK_i686)
1803 .Case("pentiumpro", CK_PentiumPro)
1804 .Case("pentium2", CK_Pentium2)
1805 .Case("pentium3", CK_Pentium3)
1806 .Case("pentium3m", CK_Pentium3M)
1807 .Case("pentium-m", CK_PentiumM)
1808 .Case("c3-2", CK_C3_2)
1809 .Case("yonah", CK_Yonah)
1810 .Case("pentium4", CK_Pentium4)
1811 .Case("pentium4m", CK_Pentium4M)
1812 .Case("prescott", CK_Prescott)
1813 .Case("nocona", CK_Nocona)
1814 .Case("core2", CK_Core2)
1815 .Case("penryn", CK_Penryn)
1816 .Case("atom", CK_Atom)
1817 .Case("corei7", CK_Corei7)
1818 .Case("corei7-avx", CK_Corei7AVX)
1819 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001820 .Case("core-avx2", CK_CoreAVX2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001821 .Case("k6", CK_K6)
1822 .Case("k6-2", CK_K6_2)
1823 .Case("k6-3", CK_K6_3)
1824 .Case("athlon", CK_Athlon)
1825 .Case("athlon-tbird", CK_AthlonThunderbird)
1826 .Case("athlon-4", CK_Athlon4)
1827 .Case("athlon-xp", CK_AthlonXP)
1828 .Case("athlon-mp", CK_AthlonMP)
1829 .Case("athlon64", CK_Athlon64)
1830 .Case("athlon64-sse3", CK_Athlon64SSE3)
1831 .Case("athlon-fx", CK_AthlonFX)
1832 .Case("k8", CK_K8)
1833 .Case("k8-sse3", CK_K8SSE3)
1834 .Case("opteron", CK_Opteron)
1835 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001836 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001837 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001838 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001839 .Case("bdver1", CK_BDVER1)
1840 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001841 .Case("x86-64", CK_x86_64)
1842 .Case("geode", CK_Geode)
1843 .Default(CK_Generic);
1844
Chandler Carruth26a39142011-09-28 09:45:08 +00001845 // Perform any per-CPU checks necessary to determine if this CPU is
1846 // acceptable.
1847 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1848 // invalid without explaining *why*.
1849 switch (CPU) {
1850 case CK_Generic:
1851 // No processor selected!
1852 return false;
1853
1854 case CK_i386:
1855 case CK_i486:
1856 case CK_WinChipC6:
1857 case CK_WinChip2:
1858 case CK_C3:
1859 case CK_i586:
1860 case CK_Pentium:
1861 case CK_PentiumMMX:
1862 case CK_i686:
1863 case CK_PentiumPro:
1864 case CK_Pentium2:
1865 case CK_Pentium3:
1866 case CK_Pentium3M:
1867 case CK_PentiumM:
1868 case CK_Yonah:
1869 case CK_C3_2:
1870 case CK_Pentium4:
1871 case CK_Pentium4M:
1872 case CK_Prescott:
1873 case CK_K6:
1874 case CK_K6_2:
1875 case CK_K6_3:
1876 case CK_Athlon:
1877 case CK_AthlonThunderbird:
1878 case CK_Athlon4:
1879 case CK_AthlonXP:
1880 case CK_AthlonMP:
1881 case CK_Geode:
1882 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001883 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001884 return false;
1885
1886 // Fallthrough
1887 case CK_Nocona:
1888 case CK_Core2:
1889 case CK_Penryn:
1890 case CK_Atom:
1891 case CK_Corei7:
1892 case CK_Corei7AVX:
1893 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001894 case CK_CoreAVX2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001895 case CK_Athlon64:
1896 case CK_Athlon64SSE3:
1897 case CK_AthlonFX:
1898 case CK_K8:
1899 case CK_K8SSE3:
1900 case CK_Opteron:
1901 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001902 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001903 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00001904 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001905 case CK_BDVER1:
1906 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001907 case CK_x86_64:
1908 return true;
1909 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001910 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001911 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001912
1913 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1914 // We accept all non-ARM calling conventions
1915 return (CC == CC_X86ThisCall ||
1916 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00001917 CC == CC_X86StdCall ||
1918 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001919 CC == CC_X86Pascal ||
1920 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001921 }
1922
Aaron Ballmanfff32482012-12-09 17:45:41 +00001923 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1924 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001925 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001926};
Chris Lattner3daed522009-03-02 22:20:04 +00001927
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001928void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001929 // FIXME: This should not be here.
1930 Features["3dnow"] = false;
1931 Features["3dnowa"] = false;
1932 Features["mmx"] = false;
1933 Features["sse"] = false;
1934 Features["sse2"] = false;
1935 Features["sse3"] = false;
1936 Features["ssse3"] = false;
1937 Features["sse41"] = false;
1938 Features["sse42"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00001939 Features["sse4a"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00001940 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00001941 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001942 Features["avx"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00001943 Features["avx2"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001944 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001945 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00001946 Features["bmi"] = false;
1947 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00001948 Features["popcnt"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00001949 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00001950 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001951 Features["rdseed"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00001952 Features["fma4"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00001953 Features["fma"] = false;
Craig Topperb6af69e2012-06-09 22:24:14 +00001954 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00001955 Features["f16c"] = false;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001956
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001957 // FIXME: This *really* should not be here.
1958
1959 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001960 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001961 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001962
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001963 switch (CPU) {
1964 case CK_Generic:
1965 case CK_i386:
1966 case CK_i486:
1967 case CK_i586:
1968 case CK_Pentium:
1969 case CK_i686:
1970 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001971 break;
1972 case CK_PentiumMMX:
1973 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001974 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001975 break;
1976 case CK_Pentium3:
1977 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001978 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001979 break;
1980 case CK_PentiumM:
1981 case CK_Pentium4:
1982 case CK_Pentium4M:
1983 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001984 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001985 break;
1986 case CK_Yonah:
1987 case CK_Prescott:
1988 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001989 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001990 break;
1991 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001992 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001993 break;
1994 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001995 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001996 break;
1997 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00001998 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001999 break;
2000 case CK_Corei7:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002001 setFeatureEnabled(Features, "sse4", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002002 break;
2003 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00002004 setFeatureEnabled(Features, "avx", true);
2005 setFeatureEnabled(Features, "aes", true);
2006 setFeatureEnabled(Features, "pclmul", true);
2007 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002008 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00002009 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00002010 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002011 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002012 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002013 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002014 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00002015 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00002016 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002017 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002018 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002019 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00002020 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002021 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002022 setFeatureEnabled(Features, "bmi", true);
2023 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002024 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002025 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002026 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002027 case CK_K6:
2028 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002029 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002030 break;
2031 case CK_K6_2:
2032 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002033 case CK_WinChip2:
2034 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002035 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002036 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002037 case CK_Athlon:
2038 case CK_AthlonThunderbird:
2039 case CK_Geode:
2040 setFeatureEnabled(Features, "3dnowa", true);
2041 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002042 case CK_Athlon4:
2043 case CK_AthlonXP:
2044 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002045 setFeatureEnabled(Features, "sse", true);
2046 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002047 break;
2048 case CK_K8:
2049 case CK_Opteron:
2050 case CK_Athlon64:
2051 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002052 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002053 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002054 break;
2055 case CK_K8SSE3:
2056 case CK_OpteronSSE3:
2057 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002058 setFeatureEnabled(Features, "sse3", true);
2059 setFeatureEnabled(Features, "3dnowa", true);
2060 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002061 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002062 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002063 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002064 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002065 setFeatureEnabled(Features, "lzcnt", true);
2066 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002067 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002068 case CK_BTVER1:
2069 setFeatureEnabled(Features, "ssse3", true);
2070 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002071 setFeatureEnabled(Features, "lzcnt", true);
2072 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002073 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002074 case CK_BTVER2:
2075 setFeatureEnabled(Features, "avx", true);
2076 setFeatureEnabled(Features, "sse4a", true);
2077 setFeatureEnabled(Features, "lzcnt", true);
2078 setFeatureEnabled(Features, "aes", true);
2079 setFeatureEnabled(Features, "pclmul", true);
2080 setFeatureEnabled(Features, "bmi", true);
2081 setFeatureEnabled(Features, "f16c", true);
2082 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002083 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002084 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002085 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002086 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002087 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002088 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002089 case CK_BDVER2:
2090 setFeatureEnabled(Features, "xop", true);
2091 setFeatureEnabled(Features, "lzcnt", true);
2092 setFeatureEnabled(Features, "aes", true);
2093 setFeatureEnabled(Features, "pclmul", true);
2094 setFeatureEnabled(Features, "bmi", true);
2095 setFeatureEnabled(Features, "fma", true);
2096 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002097 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002098 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002099 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002100 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002101 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002102}
2103
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002104bool X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002105 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002106 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002107 // FIXME: This *really* should not be here. We need some way of translating
2108 // options into llvm subtarget features.
2109 if (!Features.count(Name) &&
Benjamin Kramer84f30802012-07-07 09:39:18 +00002110 (Name != "sse4" && Name != "sse4.2" && Name != "sse4.1" &&
2111 Name != "rdrnd"))
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002112 return false;
2113
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002114 // FIXME: this should probably use a switch with fall through.
2115
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002116 if (Enabled) {
2117 if (Name == "mmx")
2118 Features["mmx"] = true;
2119 else if (Name == "sse")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002120 Features["mmx"] = Features["sse"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002121 else if (Name == "sse2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002122 Features["mmx"] = Features["sse"] = Features["sse2"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002123 else if (Name == "sse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002124 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2125 true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002126 else if (Name == "ssse3")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002127 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002128 Features["ssse3"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002129 else if (Name == "sse4" || Name == "sse4.2")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002130 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002131 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2132 Features["popcnt"] = true;
Eric Christopherd39ebe22010-03-04 02:26:37 +00002133 else if (Name == "sse4.1")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002134 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Eric Christopherd39ebe22010-03-04 02:26:37 +00002135 Features["ssse3"] = Features["sse41"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002136 else if (Name == "3dnow")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002137 Features["mmx"] = Features["3dnow"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002138 else if (Name == "3dnowa")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002139 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = true;
Eric Christophereea12d12010-04-02 23:50:19 +00002140 else if (Name == "aes")
Craig Toppera7463c32012-06-03 21:56:22 +00002141 Features["sse"] = Features["sse2"] = Features["aes"] = true;
Craig Topper3c0bc152012-05-31 05:18:48 +00002142 else if (Name == "pclmul")
Craig Toppera7463c32012-06-03 21:56:22 +00002143 Features["sse"] = Features["sse2"] = Features["pclmul"] = true;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002144 else if (Name == "avx")
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002145 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2146 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002147 Features["popcnt"] = Features["avx"] = true;
Craig Topper2b03bb02011-12-17 19:55:21 +00002148 else if (Name == "avx2")
2149 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2150 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppere14e08b2011-12-29 16:10:46 +00002151 Features["popcnt"] = Features["avx"] = Features["avx2"] = true;
Craig Topper2ae95072012-06-03 21:46:30 +00002152 else if (Name == "fma")
2153 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
2154 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2155 Features["popcnt"] = Features["avx"] = Features["fma"] = true;
Craig Topper6a511e12011-12-30 07:33:42 +00002156 else if (Name == "fma4")
Eli Friedman612db2a2012-11-17 01:16:19 +00002157 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002158 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002159 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2160 Features["fma4"] = true;
Craig Topperb6af69e2012-06-09 22:24:14 +00002161 else if (Name == "xop")
Eli Friedman612db2a2012-11-17 01:16:19 +00002162 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topperb6af69e2012-06-09 22:24:14 +00002163 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
2164 Features["popcnt"] = Features["avx"] = Features["sse4a"] =
2165 Features["fma4"] = Features["xop"] = true;
Roman Divacky80b32b82011-10-30 13:47:56 +00002166 else if (Name == "sse4a")
Craig Topper6a511e12011-12-30 07:33:42 +00002167 Features["mmx"] = Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper90ea0362012-05-30 05:54:54 +00002168 Features["sse4a"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002169 else if (Name == "lzcnt")
2170 Features["lzcnt"] = true;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002171 else if (Name == "rdrnd")
2172 Features["rdrand"] = true;
Craig Topper31ceea02011-12-25 05:06:45 +00002173 else if (Name == "bmi")
2174 Features["bmi"] = true;
2175 else if (Name == "bmi2")
2176 Features["bmi2"] = true;
Craig Toppere14e08b2011-12-29 16:10:46 +00002177 else if (Name == "popcnt")
2178 Features["popcnt"] = true;
Manman Ren146e5a42012-10-11 00:59:55 +00002179 else if (Name == "f16c")
2180 Features["f16c"] = true;
Michael Liao463eb892012-11-10 05:17:46 +00002181 else if (Name == "rtm")
2182 Features["rtm"] = true;
Michael Liao72339a02013-03-26 17:52:08 +00002183 else if (Name == "prfchw")
2184 Features["prfchw"] = true;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002185 else if (Name == "rdseed")
2186 Features["rdseed"] = true;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002187 } else {
2188 if (Name == "mmx")
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002189 Features["mmx"] = Features["3dnow"] = Features["3dnowa"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002190 else if (Name == "sse")
Mike Stump1eb44332009-09-09 15:08:12 +00002191 Features["sse"] = Features["sse2"] = Features["sse3"] =
Craig Topper6a511e12011-12-30 07:33:42 +00002192 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002193 Features["sse4a"] = Features["avx"] = Features["avx2"] =
Craig Toppered218d02013-08-20 07:07:29 +00002194 Features["fma"] = Features["fma4"] = Features["aes"] =
2195 Features["pclmul"] = Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002196 else if (Name == "sse2")
Mike Stump1eb44332009-09-09 15:08:12 +00002197 Features["sse2"] = Features["sse3"] = Features["ssse3"] =
Craig Toppera7463c32012-06-03 21:56:22 +00002198 Features["sse41"] = Features["sse42"] = Features["sse4a"] =
Craig Toppered218d02013-08-20 07:07:29 +00002199 Features["avx"] = Features["avx2"] = Features["fma"] =
2200 Features["fma4"] = Features["aes"] = Features["pclmul"] =
2201 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002202 else if (Name == "sse3")
Mike Stump1eb44332009-09-09 15:08:12 +00002203 Features["sse3"] = Features["ssse3"] = Features["sse41"] =
Craig Topper31380fb2012-06-03 22:23:42 +00002204 Features["sse42"] = Features["sse4a"] = Features["avx"] =
Craig Toppered218d02013-08-20 07:07:29 +00002205 Features["avx2"] = Features["fma"] = Features["fma4"] =
2206 Features["xop"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002207 else if (Name == "ssse3")
Craig Topper31380fb2012-06-03 22:23:42 +00002208 Features["ssse3"] = Features["sse41"] = Features["sse42"] =
Craig Toppered218d02013-08-20 07:07:29 +00002209 Features["avx"] = Features["avx2"] = Features["fma"] = false;
Michael J. Spencerb24bac92011-04-17 19:22:03 +00002210 else if (Name == "sse4" || Name == "sse4.1")
Craig Topper31380fb2012-06-03 22:23:42 +00002211 Features["sse41"] = Features["sse42"] = Features["avx"] =
Craig Toppered218d02013-08-20 07:07:29 +00002212 Features["avx2"] = Features["fma"] = false;
Eric Christopherd41b4ec2010-03-04 02:31:44 +00002213 else if (Name == "sse4.2")
Craig Topper31380fb2012-06-03 22:23:42 +00002214 Features["sse42"] = Features["avx"] = Features["avx2"] =
Craig Toppered218d02013-08-20 07:07:29 +00002215 Features["fma"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002216 else if (Name == "3dnow")
2217 Features["3dnow"] = Features["3dnowa"] = false;
2218 else if (Name == "3dnowa")
2219 Features["3dnowa"] = false;
Eric Christophereea12d12010-04-02 23:50:19 +00002220 else if (Name == "aes")
2221 Features["aes"] = false;
Craig Topper3c0bc152012-05-31 05:18:48 +00002222 else if (Name == "pclmul")
2223 Features["pclmul"] = false;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00002224 else if (Name == "avx")
Craig Toppered218d02013-08-20 07:07:29 +00002225 Features["avx"] = Features["avx2"] = Features["fma"] =
2226 Features["fma4"] = Features["xop"] = false;
Craig Topper2b03bb02011-12-17 19:55:21 +00002227 else if (Name == "avx2")
Craig Toppered218d02013-08-20 07:07:29 +00002228 Features["avx2"] = false;
Craig Topper2ae95072012-06-03 21:46:30 +00002229 else if (Name == "fma")
2230 Features["fma"] = false;
Roman Divacky80b32b82011-10-30 13:47:56 +00002231 else if (Name == "sse4a")
Craig Topperb6af69e2012-06-09 22:24:14 +00002232 Features["sse4a"] = Features["fma4"] = Features["xop"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002233 else if (Name == "lzcnt")
2234 Features["lzcnt"] = false;
Benjamin Kramer84f30802012-07-07 09:39:18 +00002235 else if (Name == "rdrnd")
2236 Features["rdrand"] = false;
Craig Topper31ceea02011-12-25 05:06:45 +00002237 else if (Name == "bmi")
2238 Features["bmi"] = false;
2239 else if (Name == "bmi2")
2240 Features["bmi2"] = false;
Craig Toppere14e08b2011-12-29 16:10:46 +00002241 else if (Name == "popcnt")
2242 Features["popcnt"] = false;
Craig Topper6a511e12011-12-30 07:33:42 +00002243 else if (Name == "fma4")
Craig Topperb6af69e2012-06-09 22:24:14 +00002244 Features["fma4"] = Features["xop"] = false;
2245 else if (Name == "xop")
2246 Features["xop"] = false;
Manman Ren146e5a42012-10-11 00:59:55 +00002247 else if (Name == "f16c")
2248 Features["f16c"] = false;
Michael Liao463eb892012-11-10 05:17:46 +00002249 else if (Name == "rtm")
2250 Features["rtm"] = false;
Michael Liao72339a02013-03-26 17:52:08 +00002251 else if (Name == "prfchw")
2252 Features["prfchw"] = false;
Michael Liao1bfc28c2013-03-29 05:17:55 +00002253 else if (Name == "rdseed")
2254 Features["rdseed"] = false;
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002255 }
2256
2257 return true;
2258}
2259
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002260/// HandleTargetOptions - Perform initialization based on the user
2261/// configured set of features.
Daniel Dunbarb93292a2009-12-19 03:30:57 +00002262void X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002263 // Remember the maximum enabled sselevel.
2264 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2265 // Ignore disabled features.
2266 if (Features[i][0] == '-')
2267 continue;
2268
Benjamin Kramer713575a2012-03-05 15:10:44 +00002269 StringRef Feature = StringRef(Features[i]).substr(1);
2270
2271 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002272 HasAES = true;
2273 continue;
2274 }
2275
Craig Topper3c0bc152012-05-31 05:18:48 +00002276 if (Feature == "pclmul") {
2277 HasPCLMUL = true;
2278 continue;
2279 }
2280
Benjamin Kramer713575a2012-03-05 15:10:44 +00002281 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002282 HasLZCNT = true;
2283 continue;
2284 }
2285
Benjamin Kramer84f30802012-07-07 09:39:18 +00002286 if (Feature == "rdrand") {
2287 HasRDRND = true;
2288 continue;
2289 }
2290
Benjamin Kramer713575a2012-03-05 15:10:44 +00002291 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002292 HasBMI = true;
2293 continue;
2294 }
2295
Benjamin Kramer713575a2012-03-05 15:10:44 +00002296 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002297 HasBMI2 = true;
2298 continue;
2299 }
2300
Benjamin Kramer713575a2012-03-05 15:10:44 +00002301 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002302 HasPOPCNT = true;
2303 continue;
2304 }
2305
Michael Liao463eb892012-11-10 05:17:46 +00002306 if (Feature == "rtm") {
2307 HasRTM = true;
2308 continue;
2309 }
2310
Michael Liao72339a02013-03-26 17:52:08 +00002311 if (Feature == "prfchw") {
2312 HasPRFCHW = true;
2313 continue;
2314 }
2315
Michael Liao1bfc28c2013-03-29 05:17:55 +00002316 if (Feature == "rdseed") {
2317 HasRDSEED = true;
2318 continue;
2319 }
2320
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002321 if (Feature == "sse4a") {
2322 HasSSE4a = true;
2323 continue;
2324 }
2325
Benjamin Kramer713575a2012-03-05 15:10:44 +00002326 if (Feature == "fma4") {
Craig Topper6a511e12011-12-30 07:33:42 +00002327 HasFMA4 = true;
2328 continue;
2329 }
2330
Craig Topper2ae95072012-06-03 21:46:30 +00002331 if (Feature == "fma") {
2332 HasFMA = true;
2333 continue;
2334 }
2335
Craig Topperb6af69e2012-06-09 22:24:14 +00002336 if (Feature == "xop") {
2337 HasXOP = true;
2338 continue;
2339 }
2340
Manman Ren146e5a42012-10-11 00:59:55 +00002341 if (Feature == "f16c") {
2342 HasF16C = true;
2343 continue;
2344 }
2345
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002346 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002347 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper05fe4b52012-01-09 09:19:09 +00002348 .Case("avx2", AVX2)
2349 .Case("avx", AVX)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002350 .Case("sse42", SSE42)
2351 .Case("sse41", SSE41)
2352 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002353 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002354 .Case("sse2", SSE2)
2355 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002356 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002357 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002358
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002359 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002360 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002361 .Case("3dnowa", AMD3DNowAthlon)
2362 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002363 .Case("mmx", MMX)
2364 .Default(NoMMX3DNow);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002365
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002366 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002367 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002368
2369 // Don't tell the backend if we're turning off mmx; it will end up disabling
2370 // SSE, which we don't want.
2371 std::vector<std::string>::iterator it;
2372 it = std::find(Features.begin(), Features.end(), "-mmx");
2373 if (it != Features.end())
2374 Features.erase(it);
Chris Lattner3daed522009-03-02 22:20:04 +00002375}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002376
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002377/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2378/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002379void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002380 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002381 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002382 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002383 Builder.defineMacro("__amd64__");
2384 Builder.defineMacro("__amd64");
2385 Builder.defineMacro("__x86_64");
2386 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002387 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002388 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002389 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002390
Chris Lattnerc0f59212009-03-02 22:27:17 +00002391 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002392 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2393 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002394 switch (CPU) {
2395 case CK_Generic:
2396 break;
2397 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002398 // The rest are coming from the i386 define above.
2399 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002400 break;
2401 case CK_i486:
2402 case CK_WinChipC6:
2403 case CK_WinChip2:
2404 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002405 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002406 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002407 case CK_PentiumMMX:
2408 Builder.defineMacro("__pentium_mmx__");
2409 Builder.defineMacro("__tune_pentium_mmx__");
2410 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002411 case CK_i586:
2412 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002413 defineCPUMacros(Builder, "i586");
2414 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002415 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002416 case CK_Pentium3:
2417 case CK_Pentium3M:
2418 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002419 Builder.defineMacro("__tune_pentium3__");
2420 // Fallthrough
2421 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002422 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002423 Builder.defineMacro("__tune_pentium2__");
2424 // Fallthrough
2425 case CK_PentiumPro:
2426 Builder.defineMacro("__tune_i686__");
2427 Builder.defineMacro("__tune_pentiumpro__");
2428 // Fallthrough
2429 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002430 Builder.defineMacro("__i686");
2431 Builder.defineMacro("__i686__");
2432 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2433 Builder.defineMacro("__pentiumpro");
2434 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002435 break;
2436 case CK_Pentium4:
2437 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002438 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002439 break;
2440 case CK_Yonah:
2441 case CK_Prescott:
2442 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002443 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002444 break;
2445 case CK_Core2:
2446 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002447 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002448 break;
2449 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002450 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002451 break;
2452 case CK_Corei7:
2453 case CK_Corei7AVX:
2454 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002455 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002456 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002457 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002458 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002459 Builder.defineMacro("__k6_2__");
2460 Builder.defineMacro("__tune_k6_2__");
2461 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002462 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002463 if (CPU != CK_K6_2) { // In case of fallthrough
2464 // FIXME: GCC may be enabling these in cases where some other k6
2465 // architecture is specified but -m3dnow is explicitly provided. The
2466 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002467 Builder.defineMacro("__k6_3__");
2468 Builder.defineMacro("__tune_k6_3__");
2469 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002470 // Fallthrough
2471 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002472 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002473 break;
2474 case CK_Athlon:
2475 case CK_AthlonThunderbird:
2476 case CK_Athlon4:
2477 case CK_AthlonXP:
2478 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002479 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002480 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002481 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002482 Builder.defineMacro("__tune_athlon_sse__");
2483 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002484 break;
2485 case CK_K8:
2486 case CK_K8SSE3:
2487 case CK_x86_64:
2488 case CK_Opteron:
2489 case CK_OpteronSSE3:
2490 case CK_Athlon64:
2491 case CK_Athlon64SSE3:
2492 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002493 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002494 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002495 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002496 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002497 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002498 case CK_BTVER1:
2499 defineCPUMacros(Builder, "btver1");
2500 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002501 case CK_BTVER2:
2502 defineCPUMacros(Builder, "btver2");
2503 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002504 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002505 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002506 break;
2507 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002508 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002509 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002510 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002511 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002512 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002513 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002514
Chandler Carruth88c75b02011-09-28 09:54:07 +00002515 // Target properties.
2516 Builder.defineMacro("__LITTLE_ENDIAN__");
2517 Builder.defineMacro("__REGISTER_PREFIX__", "");
2518
Chris Lattner54175442009-04-19 17:32:33 +00002519 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2520 // functions in glibc header files that use FP Stack inline asm which the
2521 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002522 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002523
Chandler Carruth88c75b02011-09-28 09:54:07 +00002524 if (HasAES)
2525 Builder.defineMacro("__AES__");
2526
Craig Topper3c0bc152012-05-31 05:18:48 +00002527 if (HasPCLMUL)
2528 Builder.defineMacro("__PCLMUL__");
2529
Craig Topper31ceea02011-12-25 05:06:45 +00002530 if (HasLZCNT)
2531 Builder.defineMacro("__LZCNT__");
2532
Benjamin Kramer84f30802012-07-07 09:39:18 +00002533 if (HasRDRND)
2534 Builder.defineMacro("__RDRND__");
2535
Craig Topper31ceea02011-12-25 05:06:45 +00002536 if (HasBMI)
2537 Builder.defineMacro("__BMI__");
2538
2539 if (HasBMI2)
2540 Builder.defineMacro("__BMI2__");
2541
Craig Toppere14e08b2011-12-29 16:10:46 +00002542 if (HasPOPCNT)
2543 Builder.defineMacro("__POPCNT__");
2544
Michael Liao463eb892012-11-10 05:17:46 +00002545 if (HasRTM)
2546 Builder.defineMacro("__RTM__");
2547
Michael Liao72339a02013-03-26 17:52:08 +00002548 if (HasPRFCHW)
2549 Builder.defineMacro("__PRFCHW__");
2550
Michael Liao1bfc28c2013-03-29 05:17:55 +00002551 if (HasRDSEED)
2552 Builder.defineMacro("__RDSEED__");
2553
Benjamin Kramer4dfa5ad2012-05-29 17:48:39 +00002554 if (HasSSE4a)
2555 Builder.defineMacro("__SSE4A__");
2556
Craig Topper6a511e12011-12-30 07:33:42 +00002557 if (HasFMA4)
2558 Builder.defineMacro("__FMA4__");
2559
Craig Topper2ae95072012-06-03 21:46:30 +00002560 if (HasFMA)
2561 Builder.defineMacro("__FMA__");
2562
Craig Topperb6af69e2012-06-09 22:24:14 +00002563 if (HasXOP)
2564 Builder.defineMacro("__XOP__");
2565
Manman Ren146e5a42012-10-11 00:59:55 +00002566 if (HasF16C)
2567 Builder.defineMacro("__F16C__");
2568
Chris Lattner84f0ea82009-03-02 22:40:39 +00002569 // Each case falls through to the previous one here.
2570 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002571 case AVX2:
2572 Builder.defineMacro("__AVX2__");
2573 case AVX:
2574 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002575 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002576 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002577 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002578 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002579 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002580 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002581 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002582 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002583 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002584 Builder.defineMacro("__SSE2__");
2585 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002586 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002587 Builder.defineMacro("__SSE__");
2588 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002589 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002590 break;
2591 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002592
Derek Schuffbabaf312012-10-11 15:52:22 +00002593 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002594 switch (SSELevel) {
Craig Topper05fe4b52012-01-09 09:19:09 +00002595 case AVX2:
2596 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002597 case SSE42:
2598 case SSE41:
2599 case SSSE3:
2600 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002601 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002602 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002603 break;
2604 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002605 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002606 break;
2607 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002608 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002609 }
2610 }
2611
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002612 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002613 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002614 case AMD3DNowAthlon:
2615 Builder.defineMacro("__3dNOW_A__");
2616 case AMD3DNow:
2617 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002618 case MMX:
2619 Builder.defineMacro("__MMX__");
2620 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002621 break;
2622 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002623
2624 if (CPU >= CK_i486) {
2625 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2626 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2627 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2628 }
2629 if (CPU >= CK_i586)
2630 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002631}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002632
Douglas Gregore727d212012-01-30 06:38:25 +00002633bool X86TargetInfo::hasFeature(StringRef Feature) const {
2634 return llvm::StringSwitch<bool>(Feature)
2635 .Case("aes", HasAES)
2636 .Case("avx", SSELevel >= AVX)
2637 .Case("avx2", SSELevel >= AVX2)
2638 .Case("bmi", HasBMI)
2639 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002640 .Case("fma", HasFMA)
Douglas Gregore727d212012-01-30 06:38:25 +00002641 .Case("fma4", HasFMA4)
2642 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002643 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002644 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2645 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2646 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002647 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002648 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002649 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002650 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002651 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002652 .Case("sse", SSELevel >= SSE1)
2653 .Case("sse2", SSELevel >= SSE2)
2654 .Case("sse3", SSELevel >= SSE3)
2655 .Case("ssse3", SSELevel >= SSSE3)
2656 .Case("sse41", SSELevel >= SSE41)
2657 .Case("sse42", SSELevel >= SSE42)
Craig Topper3c0bc152012-05-31 05:18:48 +00002658 .Case("sse4a", HasSSE4a)
Douglas Gregore727d212012-01-30 06:38:25 +00002659 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002660 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2661 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Craig Topperb6af69e2012-06-09 22:24:14 +00002662 .Case("xop", HasXOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002663 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002664 .Default(false);
2665}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002666
Eli Friedman618234a2008-08-20 02:34:37 +00002667bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002668X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002669 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002670 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002671 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002672 case 'Y': // first letter of a pair:
2673 switch (*(Name+1)) {
2674 default: return false;
2675 case '0': // First SSE register.
2676 case 't': // Any SSE register, when SSE2 is enabled.
2677 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2678 case 'm': // any MMX register, when inter-unit moves enabled.
2679 break; // falls through to setAllowsRegister.
2680 }
Eli Friedman618234a2008-08-20 02:34:37 +00002681 case 'a': // eax.
2682 case 'b': // ebx.
2683 case 'c': // ecx.
2684 case 'd': // edx.
2685 case 'S': // esi.
2686 case 'D': // edi.
2687 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002688 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002689 case 't': // top of floating point stack.
2690 case 'u': // second from top of floating point stack.
2691 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002692 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002693 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002694 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002695 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2696 case 'l': // "Index" registers: any general register that can be used as an
2697 // index in a base+index memory access.
2698 Info.setAllowsRegister();
2699 return true;
2700 case 'C': // SSE floating point constant.
2701 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002702 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002703 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002704 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002705 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002706 return true;
2707 }
2708}
2709
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002710
Eli Friedman618234a2008-08-20 02:34:37 +00002711std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002712X86TargetInfo::convertConstraint(const char *&Constraint) const {
2713 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002714 case 'a': return std::string("{ax}");
2715 case 'b': return std::string("{bx}");
2716 case 'c': return std::string("{cx}");
2717 case 'd': return std::string("{dx}");
2718 case 'S': return std::string("{si}");
2719 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002720 case 'p': // address
2721 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002722 case 't': // top of floating point stack.
2723 return std::string("{st}");
2724 case 'u': // second from top of floating point stack.
2725 return std::string("{st(1)}"); // second from top of floating point stack.
2726 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002727 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002728 }
2729}
Eli Friedman618234a2008-08-20 02:34:37 +00002730} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002731
2732namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002733// X86-32 generic target
2734class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002735public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002736 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002737 DoubleAlign = LongLongAlign = 32;
2738 LongDoubleWidth = 96;
2739 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002740 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002741 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2742 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002743 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002744 SizeType = UnsignedInt;
2745 PtrDiffType = SignedInt;
2746 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002747 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002748
2749 // Use fpret for all types.
2750 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2751 (1 << TargetInfo::Double) |
2752 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002753
2754 // x86-32 has atomics up to 8 bytes
2755 // FIXME: Check that we actually have cmpxchg8b before setting
2756 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2757 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002758 }
Meador Ingec5613b22012-06-16 03:34:49 +00002759 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2760 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002761 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002762
Chris Lattner21fb98e2009-09-23 06:06:36 +00002763 int getEHDataRegisterNumber(unsigned RegNo) const {
2764 if (RegNo == 0) return 0;
2765 if (RegNo == 1) return 2;
2766 return -1;
2767 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002768 virtual bool validateInputSize(StringRef Constraint,
2769 unsigned Size) const {
2770 switch (Constraint[0]) {
2771 default: break;
2772 case 'a':
2773 case 'b':
2774 case 'c':
2775 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002776 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002777 }
2778
2779 return true;
2780 }
Eli Friedman618234a2008-08-20 02:34:37 +00002781};
2782} // end anonymous namespace
2783
2784namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002785class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2786public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002787 NetBSDI386TargetInfo(const llvm::Triple &Triple)
2788 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002789
2790 virtual unsigned getFloatEvalMethod() const {
2791 // NetBSD defaults to "double" rounding
2792 return 1;
2793 }
2794};
2795} // end anonymous namespace
2796
2797namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002798class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2799public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002800 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
2801 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman624c1462009-07-05 18:47:56 +00002802 SizeType = UnsignedLong;
2803 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002804 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002805 }
2806};
2807} // end anonymous namespace
2808
2809namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002810class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2811public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002812 BitrigI386TargetInfo(const llvm::Triple &Triple)
2813 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman42f74f22012-08-08 23:57:20 +00002814 SizeType = UnsignedLong;
2815 IntPtrType = SignedLong;
2816 PtrDiffType = SignedLong;
2817 }
2818};
2819} // end anonymous namespace
2820
2821namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002822class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002823public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002824 DarwinI386TargetInfo(const llvm::Triple &Triple)
2825 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002826 LongDoubleWidth = 128;
2827 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002828 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002829 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002830 SizeType = UnsignedLong;
2831 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002832 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2833 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002834 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002835 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002836 }
2837
Eli Friedman618234a2008-08-20 02:34:37 +00002838};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002839} // end anonymous namespace
2840
2841namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002842// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002843class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002844public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002845 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
2846 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002847 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002848 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002849 DoubleAlign = LongLongAlign = 64;
2850 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 +00002851 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002852 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002853 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002854 virtual void getTargetDefines(const LangOptions &Opts,
2855 MacroBuilder &Builder) const {
2856 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2857 }
2858};
2859} // end anonymous namespace
2860
2861namespace {
2862
2863// x86-32 Windows Visual Studio target
2864class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2865public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002866 VisualStudioWindowsX86_32TargetInfo(const llvm::Triple &Triple)
2867 : WindowsX86_32TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002868 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002869 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2870 }
2871 virtual void getTargetDefines(const LangOptions &Opts,
2872 MacroBuilder &Builder) const {
2873 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2874 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2875 // The value of the following reflects processor type.
2876 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2877 // We lost the original triple, so we use the default.
2878 Builder.defineMacro("_M_IX86", "600");
2879 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002880};
2881} // end anonymous namespace
2882
2883namespace {
2884// x86-32 MinGW target
2885class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2886public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002887 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
2888 : WindowsX86_32TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002889 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002890 MacroBuilder &Builder) const {
2891 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002892 DefineStd(Builder, "WIN32", Opts);
2893 DefineStd(Builder, "WINNT", Opts);
2894 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002895 Builder.defineMacro("__MSVCRT__");
2896 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002897
2898 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2899 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002900 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002901 // Provide "as-is" __declspec.
2902 Builder.defineMacro("__declspec", "__declspec");
2903 else
2904 // Provide alias of __attribute__ like mingw32-gcc.
2905 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002906 }
2907};
2908} // end anonymous namespace
2909
2910namespace {
2911// x86-32 Cygwin target
2912class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2913public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002914 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
2915 : X86_32TargetInfo(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002916 TLSSupported = false;
2917 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002918 DoubleAlign = LongLongAlign = 64;
2919 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2920 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002921 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002922 }
2923 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002924 MacroBuilder &Builder) const {
2925 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00002926 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002927 Builder.defineMacro("__CYGWIN__");
2928 Builder.defineMacro("__CYGWIN32__");
2929 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002930 if (Opts.CPlusPlus)
2931 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002932 }
Eli Friedman29a30502008-08-21 01:40:19 +00002933};
2934} // end anonymous namespace
2935
2936namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002937// x86-32 Haiku target
2938class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2939public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002940 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002941 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002942 IntPtrType = SignedLong;
2943 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00002944 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002945 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002946 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002947 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002948 virtual void getTargetDefines(const LangOptions &Opts,
2949 MacroBuilder &Builder) const {
2950 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2951 Builder.defineMacro("__INTEL__");
2952 Builder.defineMacro("__HAIKU__");
2953 }
2954};
2955} // end anonymous namespace
2956
Douglas Gregordca52262011-07-01 22:41:14 +00002957// RTEMS Target
2958template<typename Target>
2959class RTEMSTargetInfo : public OSTargetInfo<Target> {
2960protected:
2961 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
2962 MacroBuilder &Builder) const {
2963 // RTEMS defines; list based off of gcc output
2964
Douglas Gregordca52262011-07-01 22:41:14 +00002965 Builder.defineMacro("__rtems__");
2966 Builder.defineMacro("__ELF__");
2967 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002968
Douglas Gregordca52262011-07-01 22:41:14 +00002969public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002970 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
2971 this->UserLabelPrefix = "";
Douglas Gregordca52262011-07-01 22:41:14 +00002972
Benjamin Kramer9df08232013-06-29 16:37:14 +00002973 switch (Triple.getArch()) {
2974 default:
2975 case llvm::Triple::x86:
2976 // this->MCountName = ".mcount";
2977 break;
2978 case llvm::Triple::mips:
2979 case llvm::Triple::mipsel:
2980 case llvm::Triple::ppc:
2981 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00002982 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002983 // this->MCountName = "_mcount";
2984 break;
2985 case llvm::Triple::arm:
2986 // this->MCountName = "__mcount";
2987 break;
Douglas Gregordca52262011-07-01 22:41:14 +00002988 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00002989 }
Douglas Gregordca52262011-07-01 22:41:14 +00002990};
2991
2992namespace {
2993// x86-32 RTEMS target
2994class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
2995public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002996 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregordca52262011-07-01 22:41:14 +00002997 SizeType = UnsignedLong;
2998 IntPtrType = SignedLong;
2999 PtrDiffType = SignedLong;
3000 this->UserLabelPrefix = "";
3001 }
3002 virtual void getTargetDefines(const LangOptions &Opts,
3003 MacroBuilder &Builder) const {
3004 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3005 Builder.defineMacro("__INTEL__");
3006 Builder.defineMacro("__rtems__");
3007 }
3008};
3009} // end anonymous namespace
3010
Chris Lattner86ed3a32010-04-11 19:29:39 +00003011namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003012// x86-64 generic target
3013class X86_64TargetInfo : public X86TargetInfo {
3014public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003015 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003016 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003017 LongDoubleWidth = 128;
3018 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003019 LargeArrayMinWidth = 128;
3020 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003021 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003022 IntMaxType = SignedLong;
3023 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003024 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003025 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003026
Eli Friedmaned855cb2008-08-21 00:13:15 +00003027 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3028 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003029 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003030
3031 // Use fpret only for long double.
3032 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003033
Anders Carlssoneea64802011-10-31 16:27:11 +00003034 // Use fp2ret for _Complex long double.
3035 ComplexLongDoubleUsesFP2Ret = true;
3036
Eli Friedman2be46072011-10-14 20:59:01 +00003037 // x86-64 has atomics up to 16 bytes.
3038 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3039 // on CPUs with cmpxchg16b
3040 MaxAtomicPromoteWidth = 128;
3041 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003042 }
Meador Ingec5613b22012-06-16 03:34:49 +00003043 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3044 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003045 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003046
Chris Lattner21fb98e2009-09-23 06:06:36 +00003047 int getEHDataRegisterNumber(unsigned RegNo) const {
3048 if (RegNo == 0) return 0;
3049 if (RegNo == 1) return 1;
3050 return -1;
3051 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003052
3053 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00003054 return (CC == CC_Default ||
3055 CC == CC_C ||
3056 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003057 }
3058
Aaron Ballmanfff32482012-12-09 17:45:41 +00003059 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3060 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003061 }
3062
Eli Friedman618234a2008-08-20 02:34:37 +00003063};
3064} // end anonymous namespace
3065
3066namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003067// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003068class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003069public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003070 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3071 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003072 TLSSupported = false;
3073 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003074 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003075 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003076 IntMaxType = SignedLongLong;
3077 UIntMaxType = UnsignedLongLong;
3078 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003079 SizeType = UnsignedLongLong;
3080 PtrDiffType = SignedLongLong;
3081 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003082 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003083 }
3084 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003085 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003086 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003087 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003088 }
Meador Ingec5613b22012-06-16 03:34:49 +00003089 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3090 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003091 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003092};
3093} // end anonymous namespace
3094
3095namespace {
3096// x86-64 Windows Visual Studio target
3097class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3098public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003099 VisualStudioWindowsX86_64TargetInfo(const llvm::Triple &Triple)
3100 : WindowsX86_64TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003101 LongDoubleWidth = LongDoubleAlign = 64;
3102 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003103 }
3104 virtual void getTargetDefines(const LangOptions &Opts,
3105 MacroBuilder &Builder) const {
3106 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3107 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003108 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003109 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003110 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003111};
3112} // end anonymous namespace
3113
3114namespace {
3115// x86-64 MinGW target
3116class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3117public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003118 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3119 : WindowsX86_64TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003120 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003121 MacroBuilder &Builder) const {
3122 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003123 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003124 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003125 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003126 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003127
3128 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3129 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003130 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003131 // Provide "as-is" __declspec.
3132 Builder.defineMacro("__declspec", "__declspec");
3133 else
3134 // Provide alias of __attribute__ like mingw32-gcc.
3135 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003136 }
3137};
3138} // end anonymous namespace
3139
3140namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003141class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3142public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003143 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3144 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003145 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003146 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003147 }
3148};
3149} // end anonymous namespace
3150
3151namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003152class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3153public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003154 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3155 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003156 IntMaxType = SignedLongLong;
3157 UIntMaxType = UnsignedLongLong;
3158 Int64Type = SignedLongLong;
3159 }
3160};
3161} // end anonymous namespace
3162
3163namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003164class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3165public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003166 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3167 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3168 IntMaxType = SignedLongLong;
3169 UIntMaxType = UnsignedLongLong;
3170 Int64Type = SignedLongLong;
Eli Friedman42f74f22012-08-08 23:57:20 +00003171 }
3172};
Tim Northoverc264e162013-01-31 12:13:10 +00003173}
3174
3175namespace {
3176class AArch64TargetInfo : public TargetInfo {
3177 static const char * const GCCRegNames[];
3178 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003179
Tim Northoverb793f0d2013-08-01 09:23:19 +00003180 enum FPUModeEnum {
3181 FPUMode,
3182 NeonMode
3183 };
3184
3185 unsigned FPU;
Tim Northoverff920ee2013-05-04 07:15:13 +00003186 static const Builtin::Info BuiltinInfo[];
Tim Northoverb793f0d2013-08-01 09:23:19 +00003187
Tim Northoverc264e162013-01-31 12:13:10 +00003188public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003189 AArch64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Tim Northoverc264e162013-01-31 12:13:10 +00003190 BigEndian = false;
3191 LongWidth = LongAlign = 64;
3192 LongDoubleWidth = LongDoubleAlign = 128;
3193 PointerWidth = PointerAlign = 64;
3194 SuitableAlign = 128;
3195 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3196 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3197 "f128:128:128-n32:64-S128";
3198
3199 WCharType = UnsignedInt;
3200 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3201
Tim Northover6a93c862013-02-18 12:11:32 +00003202 // AArch64 backend supports 64-bit operations at the moment. In principle
3203 // 128-bit is possible if register-pairs are used.
3204 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3205
Tim Northoverc264e162013-01-31 12:13:10 +00003206 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3207 }
3208 virtual void getTargetDefines(const LangOptions &Opts,
3209 MacroBuilder &Builder) const {
3210 // GCC defines theses currently
3211 Builder.defineMacro("__aarch64__");
3212 Builder.defineMacro("__AARCH64EL__");
3213
3214 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3215
3216 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3217 // which was intended to be compatible with a 64-bit implementation. They
3218 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003219 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3220 Builder.defineMacro("__ARM_ACLE", "101");
3221 Builder.defineMacro("__ARM_ARCH", "8");
3222 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003223
Tim Northoverdabcbf92013-04-05 14:08:55 +00003224 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3225 Builder.defineMacro("__ARM_FEATURE_CLZ");
3226 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003227
3228 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3229 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003230 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003231
3232 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003233 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003234
3235 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003236 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3237 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003238
3239 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003240 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003241
3242 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003243 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003244
Tim Northoverdabcbf92013-04-05 14:08:55 +00003245 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003246 Opts.ShortWChar ? "2" : "4");
3247
Tim Northoverdabcbf92013-04-05 14:08:55 +00003248 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003249 Opts.ShortEnums ? "1" : "4");
3250
3251 if (BigEndian)
Tim Northoverb793f0d2013-08-01 09:23:19 +00003252 Builder.defineMacro("__AARCH_BIG_ENDIAN");
3253
3254 if (FPU == NeonMode) {
3255 Builder.defineMacro("__AARCH_FEATURE_ADVSIMD");
3256
3257 // 64-bit NEON supports half, single and double precision operations.
3258 Builder.defineMacro("__AARCH_ADVSIMD_FP", "0xe");
3259 }
Tim Northoverc264e162013-01-31 12:13:10 +00003260 }
3261 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3262 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003263 Records = BuiltinInfo;
3264 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003265 }
3266 virtual bool hasFeature(StringRef Feature) const {
Tim Northoverb793f0d2013-08-01 09:23:19 +00003267 return Feature == "aarch64" || (Feature == "neon" && FPU == NeonMode);
Tim Northoverc264e162013-01-31 12:13:10 +00003268 }
Tim Northoverb793f0d2013-08-01 09:23:19 +00003269
3270 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
3271 StringRef Name, bool Enabled) const {
3272 if (Name == "neon") {
3273 Features[Name] = Enabled;
3274 return true;
3275 }
3276
3277 return false;
3278 }
3279
3280 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
3281 FPU = FPUMode;
3282 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3283 if (Features[i] == "+neon")
3284 FPU = NeonMode;
3285 }
3286 }
3287
3288 virtual void getGCCRegNames(const char *const *&Names,
Tim Northoverc264e162013-01-31 12:13:10 +00003289 unsigned &NumNames) const;
3290 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3291 unsigned &NumAliases) const;
3292
3293 virtual bool isCLZForZeroUndef() const { return false; }
3294
3295 virtual bool validateAsmConstraint(const char *&Name,
3296 TargetInfo::ConstraintInfo &Info) const {
3297 switch (*Name) {
3298 default: return false;
3299 case 'w': // An FP/SIMD vector register
3300 Info.setAllowsRegister();
3301 return true;
3302 case 'I': // Constant that can be used with an ADD instruction
3303 case 'J': // Constant that can be used with a SUB instruction
3304 case 'K': // Constant that can be used with a 32-bit logical instruction
3305 case 'L': // Constant that can be used with a 64-bit logical instruction
3306 case 'M': // Constant that can be used as a 32-bit MOV immediate
3307 case 'N': // Constant that can be used as a 64-bit MOV immediate
3308 case 'Y': // Floating point constant zero
3309 case 'Z': // Integer constant zero
3310 return true;
3311 case 'Q': // A memory reference with base register and no offset
3312 Info.setAllowsMemory();
3313 return true;
3314 case 'S': // A symbolic address
3315 Info.setAllowsRegister();
3316 return true;
3317 case 'U':
3318 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3319 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3320 // Usa: An absolute symbolic address
3321 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3322 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3323 }
3324 }
3325
3326 virtual const char *getClobbers() const {
3327 // There are no AArch64 clobbers shared by all asm statements.
3328 return "";
3329 }
3330
3331 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3332 return TargetInfo::AArch64ABIBuiltinVaList;
3333 }
3334};
3335
3336const char * const AArch64TargetInfo::GCCRegNames[] = {
3337 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3338 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3339 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3340 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3341
3342 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3343 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3344 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3345 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3346
3347 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3348 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3349 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3350 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3351
3352 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3353 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3354 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3355 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3356
3357 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3358 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3359 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3360 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3361
3362 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3363 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3364 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3365 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3366
3367 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3368 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3369 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3370 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3371};
3372
3373void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3374 unsigned &NumNames) const {
3375 Names = GCCRegNames;
3376 NumNames = llvm::array_lengthof(GCCRegNames);
3377}
3378
3379const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3380 { { "x16" }, "ip0"},
3381 { { "x17" }, "ip1"},
3382 { { "x29" }, "fp" },
3383 { { "x30" }, "lr" }
3384};
3385
3386void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3387 unsigned &NumAliases) const {
3388 Aliases = GCCRegAliases;
3389 NumAliases = llvm::array_lengthof(GCCRegAliases);
3390
3391}
Tim Northoverff920ee2013-05-04 07:15:13 +00003392
3393const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3394#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3395#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3396 ALL_LANGUAGES },
3397#include "clang/Basic/BuiltinsAArch64.def"
3398};
3399
Eli Friedman42f74f22012-08-08 23:57:20 +00003400} // end anonymous namespace
3401
3402namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003403class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003404 // Possible FPU choices.
3405 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003406 VFP2FPU = (1 << 0),
3407 VFP3FPU = (1 << 1),
3408 VFP4FPU = (1 << 2),
3409 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003410 };
3411
3412 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003413 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003414 }
3415
3416 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3417 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003418
Daniel Dunbareac7c532009-12-18 18:42:37 +00003419 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003420
Bob Wilsoncfaab002012-09-29 23:52:52 +00003421 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003422
Logan Chieneae5a8202012-10-10 06:56:20 +00003423 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003424 unsigned IsThumb : 1;
3425
3426 // Initialized via features.
3427 unsigned SoftFloat : 1;
3428 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003429
Chris Lattner2752c012010-03-03 19:03:45 +00003430 static const Builtin::Info BuiltinInfo[];
3431
Rafael Espindola620c0af2013-05-13 20:09:47 +00003432 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3433 // On linux, binaries targeting old cpus call functions in libgcc to
3434 // perform atomic operations. The implementation in libgcc then calls into
3435 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3436 // is that if we assume the kernel is at least as recent as the hardware,
3437 // it is safe to use atomic instructions on armv6 and newer.
Rafael Espindolae1e03422013-06-17 20:00:15 +00003438 if (T.getOS() != llvm::Triple::Linux &&
3439 T.getOS() != llvm::Triple::FreeBSD &&
3440 T.getOS() != llvm::Triple::Bitrig)
Ed Schouten04491632013-06-15 09:40:14 +00003441 return false;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003442 StringRef ArchName = T.getArchName();
Rafael Espindola69db5552013-05-14 00:44:24 +00003443 if (T.getArch() == llvm::Triple::arm) {
3444 if (!ArchName.startswith("armv"))
3445 return false;
3446 StringRef VersionStr = ArchName.substr(4);
3447 unsigned Version;
3448 if (VersionStr.getAsInteger(10, Version))
3449 return false;
3450 return Version >= 6;
3451 }
3452 assert(T.getArch() == llvm::Triple::thumb);
3453 if (!ArchName.startswith("thumbv"))
3454 return false;
3455 StringRef VersionStr = ArchName.substr(6);
3456 unsigned Version;
3457 if (VersionStr.getAsInteger(10, Version))
3458 return false;
3459 return Version >= 7;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003460 }
3461
Chris Lattner393ff042008-04-21 18:56:49 +00003462public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003463 ARMTargetInfo(const llvm::Triple &Triple)
3464 : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
3465 IsAAPCS(true) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003466 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003467 SizeType = UnsignedInt;
3468 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003469 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3470 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003471
Chris Lattner9bffb072010-04-23 16:29:58 +00003472 // {} in inline assembly are neon specifiers, not assembly variant
3473 // specifiers.
3474 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003475
Daniel Dunbareac7c532009-12-18 18:42:37 +00003476 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003477 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003478 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003479 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3480 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003481 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3482 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003483 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003484 } else {
3485 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3486 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003487 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003488 }
John McCallee79a4c2010-08-21 22:46:04 +00003489
3490 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003491 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003492
3493 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003494 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003495 if (shouldUseInlineAtomic(getTriple()))
3496 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003497
3498 // Do force alignment of members that follow zero length bitfields. If
3499 // the alignment of the zero-length bitfield is greater than the member
3500 // that follows it, `bar', `bar' will be aligned as the type of the
3501 // zero length bitfield.
3502 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003503 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003504 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003505 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003506 ABI = Name;
3507
Daniel Dunbara2a41612009-09-14 00:02:24 +00003508 // The defaults (above) are for AAPCS, check if we need to change them.
3509 //
3510 // FIXME: We need support for -meabi... we could just mangle it into the
3511 // name.
3512 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003513 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003514 // size_t is unsigned int on FreeBSD.
3515 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3516 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003517
James Molloya6d81f92011-11-23 13:35:08 +00003518 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3519 WCharType = SignedInt;
3520
Daniel Dunbar684de632010-04-22 16:14:54 +00003521 // Do not respect the alignment of bit-field types when laying out
3522 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3523 UseBitFieldTypeAlignment = false;
3524
Chad Rosier61a62212011-08-04 01:21:14 +00003525 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003526 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3527 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003528 ZeroLengthBitfieldBoundary = 32;
3529
Logan Chieneae5a8202012-10-10 06:56:20 +00003530 IsAAPCS = false;
3531
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003532 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003533 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3534 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003535 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 +00003536 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003537 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003538 } else {
3539 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 +00003540 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003541 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003542 }
3543
Chad Rosier9f1210c2011-07-26 07:03:04 +00003544 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003545 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Bob Wilsone4bce7a2013-06-18 05:36:04 +00003546 // size_t is unsigned long on Darwin.
3547 if (getTriple().isOSDarwin())
3548 SizeType = UnsignedLong;
Logan Chieneae5a8202012-10-10 06:56:20 +00003549 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003550 // FIXME: Enumerated types are variable width in straight AAPCS.
3551 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003552 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003553 } else
3554 return false;
3555
3556 return true;
3557 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003558
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003559 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003560 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3561 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003562 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3563 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003564 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003565 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003566 Features["vfp4"] = true;
3567 Features["neon"] = true;
3568 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003569 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003570
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003571 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00003572 StringRef Name,
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003573 bool Enabled) const {
Evan Chengf972b262011-07-08 06:40:11 +00003574 if (Name == "soft-float" || Name == "soft-float-abi" ||
Bob Wilsoncfaab002012-09-29 23:52:52 +00003575 Name == "vfp2" || Name == "vfp3" || Name == "vfp4" || Name == "neon" ||
Joey Goulycbed3bf2013-06-27 13:19:54 +00003576 Name == "d16" || Name == "neonfp" || Name == "v8fp") {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003577 Features[Name] = Enabled;
3578 } else
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003579 return false;
3580
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003581 return true;
3582 }
3583
3584 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003585 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003586 SoftFloat = SoftFloatABI = false;
3587 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3588 if (Features[i] == "+soft-float")
3589 SoftFloat = true;
3590 else if (Features[i] == "+soft-float-abi")
3591 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003592 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003593 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003594 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003595 FPU |= VFP3FPU;
3596 else if (Features[i] == "+vfp4")
3597 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003598 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003599 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003600 }
3601
3602 // Remove front-end specific options which the backend handles differently.
3603 std::vector<std::string>::iterator it;
3604 it = std::find(Features.begin(), Features.end(), "+soft-float");
3605 if (it != Features.end())
3606 Features.erase(it);
3607 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3608 if (it != Features.end())
3609 Features.erase(it);
3610 }
3611
Douglas Gregore727d212012-01-30 06:38:25 +00003612 virtual bool hasFeature(StringRef Feature) const {
3613 return llvm::StringSwitch<bool>(Feature)
3614 .Case("arm", true)
3615 .Case("softfloat", SoftFloat)
3616 .Case("thumb", IsThumb)
3617 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3618 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3619 .Default(false);
3620 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003621 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003622 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003623 return llvm::StringSwitch<const char*>(Name)
3624 .Cases("arm8", "arm810", "4")
3625 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3626 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3627 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3628 .Case("ep9312", "4T")
3629 .Cases("arm10tdmi", "arm1020t", "5T")
3630 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3631 .Case("arm926ej-s", "5TEJ")
3632 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3633 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003634 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003635 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003636 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003637 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003638 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3639 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003640 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003641 .Case("cortex-a9-mp", "7F")
3642 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003643 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003644 .Case("cortex-m0", "6M")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +00003645 .Case("cortex-a53", "8A")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003646 .Default(0);
3647 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003648 static const char *getCPUProfile(StringRef Name) {
3649 return llvm::StringSwitch<const char*>(Name)
3650 .Cases("cortex-a8", "cortex-a9", "A")
3651 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003652 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003653 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003654 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003655 virtual bool setCPU(const std::string &Name) {
3656 if (!getCPUDefineSuffix(Name))
3657 return false;
3658
3659 CPU = Name;
3660 return true;
3661 }
Chris Lattner33328642009-03-20 15:52:06 +00003662 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003663 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003664 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003665 Builder.defineMacro("__arm");
3666 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003667
Chris Lattnerc0f59212009-03-02 22:27:17 +00003668 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003669 Builder.defineMacro("__ARMEL__");
3670 Builder.defineMacro("__LITTLE_ENDIAN__");
3671 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003672
Chris Lattner5f9e2722011-07-23 10:55:15 +00003673 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003674 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003675 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3676 StringRef CPUProfile = getCPUProfile(CPU);
3677 if (!CPUProfile.empty())
3678 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3679
Mike Stump437bb4b2009-04-08 02:07:04 +00003680 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003681
Daniel Dunbareac7c532009-12-18 18:42:37 +00003682 // FIXME: It's more complicated than this and we don't really support
3683 // interworking.
3684 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003685 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003686
David Tweedb16abb12012-10-25 13:33:01 +00003687 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003688 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003689 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003690 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003691 Builder.defineMacro("__ARM_PCS", "1");
3692
David Tweedb16abb12012-10-25 13:33:01 +00003693 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003694 Builder.defineMacro("__ARM_PCS_VFP", "1");
3695 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003696
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003697 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003698 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003699
3700 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003701 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003702
Bob Wilson84f95cf2011-05-13 18:56:03 +00003703 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003704 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003705 Builder.defineMacro("__THUMBEL__");
3706 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003707 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003708 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003709 }
3710
3711 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003712 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003713
Bob Wilsoncfaab002012-09-29 23:52:52 +00003714 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003715 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003716 if (FPU & VFP2FPU)
3717 Builder.defineMacro("__ARM_VFPV2__");
3718 if (FPU & VFP3FPU)
3719 Builder.defineMacro("__ARM_VFPV3__");
3720 if (FPU & VFP4FPU)
3721 Builder.defineMacro("__ARM_VFPV4__");
3722 }
3723
Daniel Dunbara91320b2009-12-21 23:28:17 +00003724 // This only gets set when Neon instructions are actually available, unlike
3725 // the VFP define, hence the soft float and arch check. This is subtly
3726 // different from gcc, we follow the intent which was that it should be set
3727 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003728 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003729 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003730 }
3731 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3732 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003733 Records = BuiltinInfo;
3734 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003735 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003736 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003737 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003738 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003739 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003740 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003741 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003742 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003743 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003744 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003745 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003746 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003747 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003748 case 'l': // r0-r7
3749 case 'h': // r8-r15
3750 case 'w': // VFP Floating point register single precision
3751 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003752 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003753 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003754 case 'Q': // A memory address that is a single base register.
3755 Info.setAllowsMemory();
3756 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003757 case 'U': // a memory reference...
3758 switch (Name[1]) {
3759 case 'q': // ...ARMV4 ldrsb
3760 case 'v': // ...VFP load/store (reg+constant offset)
3761 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003762 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003763 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003764 case 'n': // valid address for Neon doubleword vector load/store
3765 case 'm': // valid address for Neon element and structure load/store
3766 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003767 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003768 Info.setAllowsMemory();
3769 Name++;
3770 return true;
3771 }
Nate Begemanad487f42008-04-22 05:03:19 +00003772 }
Chris Lattner393ff042008-04-21 18:56:49 +00003773 return false;
3774 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003775 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003776 std::string R;
3777 switch (*Constraint) {
3778 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003779 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003780 Constraint++;
3781 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003782 case 'p': // 'p' should be translated to 'r' by default.
3783 R = std::string("r");
3784 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003785 default:
3786 return std::string(1, *Constraint);
3787 }
3788 return R;
3789 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003790 virtual bool validateConstraintModifier(StringRef Constraint,
3791 const char Modifier,
3792 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003793 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003794 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003795
Bill Wendling50d46ca2012-10-25 23:28:48 +00003796 // Strip off constraint modifiers.
3797 while (Constraint[0] == '=' ||
3798 Constraint[0] == '+' ||
3799 Constraint[0] == '&')
3800 Constraint = Constraint.substr(1);
3801
3802 switch (Constraint[0]) {
3803 default: break;
3804 case 'r': {
3805 switch (Modifier) {
3806 default:
Bob Wilson221a8902013-06-03 23:57:13 +00003807 return (isInOut || isOutput || Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003808 case 'q':
3809 // A register of size 32 cannot fit a vector type.
3810 return false;
3811 }
3812 }
3813 }
3814
3815 return true;
3816 }
Chris Lattner393ff042008-04-21 18:56:49 +00003817 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003818 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003819 return "";
3820 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003821
3822 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3823 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3824 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003825
3826 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3827 if (RegNo == 0) return 0;
3828 if (RegNo == 1) return 1;
3829 return -1;
3830 }
Chris Lattner393ff042008-04-21 18:56:49 +00003831};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003832
3833const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003834 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003835 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003836 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3837
3838 // Float registers
3839 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3840 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3841 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003842 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003843
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003844 // Double registers
3845 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3846 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003847 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3848 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003849
3850 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003851 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3852 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003853};
3854
3855void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003856 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003857 Names = GCCRegNames;
3858 NumNames = llvm::array_lengthof(GCCRegNames);
3859}
3860
3861const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003862 { { "a1" }, "r0" },
3863 { { "a2" }, "r1" },
3864 { { "a3" }, "r2" },
3865 { { "a4" }, "r3" },
3866 { { "v1" }, "r4" },
3867 { { "v2" }, "r5" },
3868 { { "v3" }, "r6" },
3869 { { "v4" }, "r7" },
3870 { { "v5" }, "r8" },
3871 { { "v6", "rfp" }, "r9" },
3872 { { "sl" }, "r10" },
3873 { { "fp" }, "r11" },
3874 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003875 { { "r13" }, "sp" },
3876 { { "r14" }, "lr" },
3877 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003878 // The S, D and Q registers overlap, but aren't really aliases; we
3879 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003880};
3881
3882void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3883 unsigned &NumAliases) const {
3884 Aliases = GCCRegAliases;
3885 NumAliases = llvm::array_lengthof(GCCRegAliases);
3886}
Chris Lattner2752c012010-03-03 19:03:45 +00003887
3888const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003889#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003890#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003891 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003892#include "clang/Basic/BuiltinsARM.def"
3893};
Chris Lattner393ff042008-04-21 18:56:49 +00003894} // end anonymous namespace.
3895
Eli Friedmana9f54962008-08-20 07:44:10 +00003896namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003897class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003898 public DarwinTargetInfo<ARMTargetInfo> {
3899protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003900 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003901 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003902 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003903 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003904
Torok Edwin5f6c1942009-06-30 17:10:35 +00003905public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003906 DarwinARMTargetInfo(const llvm::Triple &Triple)
3907 : DarwinTargetInfo<ARMTargetInfo>(Triple) {
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003908 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003909 // iOS always has 64-bit atomic instructions.
3910 // FIXME: This should be based off of the target features in ARMTargetInfo.
3911 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003912
3913 // Darwin on iOS uses a variant of the ARM C++ ABI.
3914 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003915 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003916};
3917} // end anonymous namespace.
3918
Tony Linthicum96319392011-12-12 21:14:55 +00003919
3920namespace {
3921// Hexagon abstract base class
3922class HexagonTargetInfo : public TargetInfo {
3923 static const Builtin::Info BuiltinInfo[];
3924 static const char * const GCCRegNames[];
3925 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3926 std::string CPU;
3927public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003928 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003929 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003930 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003931 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003932 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003933
3934 // {} in inline assembly are packet specifiers, not assembly variant
3935 // specifiers.
3936 NoAsmVariants = true;
3937 }
3938
3939 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3940 unsigned &NumRecords) const {
3941 Records = BuiltinInfo;
3942 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
3943 }
3944
3945 virtual bool validateAsmConstraint(const char *&Name,
3946 TargetInfo::ConstraintInfo &Info) const {
3947 return true;
3948 }
3949
3950 virtual void getTargetDefines(const LangOptions &Opts,
3951 MacroBuilder &Builder) const;
3952
Douglas Gregore727d212012-01-30 06:38:25 +00003953 virtual bool hasFeature(StringRef Feature) const {
3954 return Feature == "hexagon";
3955 }
3956
Meador Ingec5613b22012-06-16 03:34:49 +00003957 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3958 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00003959 }
3960 virtual void getGCCRegNames(const char * const *&Names,
3961 unsigned &NumNames) const;
3962 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3963 unsigned &NumAliases) const;
3964 virtual const char *getClobbers() const {
3965 return "";
3966 }
Sebastian Pop43115d42012-01-13 20:37:10 +00003967
3968 static const char *getHexagonCPUSuffix(StringRef Name) {
3969 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00003970 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00003971 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00003972 .Default(0);
3973 }
3974
Tony Linthicum96319392011-12-12 21:14:55 +00003975 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00003976 if (!getHexagonCPUSuffix(Name))
3977 return false;
3978
Tony Linthicum96319392011-12-12 21:14:55 +00003979 CPU = Name;
3980 return true;
3981 }
3982};
3983
3984void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
3985 MacroBuilder &Builder) const {
3986 Builder.defineMacro("qdsp6");
3987 Builder.defineMacro("__qdsp6", "1");
3988 Builder.defineMacro("__qdsp6__", "1");
3989
3990 Builder.defineMacro("hexagon");
3991 Builder.defineMacro("__hexagon", "1");
3992 Builder.defineMacro("__hexagon__", "1");
3993
3994 if(CPU == "hexagonv1") {
3995 Builder.defineMacro("__HEXAGON_V1__");
3996 Builder.defineMacro("__HEXAGON_ARCH__", "1");
3997 if(Opts.HexagonQdsp6Compat) {
3998 Builder.defineMacro("__QDSP6_V1__");
3999 Builder.defineMacro("__QDSP6_ARCH__", "1");
4000 }
4001 }
4002 else if(CPU == "hexagonv2") {
4003 Builder.defineMacro("__HEXAGON_V2__");
4004 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4005 if(Opts.HexagonQdsp6Compat) {
4006 Builder.defineMacro("__QDSP6_V2__");
4007 Builder.defineMacro("__QDSP6_ARCH__", "2");
4008 }
4009 }
4010 else if(CPU == "hexagonv3") {
4011 Builder.defineMacro("__HEXAGON_V3__");
4012 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4013 if(Opts.HexagonQdsp6Compat) {
4014 Builder.defineMacro("__QDSP6_V3__");
4015 Builder.defineMacro("__QDSP6_ARCH__", "3");
4016 }
4017 }
4018 else if(CPU == "hexagonv4") {
4019 Builder.defineMacro("__HEXAGON_V4__");
4020 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4021 if(Opts.HexagonQdsp6Compat) {
4022 Builder.defineMacro("__QDSP6_V4__");
4023 Builder.defineMacro("__QDSP6_ARCH__", "4");
4024 }
4025 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00004026 else if(CPU == "hexagonv5") {
4027 Builder.defineMacro("__HEXAGON_V5__");
4028 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4029 if(Opts.HexagonQdsp6Compat) {
4030 Builder.defineMacro("__QDSP6_V5__");
4031 Builder.defineMacro("__QDSP6_ARCH__", "5");
4032 }
4033 }
Tony Linthicum96319392011-12-12 21:14:55 +00004034}
4035
4036const char * const HexagonTargetInfo::GCCRegNames[] = {
4037 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4038 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4039 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4040 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4041 "p0", "p1", "p2", "p3",
4042 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4043};
4044
4045void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4046 unsigned &NumNames) const {
4047 Names = GCCRegNames;
4048 NumNames = llvm::array_lengthof(GCCRegNames);
4049}
4050
4051
4052const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4053 { { "sp" }, "r29" },
4054 { { "fp" }, "r30" },
4055 { { "lr" }, "r31" },
4056 };
4057
4058void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4059 unsigned &NumAliases) const {
4060 Aliases = GCCRegAliases;
4061 NumAliases = llvm::array_lengthof(GCCRegAliases);
4062}
4063
4064
4065const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4066#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4067#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4068 ALL_LANGUAGES },
4069#include "clang/Basic/BuiltinsHexagon.def"
4070};
4071}
4072
4073
Reid Spencer5f016e22007-07-11 17:01:13 +00004074namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004075// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4076class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004077 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4078 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004079 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004080public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004081 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004082
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004083 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00004084 StringRef Name,
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004085 bool Enabled) const {
4086 if (Name == "soft-float")
4087 Features[Name] = Enabled;
4088 else
4089 return false;
4090
4091 return true;
4092 }
4093 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
4094 SoftFloat = false;
4095 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4096 if (Features[i] == "+soft-float")
4097 SoftFloat = true;
4098 }
Chris Lattner33328642009-03-20 15:52:06 +00004099 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004100 MacroBuilder &Builder) const {
4101 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004102 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004103
4104 if (SoftFloat)
4105 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004106 }
Douglas Gregore727d212012-01-30 06:38:25 +00004107
4108 virtual bool hasFeature(StringRef Feature) const {
4109 return llvm::StringSwitch<bool>(Feature)
4110 .Case("softfloat", SoftFloat)
4111 .Case("sparc", true)
4112 .Default(false);
4113 }
4114
Gabor Greif26658672008-02-21 16:29:08 +00004115 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4116 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004117 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004118 }
Meador Ingec5613b22012-06-16 03:34:49 +00004119 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4120 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004121 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004122 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004123 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004124 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004125 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004126 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004127 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004128 // FIXME: Implement!
4129 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004130 }
4131 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004132 // FIXME: Implement!
4133 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004134 }
4135};
4136
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004137const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004138 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4139 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4140 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4141 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4142};
4143
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004144void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4145 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004146 Names = GCCRegNames;
4147 NumNames = llvm::array_lengthof(GCCRegNames);
4148}
4149
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004150const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004151 { { "g0" }, "r0" },
4152 { { "g1" }, "r1" },
4153 { { "g2" }, "r2" },
4154 { { "g3" }, "r3" },
4155 { { "g4" }, "r4" },
4156 { { "g5" }, "r5" },
4157 { { "g6" }, "r6" },
4158 { { "g7" }, "r7" },
4159 { { "o0" }, "r8" },
4160 { { "o1" }, "r9" },
4161 { { "o2" }, "r10" },
4162 { { "o3" }, "r11" },
4163 { { "o4" }, "r12" },
4164 { { "o5" }, "r13" },
4165 { { "o6", "sp" }, "r14" },
4166 { { "o7" }, "r15" },
4167 { { "l0" }, "r16" },
4168 { { "l1" }, "r17" },
4169 { { "l2" }, "r18" },
4170 { { "l3" }, "r19" },
4171 { { "l4" }, "r20" },
4172 { { "l5" }, "r21" },
4173 { { "l6" }, "r22" },
4174 { { "l7" }, "r23" },
4175 { { "i0" }, "r24" },
4176 { { "i1" }, "r25" },
4177 { { "i2" }, "r26" },
4178 { { "i3" }, "r27" },
4179 { { "i4" }, "r28" },
4180 { { "i5" }, "r29" },
4181 { { "i6", "fp" }, "r30" },
4182 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004183};
4184
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004185void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4186 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004187 Aliases = GCCRegAliases;
4188 NumAliases = llvm::array_lengthof(GCCRegAliases);
4189}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004190
4191// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4192class SparcV8TargetInfo : public SparcTargetInfo {
4193public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004194 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004195 // FIXME: Support Sparc quad-precision long double?
4196 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4197 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4198 }
4199
4200 virtual void getTargetDefines(const LangOptions &Opts,
4201 MacroBuilder &Builder) const {
4202 SparcTargetInfo::getTargetDefines(Opts, Builder);
4203 Builder.defineMacro("__sparcv8");
4204 }
4205};
4206
4207// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4208class SparcV9TargetInfo : public SparcTargetInfo {
4209public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004210 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004211 // FIXME: Support Sparc quad-precision long double?
4212 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4213 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
Jakob Stoklund Olesenfcec0c92013-05-15 03:22:33 +00004214 // This is an LP64 platform.
4215 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen5ac8c4f2013-05-19 17:53:37 +00004216
4217 // OpenBSD uses long long for int64_t and intmax_t.
4218 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
4219 IntMaxType = SignedLongLong;
4220 UIntMaxType = UnsignedLongLong;
4221 } else {
4222 IntMaxType = SignedLong;
4223 UIntMaxType = UnsignedLong;
4224 }
4225 Int64Type = IntMaxType;
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004226 }
4227
4228 virtual void getTargetDefines(const LangOptions &Opts,
4229 MacroBuilder &Builder) const {
4230 SparcTargetInfo::getTargetDefines(Opts, Builder);
4231 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004232 Builder.defineMacro("__arch64__");
4233 // Solaris and its derivative AuroraUX don't need these variants, but the
4234 // BSDs do.
4235 if (getTriple().getOS() != llvm::Triple::Solaris &&
4236 getTriple().getOS() != llvm::Triple::AuroraUX) {
4237 Builder.defineMacro("__sparc64__");
4238 Builder.defineMacro("__sparc_v9__");
4239 Builder.defineMacro("__sparcv9__");
4240 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004241 }
4242};
4243
Gabor Greif26658672008-02-21 16:29:08 +00004244} // end anonymous namespace.
4245
Eli Friedman01b86682008-08-20 07:28:14 +00004246namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004247class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4248public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004249 AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
4250 : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004251 SizeType = UnsignedInt;
4252 PtrDiffType = SignedInt;
4253 }
4254};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004255class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004256public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004257 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
4258 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004259 SizeType = UnsignedInt;
4260 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004261 }
4262};
4263} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004264
Chris Lattner2621fd12008-05-08 05:58:21 +00004265namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004266 class SystemZTargetInfo : public TargetInfo {
4267 static const char *const GCCRegNames[];
4268
4269 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004270 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004271 TLSSupported = true;
4272 IntWidth = IntAlign = 32;
4273 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4274 PointerWidth = PointerAlign = 64;
4275 LongDoubleWidth = 128;
4276 LongDoubleAlign = 64;
4277 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4278 MinGlobalAlign = 16;
4279 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4280 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4281 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4282 }
4283 virtual void getTargetDefines(const LangOptions &Opts,
4284 MacroBuilder &Builder) const {
4285 Builder.defineMacro("__s390__");
4286 Builder.defineMacro("__s390x__");
4287 Builder.defineMacro("__zarch__");
4288 Builder.defineMacro("__LONG_DOUBLE_128__");
4289 }
4290 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4291 unsigned &NumRecords) const {
4292 // FIXME: Implement.
4293 Records = 0;
4294 NumRecords = 0;
4295 }
4296
4297 virtual void getGCCRegNames(const char *const *&Names,
4298 unsigned &NumNames) const;
4299 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4300 unsigned &NumAliases) const {
4301 // No aliases.
4302 Aliases = 0;
4303 NumAliases = 0;
4304 }
4305 virtual bool validateAsmConstraint(const char *&Name,
4306 TargetInfo::ConstraintInfo &info) const;
4307 virtual const char *getClobbers() const {
4308 // FIXME: Is this really right?
4309 return "";
4310 }
4311 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4312 return TargetInfo::SystemZBuiltinVaList;
4313 }
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00004314 virtual bool setCPU(const std::string &Name) {
4315 bool CPUKnown = llvm::StringSwitch<bool>(Name)
4316 .Case("z10", true)
4317 .Case("z196", true)
4318 .Case("zEC12", true)
4319 .Default(false);
4320
4321 // No need to store the CPU yet. There aren't any CPU-specific
4322 // macros to define.
4323 return CPUKnown;
4324 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00004325 };
4326
4327 const char *const SystemZTargetInfo::GCCRegNames[] = {
4328 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4329 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4330 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4331 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4332 };
4333
4334 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4335 unsigned &NumNames) const {
4336 Names = GCCRegNames;
4337 NumNames = llvm::array_lengthof(GCCRegNames);
4338 }
4339
4340 bool SystemZTargetInfo::
4341 validateAsmConstraint(const char *&Name,
4342 TargetInfo::ConstraintInfo &Info) const {
4343 switch (*Name) {
4344 default:
4345 return false;
4346
4347 case 'a': // Address register
4348 case 'd': // Data register (equivalent to 'r')
4349 case 'f': // Floating-point register
4350 Info.setAllowsRegister();
4351 return true;
4352
4353 case 'I': // Unsigned 8-bit constant
4354 case 'J': // Unsigned 12-bit constant
4355 case 'K': // Signed 16-bit constant
4356 case 'L': // Signed 20-bit displacement (on all targets we support)
4357 case 'M': // 0x7fffffff
4358 return true;
4359
4360 case 'Q': // Memory with base and unsigned 12-bit displacement
4361 case 'R': // Likewise, plus an index
4362 case 'S': // Memory with base and signed 20-bit displacement
4363 case 'T': // Likewise, plus an index
4364 Info.setAllowsMemory();
4365 return true;
4366 }
4367 }
4368}
4369
4370namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004371 class MSP430TargetInfo : public TargetInfo {
4372 static const char * const GCCRegNames[];
4373 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004374 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004375 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004376 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004377 IntWidth = 16; IntAlign = 16;
4378 LongWidth = 32; LongLongWidth = 64;
4379 LongAlign = LongLongAlign = 16;
4380 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004381 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004382 SizeType = UnsignedInt;
Anton Korobeynikov18a295d2013-07-01 19:42:40 +00004383 IntMaxType = SignedLongLong;
4384 UIntMaxType = UnsignedLongLong;
4385 IntPtrType = SignedInt;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004386 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004387 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004388 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004389 }
4390 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004391 MacroBuilder &Builder) const {
4392 Builder.defineMacro("MSP430");
4393 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004394 // FIXME: defines for different 'flavours' of MCU
4395 }
4396 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4397 unsigned &NumRecords) const {
4398 // FIXME: Implement.
4399 Records = 0;
4400 NumRecords = 0;
4401 }
Douglas Gregore727d212012-01-30 06:38:25 +00004402 virtual bool hasFeature(StringRef Feature) const {
4403 return Feature == "msp430";
4404 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004405 virtual void getGCCRegNames(const char * const *&Names,
4406 unsigned &NumNames) const;
4407 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4408 unsigned &NumAliases) const {
4409 // No aliases.
4410 Aliases = 0;
4411 NumAliases = 0;
4412 }
4413 virtual bool validateAsmConstraint(const char *&Name,
4414 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004415 // No target constraints for now.
4416 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004417 }
4418 virtual const char *getClobbers() const {
4419 // FIXME: Is this really right?
4420 return "";
4421 }
Meador Ingec5613b22012-06-16 03:34:49 +00004422 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004423 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004424 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004425 }
4426 };
4427
4428 const char * const MSP430TargetInfo::GCCRegNames[] = {
4429 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4430 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4431 };
4432
4433 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4434 unsigned &NumNames) const {
4435 Names = GCCRegNames;
4436 NumNames = llvm::array_lengthof(GCCRegNames);
4437 }
4438}
4439
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004440namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004441
Mike Stump1eb44332009-09-09 15:08:12 +00004442 // LLVM and Clang cannot be used directly to output native binaries for
4443 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004444 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004445 //
4446 // TCE uses the llvm bitcode as input and uses it for generating customized
4447 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004448 // publicly available in http://tce.cs.tut.fi
4449
Eli Friedman209f5bb2011-10-07 19:51:42 +00004450 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4451 3, // opencl_global
4452 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004453 5, // opencl_constant
4454 0, // cuda_device
4455 0, // cuda_constant
4456 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004457 };
4458
Eli Friedmanb63decf2009-08-19 20:47:07 +00004459 class TCETargetInfo : public TargetInfo{
4460 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004461 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004462 TLSSupported = false;
4463 IntWidth = 32;
4464 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004465 PointerWidth = 32;
4466 IntAlign = 32;
4467 LongAlign = LongLongAlign = 32;
4468 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004469 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004470 SizeType = UnsignedInt;
4471 IntMaxType = SignedLong;
4472 UIntMaxType = UnsignedLong;
4473 IntPtrType = SignedInt;
4474 PtrDiffType = SignedInt;
4475 FloatWidth = 32;
4476 FloatAlign = 32;
4477 DoubleWidth = 32;
4478 DoubleAlign = 32;
4479 LongDoubleWidth = 32;
4480 LongDoubleAlign = 32;
4481 FloatFormat = &llvm::APFloat::IEEEsingle;
4482 DoubleFormat = &llvm::APFloat::IEEEsingle;
4483 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004484 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4485 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004486 "f32:32:32-f64:32:32-v64:32:32-"
4487 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004488 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004489 }
4490
4491 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004492 MacroBuilder &Builder) const {
4493 DefineStd(Builder, "tce", Opts);
4494 Builder.defineMacro("__TCE__");
4495 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004496 }
Douglas Gregore727d212012-01-30 06:38:25 +00004497 virtual bool hasFeature(StringRef Feature) const {
4498 return Feature == "tce";
4499 }
4500
Eli Friedmanb63decf2009-08-19 20:47:07 +00004501 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4502 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004503 virtual const char *getClobbers() const {
4504 return "";
4505 }
Meador Ingec5613b22012-06-16 03:34:49 +00004506 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4507 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004508 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004509 virtual void getGCCRegNames(const char * const *&Names,
4510 unsigned &NumNames) const {}
4511 virtual bool validateAsmConstraint(const char *&Name,
4512 TargetInfo::ConstraintInfo &info) const {
4513 return true;
4514 }
4515 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4516 unsigned &NumAliases) const {}
4517 };
4518}
4519
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004520namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004521class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004522 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004523 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004524 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004525 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004526 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004527 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004528 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004529 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004530 enum DspRevEnum {
4531 NoDSP, DSP1, DSP2
4532 } DspRev;
Jack Carterc613b672013-08-12 17:20:29 +00004533 bool HasMSA;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004534
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004535protected:
4536 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004537
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004538public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004539 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
4540 const std::string &CPUStr)
4541 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Jack Carterc613b672013-08-12 17:20:29 +00004542 IsSingleFloat(false), FloatABI(HardFloat), DspRev(NoDSP),
4543 HasMSA(false), ABI(ABIStr) {}
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004544
Eric Christophered734732010-03-02 02:41:08 +00004545 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004546 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004547 virtual bool setCPU(const std::string &Name) {
4548 CPU = Name;
4549 return true;
4550 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004551 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004552 Features[ABI] = true;
4553 Features[CPU] = true;
4554 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004555
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004556 virtual void getTargetDefines(const LangOptions &Opts,
4557 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004558 DefineStd(Builder, "mips", Opts);
4559 Builder.defineMacro("_mips");
4560 Builder.defineMacro("__REGISTER_PREFIX__", "");
4561
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004562 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004563 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004564 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004565 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004566 case SoftFloat:
4567 Builder.defineMacro("__mips_soft_float", Twine(1));
4568 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004569 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004570
Simon Atanasyand96e3152013-04-14 14:07:30 +00004571 if (IsSingleFloat)
4572 Builder.defineMacro("__mips_single_float", Twine(1));
4573
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004574 if (IsMips16)
4575 Builder.defineMacro("__mips16", Twine(1));
4576
Simon Atanasyan321ae792013-04-14 14:07:51 +00004577 if (IsMicromips)
4578 Builder.defineMacro("__mips_micromips", Twine(1));
4579
Simon Atanasyana1b62272012-07-05 20:16:22 +00004580 switch (DspRev) {
4581 default:
4582 break;
4583 case DSP1:
4584 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4585 Builder.defineMacro("__mips_dsp", Twine(1));
4586 break;
4587 case DSP2:
4588 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4589 Builder.defineMacro("__mips_dspr2", Twine(1));
4590 Builder.defineMacro("__mips_dsp", Twine(1));
4591 break;
4592 }
4593
Jack Carterc613b672013-08-12 17:20:29 +00004594 if (HasMSA)
4595 Builder.defineMacro("__mips_msa", Twine(1));
4596
Simon Atanasyan90913892012-04-05 19:28:31 +00004597 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4598 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4599 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004600
4601 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4602 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004603 }
4604
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004605 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4606 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004607 Records = BuiltinInfo;
4608 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004609 }
Douglas Gregore727d212012-01-30 06:38:25 +00004610 virtual bool hasFeature(StringRef Feature) const {
4611 return Feature == "mips";
4612 }
Meador Ingec5613b22012-06-16 03:34:49 +00004613 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4614 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004615 }
4616 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004617 unsigned &NumNames) const {
4618 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004619 // CPU register names
4620 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004621 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4622 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4623 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004624 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4625 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004626 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4627 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4628 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4629 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004630 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004631 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4632 "$fcc5","$fcc6","$fcc7"
4633 };
4634 Names = GCCRegNames;
4635 NumNames = llvm::array_lengthof(GCCRegNames);
4636 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004637 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004638 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004639 virtual bool validateAsmConstraint(const char *&Name,
4640 TargetInfo::ConstraintInfo &Info) const {
4641 switch (*Name) {
4642 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004643 return false;
4644
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004645 case 'r': // CPU registers.
4646 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4647 case 'y': // Equivalent to "r", backwards compatibility only.
4648 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004649 case 'c': // $25 for indirect jumps
4650 case 'l': // lo register
4651 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004652 Info.setAllowsRegister();
4653 return true;
Jack Carter97102302013-03-05 19:10:54 +00004654 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004655 Info.setAllowsMemory();
4656 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004657 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004658 }
4659
4660 virtual const char *getClobbers() const {
4661 // FIXME: Implement!
4662 return "";
4663 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004664
4665 virtual bool setFeatureEnabled(llvm::StringMap<bool> &Features,
4666 StringRef Name,
4667 bool Enabled) const {
Simon Atanasyan8b2a5d22012-04-18 12:00:11 +00004668 if (Name == "soft-float" || Name == "single-float" ||
4669 Name == "o32" || Name == "n32" || Name == "n64" || Name == "eabi" ||
4670 Name == "mips32" || Name == "mips32r2" ||
Simon Atanasyan0b273ef2012-07-05 14:19:39 +00004671 Name == "mips64" || Name == "mips64r2" ||
Simon Atanasyan321ae792013-04-14 14:07:51 +00004672 Name == "mips16" || Name == "micromips" ||
Jack Carterc613b672013-08-12 17:20:29 +00004673 Name == "dsp" || Name == "dspr2" ||
4674 Name == "msa") {
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004675 Features[Name] = Enabled;
4676 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004677 } else if (Name == "32") {
4678 Features["o32"] = Enabled;
4679 return true;
4680 } else if (Name == "64") {
4681 Features["n64"] = Enabled;
4682 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004683 }
4684 return false;
4685 }
4686
4687 virtual void HandleTargetFeatures(std::vector<std::string> &Features) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004688 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004689 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004690 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004691 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004692 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004693
4694 for (std::vector<std::string>::iterator it = Features.begin(),
4695 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004696 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004697 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004698 else if (*it == "+soft-float")
4699 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004700 else if (*it == "+mips16")
4701 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004702 else if (*it == "+micromips")
4703 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004704 else if (*it == "+dsp")
4705 DspRev = std::max(DspRev, DSP1);
4706 else if (*it == "+dspr2")
4707 DspRev = std::max(DspRev, DSP2);
Jack Carterc613b672013-08-12 17:20:29 +00004708 else if (*it == "+msa")
4709 HasMSA = true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004710 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004711
4712 // Remove front-end specific option.
4713 std::vector<std::string>::iterator it =
4714 std::find(Features.begin(), Features.end(), "+soft-float");
4715 if (it != Features.end())
4716 Features.erase(it);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004717 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004718
4719 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4720 if (RegNo == 0) return 4;
4721 if (RegNo == 1) return 5;
4722 return -1;
4723 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004724};
4725
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004726const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4727#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4728#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4729 ALL_LANGUAGES },
4730#include "clang/Basic/BuiltinsMips.def"
4731};
4732
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004733class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004734public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004735 Mips32TargetInfoBase(const llvm::Triple &Triple)
4736 : MipsTargetInfoBase(Triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004737 SizeType = UnsignedInt;
4738 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004739 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004740 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004741 virtual bool setABI(const std::string &Name) {
4742 if ((Name == "o32") || (Name == "eabi")) {
4743 ABI = Name;
4744 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004745 } else if (Name == "32") {
4746 ABI = "o32";
4747 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004748 } else
4749 return false;
4750 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004751 virtual void getTargetDefines(const LangOptions &Opts,
4752 MacroBuilder &Builder) const {
4753 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004754
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004755 if (ABI == "o32") {
4756 Builder.defineMacro("__mips_o32");
4757 Builder.defineMacro("_ABIO32", "1");
4758 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4759 }
4760 else if (ABI == "eabi")
4761 Builder.defineMacro("__mips_eabi");
4762 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004763 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004764 }
4765 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4766 unsigned &NumAliases) const {
4767 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4768 { { "at" }, "$1" },
4769 { { "v0" }, "$2" },
4770 { { "v1" }, "$3" },
4771 { { "a0" }, "$4" },
4772 { { "a1" }, "$5" },
4773 { { "a2" }, "$6" },
4774 { { "a3" }, "$7" },
4775 { { "t0" }, "$8" },
4776 { { "t1" }, "$9" },
4777 { { "t2" }, "$10" },
4778 { { "t3" }, "$11" },
4779 { { "t4" }, "$12" },
4780 { { "t5" }, "$13" },
4781 { { "t6" }, "$14" },
4782 { { "t7" }, "$15" },
4783 { { "s0" }, "$16" },
4784 { { "s1" }, "$17" },
4785 { { "s2" }, "$18" },
4786 { { "s3" }, "$19" },
4787 { { "s4" }, "$20" },
4788 { { "s5" }, "$21" },
4789 { { "s6" }, "$22" },
4790 { { "s7" }, "$23" },
4791 { { "t8" }, "$24" },
4792 { { "t9" }, "$25" },
4793 { { "k0" }, "$26" },
4794 { { "k1" }, "$27" },
4795 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004796 { { "sp","$sp" }, "$29" },
4797 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004798 { { "ra" }, "$31" }
4799 };
4800 Aliases = GCCRegAliases;
4801 NumAliases = llvm::array_lengthof(GCCRegAliases);
4802 }
4803};
4804
4805class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4806public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004807 Mips32EBTargetInfo(const llvm::Triple &Triple)
4808 : Mips32TargetInfoBase(Triple) {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004809 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 +00004810 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004811 }
4812 virtual void getTargetDefines(const LangOptions &Opts,
4813 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004814 DefineStd(Builder, "MIPSEB", Opts);
4815 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004816 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004817 }
4818};
4819
4820class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4821public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004822 Mips32ELTargetInfo(const llvm::Triple &Triple)
4823 : Mips32TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004824 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004825 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 +00004826 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004827 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004828 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004829 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004830 DefineStd(Builder, "MIPSEL", Opts);
4831 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004832 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004833 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004834};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004835
4836class Mips64TargetInfoBase : public MipsTargetInfoBase {
4837 virtual void SetDescriptionString(const std::string &Name) = 0;
4838public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004839 Mips64TargetInfoBase(const llvm::Triple &Triple)
4840 : MipsTargetInfoBase(Triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004841 LongWidth = LongAlign = 64;
4842 PointerWidth = PointerAlign = 64;
4843 LongDoubleWidth = LongDoubleAlign = 128;
4844 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004845 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4846 LongDoubleWidth = LongDoubleAlign = 64;
4847 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4848 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004849 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004850 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004851 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004852 virtual bool setABI(const std::string &Name) {
4853 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004854 if (Name == "n32") {
4855 LongWidth = LongAlign = 32;
4856 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004857 ABI = Name;
4858 return true;
4859 } else if (Name == "n64") {
4860 ABI = Name;
4861 return true;
4862 } else if (Name == "64") {
4863 ABI = "n64";
4864 return true;
4865 } else
4866 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004867 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004868 virtual void getTargetDefines(const LangOptions &Opts,
4869 MacroBuilder &Builder) const {
4870 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004871
Simon Atanasyan600a5132012-08-29 20:50:11 +00004872 Builder.defineMacro("__mips64");
4873 Builder.defineMacro("__mips64__");
4874
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004875 if (ABI == "n32") {
4876 Builder.defineMacro("__mips_n32");
4877 Builder.defineMacro("_ABIN32", "2");
4878 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4879 }
4880 else if (ABI == "n64") {
4881 Builder.defineMacro("__mips_n64");
4882 Builder.defineMacro("_ABI64", "3");
4883 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4884 }
4885 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004886 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004887 }
4888 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4889 unsigned &NumAliases) const {
4890 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4891 { { "at" }, "$1" },
4892 { { "v0" }, "$2" },
4893 { { "v1" }, "$3" },
4894 { { "a0" }, "$4" },
4895 { { "a1" }, "$5" },
4896 { { "a2" }, "$6" },
4897 { { "a3" }, "$7" },
4898 { { "a4" }, "$8" },
4899 { { "a5" }, "$9" },
4900 { { "a6" }, "$10" },
4901 { { "a7" }, "$11" },
4902 { { "t0" }, "$12" },
4903 { { "t1" }, "$13" },
4904 { { "t2" }, "$14" },
4905 { { "t3" }, "$15" },
4906 { { "s0" }, "$16" },
4907 { { "s1" }, "$17" },
4908 { { "s2" }, "$18" },
4909 { { "s3" }, "$19" },
4910 { { "s4" }, "$20" },
4911 { { "s5" }, "$21" },
4912 { { "s6" }, "$22" },
4913 { { "s7" }, "$23" },
4914 { { "t8" }, "$24" },
4915 { { "t9" }, "$25" },
4916 { { "k0" }, "$26" },
4917 { { "k1" }, "$27" },
4918 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004919 { { "sp","$sp" }, "$29" },
4920 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004921 { { "ra" }, "$31" }
4922 };
4923 Aliases = GCCRegAliases;
4924 NumAliases = llvm::array_lengthof(GCCRegAliases);
4925 }
4926};
4927
4928class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4929 virtual void SetDescriptionString(const std::string &Name) {
4930 // Change DescriptionString only if ABI is n32.
4931 if (Name == "n32")
4932 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 +00004933 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004934 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004935 }
4936public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004937 Mips64EBTargetInfo(const llvm::Triple &Triple)
4938 : Mips64TargetInfoBase(Triple) {
4939 // Default ABI is n64.
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004940 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 +00004941 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004942 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004943 }
4944 virtual void getTargetDefines(const LangOptions &Opts,
4945 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004946 DefineStd(Builder, "MIPSEB", Opts);
4947 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004948 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004949 }
4950};
4951
4952class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4953 virtual void SetDescriptionString(const std::string &Name) {
4954 // Change DescriptionString only if ABI is n32.
4955 if (Name == "n32")
4956 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 +00004957 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004958 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004959 }
4960public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004961 Mips64ELTargetInfo(const llvm::Triple &Triple)
4962 : Mips64TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004963 // Default ABI is n64.
4964 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004965 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 +00004966 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004967 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004968 }
4969 virtual void getTargetDefines(const LangOptions &Opts,
4970 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004971 DefineStd(Builder, "MIPSEL", Opts);
4972 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004973 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004974 }
4975};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004976} // end anonymous namespace.
4977
Ivan Krasinef05abd2011-08-24 20:22:22 +00004978namespace {
4979class PNaClTargetInfo : public TargetInfo {
4980public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004981 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004982 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00004983 this->UserLabelPrefix = "";
4984 this->LongAlign = 32;
4985 this->LongWidth = 32;
4986 this->PointerAlign = 32;
4987 this->PointerWidth = 32;
4988 this->IntMaxType = TargetInfo::SignedLongLong;
4989 this->UIntMaxType = TargetInfo::UnsignedLongLong;
4990 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004991 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004992 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00004993 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00004994 this->SizeType = TargetInfo::UnsignedInt;
4995 this->PtrDiffType = TargetInfo::SignedInt;
4996 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00004997 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00004998 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
4999 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
5000 }
5001
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005002 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00005003 }
5004 virtual void getArchDefines(const LangOptions &Opts,
5005 MacroBuilder &Builder) const {
5006 Builder.defineMacro("__le32__");
5007 Builder.defineMacro("__pnacl__");
5008 }
5009 virtual void getTargetDefines(const LangOptions &Opts,
5010 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00005011 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00005012 getArchDefines(Opts, Builder);
5013 }
Douglas Gregore727d212012-01-30 06:38:25 +00005014 virtual bool hasFeature(StringRef Feature) const {
5015 return Feature == "pnacl";
5016 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00005017 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5018 unsigned &NumRecords) const {
5019 }
Meador Ingec5613b22012-06-16 03:34:49 +00005020 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5021 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005022 }
5023 virtual void getGCCRegNames(const char * const *&Names,
5024 unsigned &NumNames) const;
5025 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5026 unsigned &NumAliases) const;
5027 virtual bool validateAsmConstraint(const char *&Name,
5028 TargetInfo::ConstraintInfo &Info) const {
5029 return false;
5030 }
5031
5032 virtual const char *getClobbers() const {
5033 return "";
5034 }
5035};
5036
5037void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
5038 unsigned &NumNames) const {
5039 Names = NULL;
5040 NumNames = 0;
5041}
5042
5043void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5044 unsigned &NumAliases) const {
5045 Aliases = NULL;
5046 NumAliases = 0;
5047}
5048} // end anonymous namespace.
5049
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005050namespace {
5051 static const unsigned SPIRAddrSpaceMap[] = {
5052 1, // opencl_global
5053 3, // opencl_local
5054 2, // opencl_constant
5055 0, // cuda_device
5056 0, // cuda_constant
5057 0 // cuda_shared
5058 };
5059 class SPIRTargetInfo : public TargetInfo {
5060 static const char * const GCCRegNames[];
5061 static const Builtin::Info BuiltinInfo[];
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00005062 std::vector<StringRef> AvailableFeatures;
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005063 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005064 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005065 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5066 "SPIR target must use unknown OS");
5067 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5068 "SPIR target must use unknown environment type");
5069 BigEndian = false;
5070 TLSSupported = false;
5071 LongWidth = LongAlign = 64;
5072 AddrSpaceMap = &SPIRAddrSpaceMap;
5073 // Define available target features
5074 // These must be defined in sorted order!
5075 NoAsmVariants = true;
5076 }
5077 virtual void getTargetDefines(const LangOptions &Opts,
5078 MacroBuilder &Builder) const {
5079 DefineStd(Builder, "SPIR", Opts);
5080 }
5081 virtual bool hasFeature(StringRef Feature) const {
5082 return Feature == "spir";
5083 }
5084
5085 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5086 unsigned &NumRecords) const {}
5087 virtual const char *getClobbers() const {
5088 return "";
5089 }
5090 virtual void getGCCRegNames(const char * const *&Names,
5091 unsigned &NumNames) const {}
5092 virtual bool validateAsmConstraint(const char *&Name,
5093 TargetInfo::ConstraintInfo &info) const {
5094 return true;
5095 }
5096 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5097 unsigned &NumAliases) const {}
5098 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5099 return TargetInfo::VoidPtrBuiltinVaList;
5100 }
5101 };
5102
5103
5104 class SPIR32TargetInfo : public SPIRTargetInfo {
5105 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005106 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005107 PointerWidth = PointerAlign = 32;
5108 SizeType = TargetInfo::UnsignedInt;
5109 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5110 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005111 = "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 +00005112 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5113 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5114 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005115 }
5116 virtual void getTargetDefines(const LangOptions &Opts,
5117 MacroBuilder &Builder) const {
5118 DefineStd(Builder, "SPIR32", Opts);
5119 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005120 };
5121
5122 class SPIR64TargetInfo : public SPIRTargetInfo {
5123 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005124 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005125 PointerWidth = PointerAlign = 64;
5126 SizeType = TargetInfo::UnsignedLong;
5127 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5128 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005129 = "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 +00005130 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5131 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5132 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005133 }
5134 virtual void getTargetDefines(const LangOptions &Opts,
5135 MacroBuilder &Builder) const {
5136 DefineStd(Builder, "SPIR64", Opts);
5137 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005138 };
5139}
5140
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005141namespace {
5142class XCoreTargetInfo : public TargetInfo {
5143 static const Builtin::Info BuiltinInfo[];
5144public:
5145 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5146 BigEndian = false;
5147 NoAsmVariants = true;
5148 LongLongAlign = 32;
5149 SuitableAlign = 32;
5150 DoubleAlign = LongDoubleAlign = 32;
5151 UseZeroLengthBitfieldAlignment = true;
5152 DescriptionString = "e-p:32:32:32-a0:0:32-n32"
5153 "-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32"
5154 "-f16:16:32-f32:32:32-f64:32:32";
5155 }
5156 virtual void getTargetDefines(const LangOptions &Opts,
5157 MacroBuilder &Builder) const {
5158 Builder.defineMacro("__XS1B__");
5159 }
5160 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5161 unsigned &NumRecords) const {
5162 Records = BuiltinInfo;
5163 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
5164 }
5165 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5166 return TargetInfo::VoidPtrBuiltinVaList;
5167 }
5168 virtual const char *getClobbers() const {
5169 return "";
5170 }
5171 virtual void getGCCRegNames(const char * const *&Names,
5172 unsigned &NumNames) const {
5173 static const char * const GCCRegNames[] = {
5174 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5175 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
5176 };
5177 Names = GCCRegNames;
5178 NumNames = llvm::array_lengthof(GCCRegNames);
5179 }
5180 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5181 unsigned &NumAliases) const {
5182 Aliases = NULL;
5183 NumAliases = 0;
5184 }
5185 virtual bool validateAsmConstraint(const char *&Name,
5186 TargetInfo::ConstraintInfo &Info) const {
5187 return false;
5188 }
5189};
5190
5191const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
5192#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5193#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5194 ALL_LANGUAGES },
5195#include "clang/Basic/BuiltinsXCore.def"
5196};
5197} // end anonymous namespace.
5198
Ivan Krasinef05abd2011-08-24 20:22:22 +00005199
Reid Spencer5f016e22007-07-11 17:01:13 +00005200//===----------------------------------------------------------------------===//
5201// Driver code
5202//===----------------------------------------------------------------------===//
5203
Benjamin Kramer9df08232013-06-29 16:37:14 +00005204static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005205 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005206
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005207 switch (Triple.getArch()) {
5208 default:
5209 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005210
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005211 case llvm::Triple::xcore:
5212 return new XCoreTargetInfo(Triple);
5213
Tony Linthicum96319392011-12-12 21:14:55 +00005214 case llvm::Triple::hexagon:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005215 return new HexagonTargetInfo(Triple);
Tony Linthicum96319392011-12-12 21:14:55 +00005216
Tim Northoverc264e162013-01-31 12:13:10 +00005217 case llvm::Triple::aarch64:
5218 switch (os) {
5219 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005220 return new LinuxTargetInfo<AArch64TargetInfo>(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005221 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005222 return new AArch64TargetInfo(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005223 }
5224
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005225 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005226 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005227 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005228 return new DarwinARMTargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005229
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005230 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005231 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005232 return new LinuxTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005233 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005234 return new FreeBSDTargetInfo<ARMTargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005235 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005236 return new NetBSDTargetInfo<ARMTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005237 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005238 return new OpenBSDTargetInfo<ARMTargetInfo>(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005239 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005240 return new BitrigTargetInfo<ARMTargetInfo>(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005241 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005242 return new RTEMSTargetInfo<ARMTargetInfo>(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005243 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005244 return new NaClTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005245 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005246 return new ARMTargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005247 }
Eli Friedman61538a72008-05-20 14:21:01 +00005248
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005249 case llvm::Triple::msp430:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005250 return new MSP430TargetInfo(Triple);
Eli Friedman61538a72008-05-20 14:21:01 +00005251
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005252 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005253 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005254 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005255 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005256 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005257 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005258 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005259 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005260 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005261 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005262 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005263 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005264 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005265
5266 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005267 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005268 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005269 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005270 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005271 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005272 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005273 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005274 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005275 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005276 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005277 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005278 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005279
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005280 case llvm::Triple::mips64:
5281 switch (os) {
5282 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005283 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005284 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005285 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005286 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005287 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005288 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005289 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005290 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005291 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005292 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005293 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005294 }
5295
5296 case llvm::Triple::mips64el:
5297 switch (os) {
5298 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005299 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005300 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005301 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005302 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005303 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005304 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005305 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005306 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005307 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005308 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005309 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005310 }
5311
Ivan Krasinef05abd2011-08-24 20:22:22 +00005312 case llvm::Triple::le32:
5313 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005314 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005315 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005316 default:
5317 return NULL;
5318 }
5319
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005320 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005321 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005322 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005323 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005324 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005325 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005326 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005327 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005328 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005329 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005330 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005331 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005332 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005333 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005334 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005335 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005336 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005337
5338 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005339 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005340 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005341 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005342 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005343 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005344 case llvm::Triple::Lv2:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005345 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005346 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005347 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005348 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005349 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005350 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005351 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005352 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005353
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00005354 case llvm::Triple::ppc64le:
5355 switch (os) {
5356 case llvm::Triple::Linux:
5357 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
5358 default:
5359 return new PPC64TargetInfo(Triple);
5360 }
5361
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005362 case llvm::Triple::nvptx:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005363 return new NVPTX32TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005364 case llvm::Triple::nvptx64:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005365 return new NVPTX64TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005366
Eli Friedman6505a292012-10-12 23:32:00 +00005367 case llvm::Triple::r600:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005368 return new R600TargetInfo(Triple);
Eli Friedman6505a292012-10-12 23:32:00 +00005369
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005370 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005371 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005372 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005373 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005374 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005375 return new AuroraUXSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005376 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005377 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005378 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005379 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005380 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005381 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005382 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005383 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005384 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005385 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005386 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005387
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005388 case llvm::Triple::sparcv9:
5389 switch (os) {
5390 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005391 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005392 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005393 return new AuroraUXTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005394 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005395 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005396 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005397 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005398 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005399 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005400 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005401 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005402 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005403 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005404 }
5405
Ulrich Weigandb8409212013-05-06 16:26:41 +00005406 case llvm::Triple::systemz:
5407 switch (os) {
5408 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005409 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005410 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005411 return new SystemZTargetInfo(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005412 }
5413
Eli Friedmanb63decf2009-08-19 20:47:07 +00005414 case llvm::Triple::tce:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005415 return new TCETargetInfo(Triple);
Eli Friedmanb63decf2009-08-19 20:47:07 +00005416
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005417 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005418 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005419 return new DarwinI386TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005420
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005421 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005422 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005423 return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005424 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005425 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005426 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005427 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005428 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005429 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005430 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005431 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005432 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005433 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005434 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005435 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner38e317d2010-07-07 16:01:42 +00005436 case llvm::Triple::Minix:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005437 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005438 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005439 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005440 case llvm::Triple::Cygwin:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005441 return new CygwinX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005442 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005443 return new MinGWX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005444 case llvm::Triple::Win32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005445 return new VisualStudioWindowsX86_32TargetInfo(Triple);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005446 case llvm::Triple::Haiku:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005447 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005448 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005449 return new RTEMSX86_32TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005450 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005451 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005452 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005453 return new X86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005454 }
5455
5456 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005457 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
Benjamin Kramer9df08232013-06-29 16:37:14 +00005458 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005459
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005460 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005461 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005462 return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005463 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005464 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005465 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005466 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005467 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005468 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005469 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005470 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005471 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005472 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005473 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005474 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005475 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005476 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005477 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005478 return new MinGWX86_64TargetInfo(Triple);
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005479 case llvm::Triple::Win32: // This is what Triple.h supports now.
Benjamin Kramer9df08232013-06-29 16:37:14 +00005480 return new VisualStudioWindowsX86_64TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005481 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005482 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005483 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005484 return new X86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005485 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005486
5487 case llvm::Triple::spir: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005488 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005489 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005490 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005491 return new SPIR32TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005492 }
5493 case llvm::Triple::spir64: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005494 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005495 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005496 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005497 return new SPIR64TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005498 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005499 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005500}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005501
5502/// CreateTargetInfo - Return the target info object for the specified target
5503/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005504TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005505 TargetOptions *Opts) {
5506 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005507
5508 // Construct the target
Benjamin Kramer9df08232013-06-29 16:37:14 +00005509 OwningPtr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005510 if (!Target) {
5511 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5512 return 0;
5513 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005514 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005515
Daniel Dunbareac7c532009-12-18 18:42:37 +00005516 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005517 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5518 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005519 return 0;
5520 }
5521
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005522 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005523 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5524 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005525 return 0;
5526 }
5527
Charles Davis98b7c5c2010-06-11 01:06:47 +00005528 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005529 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5530 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005531 return 0;
5532 }
5533
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005534 // Compute the default target features, we need the target to handle this
5535 // because features may have dependencies on one another.
5536 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005537 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005538
5539 // Apply the user specified deltas.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005540 // First the enables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005541 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005542 it = Opts->FeaturesAsWritten.begin(),
5543 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005544 it != ie; ++it) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005545 const char *Name = it->c_str();
5546
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005547 if (Name[0] != '+')
5548 continue;
5549
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005550 // Apply the feature via the target.
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005551 if (!Target->setFeatureEnabled(Features, Name + 1, true)) {
5552 Diags.Report(diag::err_target_invalid_feature) << Name;
5553 return 0;
5554 }
5555 }
5556
5557 // Then the disables.
Douglas Gregor57016dd2012-10-16 23:40:58 +00005558 for (std::vector<std::string>::const_iterator
Douglas Gregor49a87542012-11-16 04:24:59 +00005559 it = Opts->FeaturesAsWritten.begin(),
5560 ie = Opts->FeaturesAsWritten.end();
Douglas Gregor57016dd2012-10-16 23:40:58 +00005561 it != ie; ++it) {
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005562 const char *Name = it->c_str();
5563
5564 if (Name[0] == '+')
5565 continue;
5566
5567 // Apply the feature via the target.
5568 if (Name[0] != '-' ||
5569 !Target->setFeatureEnabled(Features, Name + 1, false)) {
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005570 Diags.Report(diag::err_target_invalid_feature) << Name;
5571 return 0;
5572 }
5573 }
5574
5575 // Add the features to the compile options.
5576 //
5577 // FIXME: If we are completely confident that we have the right set, we only
5578 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005579 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005580 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5581 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005582 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
5583 Target->HandleTargetFeatures(Opts->Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005584
5585 return Target.take();
5586}