blob: f588970a872b7907868b5b2f00361c9b08ab352b [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
Douglas Gregore727d212012-01-30 06:38:25 +0000730 virtual bool hasFeature(StringRef Feature) const;
731
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000732 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +0000733 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000734 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +0000735 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000736 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +0000737 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +0000738 switch (*Name) {
Anders Carlssond04c6e22007-11-27 04:11:28 +0000739 default: return false;
740 case 'O': // Zero
John Thompson8e6065a2010-06-24 22:44:13 +0000741 break;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000742 case 'b': // Base register
743 case 'f': // Floating point register
Chris Lattner44def072009-04-26 07:16:29 +0000744 Info.setAllowsRegister();
John Thompson8e6065a2010-06-24 22:44:13 +0000745 break;
746 // FIXME: The following are added to allow parsing.
747 // I just took a guess at what the actions should be.
748 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer20249a12010-10-21 03:16:25 +0000749 case 'd': // Floating point register (containing 64-bit value)
John Thompson8e6065a2010-06-24 22:44:13 +0000750 case 'v': // Altivec vector register
751 Info.setAllowsRegister();
752 break;
753 case 'w':
754 switch (Name[1]) {
Michael J. Spencer20249a12010-10-21 03:16:25 +0000755 case 'd':// VSX vector register to hold vector double data
756 case 'f':// VSX vector register to hold vector float data
757 case 's':// VSX vector register to hold scalar float data
758 case 'a':// Any VSX register
John Thompson8e6065a2010-06-24 22:44:13 +0000759 break;
760 default:
761 return false;
762 }
763 Info.setAllowsRegister();
764 Name++; // Skip over 'w'.
765 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000766 case 'h': // `MQ', `CTR', or `LINK' register
767 case 'q': // `MQ' register
768 case 'c': // `CTR' register
769 case 'l': // `LINK' register
770 case 'x': // `CR' register (condition register) number 0
771 case 'y': // `CR' register (condition register)
772 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson8e6065a2010-06-24 22:44:13 +0000773 Info.setAllowsRegister();
774 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000775 case 'I': // Signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000776 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer20249a12010-10-21 03:16:25 +0000777 // (use `L' instead for SImode constants)
778 case 'K': // Unsigned 16-bit constant
779 case 'L': // Signed 16-bit constant shifted left 16 bits
780 case 'M': // Constant larger than 31
781 case 'N': // Exact power of 2
782 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson8e6065a2010-06-24 22:44:13 +0000783 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000784 // register with one instruction per word
John Thompson8e6065a2010-06-24 22:44:13 +0000785 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer20249a12010-10-21 03:16:25 +0000786 // into a register using three instructions
John Thompson8e6065a2010-06-24 22:44:13 +0000787 break;
788 case 'm': // Memory operand. Note that on PowerPC targets, m can
789 // include addresses that update the base register. It
790 // is therefore only safe to use `m' in an asm statement
791 // if that asm statement accesses the operand exactly once.
792 // The asm statement must also use `%U<opno>' as a
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000793 // placeholder for the "update" flag in the corresponding
Michael J. Spencer20249a12010-10-21 03:16:25 +0000794 // load or store instruction. For example:
John Thompson8e6065a2010-06-24 22:44:13 +0000795 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer20249a12010-10-21 03:16:25 +0000796 // is correct but:
John Thompson8e6065a2010-06-24 22:44:13 +0000797 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
798 // is not. Use es rather than m if you don't want the base
Michael J. Spencer20249a12010-10-21 03:16:25 +0000799 // register to be updated.
800 case 'e':
John Thompson56b6eca2010-06-25 00:02:05 +0000801 if (Name[1] != 's')
802 return false;
Sebastian Redl5005a6c2010-08-17 22:42:34 +0000803 // es: A "stable" memory operand; that is, one which does not
John Thompson8e6065a2010-06-24 22:44:13 +0000804 // include any automodification of the base register. Unlike
805 // `m', this constraint can be used in asm statements that
806 // might access the operand several times, or that might not
John Thompson56b6eca2010-06-25 00:02:05 +0000807 // access it at all.
John Thompson8e6065a2010-06-24 22:44:13 +0000808 Info.setAllowsMemory();
John Thompson56b6eca2010-06-25 00:02:05 +0000809 Name++; // Skip over 'e'.
John Thompson8e6065a2010-06-24 22:44:13 +0000810 break;
811 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer20249a12010-10-21 03:16:25 +0000812 // usually better to use `m' or `es' in asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000813 case 'Z': // Memory operand that is an indexed or indirect from a
814 // register (it is usually better to use `m' or `es' in
Michael J. Spencer20249a12010-10-21 03:16:25 +0000815 // asm statements)
John Thompson8e6065a2010-06-24 22:44:13 +0000816 Info.setAllowsMemory();
817 Info.setAllowsRegister();
818 break;
Michael J. Spencer20249a12010-10-21 03:16:25 +0000819 case 'R': // AIX TOC entry
John Thompson8e6065a2010-06-24 22:44:13 +0000820 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer20249a12010-10-21 03:16:25 +0000821 // register (`p' is preferable for asm statements)
822 case 'S': // Constant suitable as a 64-bit mask operand
823 case 'T': // Constant suitable as a 32-bit mask operand
824 case 'U': // System V Release 4 small data area reference
John Thompson8e6065a2010-06-24 22:44:13 +0000825 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer20249a12010-10-21 03:16:25 +0000826 // instructions
827 case 'W': // Vector constant that does not require memory
828 case 'j': // Vector constant that is all zeros.
John Thompson8e6065a2010-06-24 22:44:13 +0000829 break;
830 // End FIXME.
Anders Carlssond04c6e22007-11-27 04:11:28 +0000831 }
John Thompson8e6065a2010-06-24 22:44:13 +0000832 return true;
Anders Carlssond04c6e22007-11-27 04:11:28 +0000833 }
Eli Friedmane4277982008-08-20 23:11:40 +0000834 virtual const char *getClobbers() const {
835 return "";
Anders Carlssond04c6e22007-11-27 04:11:28 +0000836 }
Adhemerval Zanellab0fc94c2013-01-22 20:02:45 +0000837 int getEHDataRegisterNumber(unsigned RegNo) const {
838 if (RegNo == 0) return 3;
839 if (RegNo == 1) return 4;
840 return -1;
841 }
Eli Friedmane4277982008-08-20 23:11:40 +0000842};
Anders Carlssond04c6e22007-11-27 04:11:28 +0000843
Eli Friedmane4277982008-08-20 23:11:40 +0000844const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +0000845#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +0000846#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +0000847 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +0000848#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmane4277982008-08-20 23:11:40 +0000849};
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000850
851
Chris Lattnerc0f59212009-03-02 22:27:17 +0000852/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
853/// #defines that are not tied to a specific subtarget.
Chris Lattner33328642009-03-20 15:52:06 +0000854void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +0000855 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +0000856 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +0000857 Builder.defineMacro("__ppc__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000858 Builder.defineMacro("__PPC__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000859 Builder.defineMacro("_ARCH_PPC");
Chris Lattnere03ae302010-02-16 18:14:57 +0000860 Builder.defineMacro("__powerpc__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000861 Builder.defineMacro("__POWERPC__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000862 if (PointerWidth == 64) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000863 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnere03ae302010-02-16 18:14:57 +0000864 Builder.defineMacro("__powerpc64__");
Benjamin Kramera9992772010-01-09 17:55:51 +0000865 Builder.defineMacro("__ppc64__");
Chandler Carruthc6fa1152013-06-25 11:13:47 +0000866 Builder.defineMacro("__PPC64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +0000867 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000868
Chris Lattnerc0f59212009-03-02 22:27:17 +0000869 // Target properties.
Bill Schmidtea7fb0c2013-07-26 01:36:11 +0000870 if (getTriple().getArch() == llvm::Triple::ppc64le) {
871 Builder.defineMacro("_LITTLE_ENDIAN");
872 Builder.defineMacro("__LITTLE_ENDIAN__");
873 } else {
874 if (getTriple().getOS() != llvm::Triple::NetBSD &&
875 getTriple().getOS() != llvm::Triple::OpenBSD)
876 Builder.defineMacro("_BIG_ENDIAN");
877 Builder.defineMacro("__BIG_ENDIAN__");
878 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000879
Chris Lattnerc0f59212009-03-02 22:27:17 +0000880 // Subtarget options.
Benjamin Kramera9992772010-01-09 17:55:51 +0000881 Builder.defineMacro("__NATURAL_ALIGNMENT__");
882 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikova7c47172009-05-03 13:42:53 +0000883
Chris Lattnerc0f59212009-03-02 22:27:17 +0000884 // FIXME: Should be controlled by command line option.
Roman Divackyb2f6f472013-07-03 19:45:54 +0000885 if (LongDoubleWidth == 128)
886 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer20249a12010-10-21 03:16:25 +0000887
John Thompson3f6918a2009-11-19 17:18:50 +0000888 if (Opts.AltiVec) {
Benjamin Kramera9992772010-01-09 17:55:51 +0000889 Builder.defineMacro("__VEC__", "10206");
890 Builder.defineMacro("__ALTIVEC__");
John Thompson3f6918a2009-11-19 17:18:50 +0000891 }
Hal Finkel02a84272012-06-11 22:35:19 +0000892
893 // CPU identification.
Hal Finkel39d5fa12012-07-03 16:51:04 +0000894 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
895 .Case("440", ArchDefineName)
896 .Case("450", ArchDefineName | ArchDefine440)
897 .Case("601", ArchDefineName)
898 .Case("602", ArchDefineName | ArchDefinePpcgr)
899 .Case("603", ArchDefineName | ArchDefinePpcgr)
900 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
901 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
902 .Case("604", ArchDefineName | ArchDefinePpcgr)
903 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
904 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt2821e182013-02-01 20:23:10 +0000905 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000906 .Case("7400", ArchDefineName | ArchDefinePpcgr)
907 .Case("7450", ArchDefineName | ArchDefinePpcgr)
908 .Case("750", ArchDefineName | ArchDefinePpcgr)
909 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
910 | ArchDefinePpcsq)
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000911 .Case("a2", ArchDefineA2)
912 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt2821e182013-02-01 20:23:10 +0000913 .Case("pwr3", ArchDefinePpcgr)
914 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
915 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
916 | ArchDefinePpcsq)
917 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
918 | ArchDefinePpcgr | ArchDefinePpcsq)
919 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
920 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
921 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
922 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
923 | ArchDefinePpcsq)
924 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
925 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
926 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
927 .Case("power3", ArchDefinePpcgr)
928 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
929 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
930 | ArchDefinePpcsq)
931 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
932 | ArchDefinePpcgr | ArchDefinePpcsq)
933 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
934 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
935 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
936 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
937 | ArchDefinePpcsq)
938 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
939 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
940 | ArchDefinePwr6 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000941 .Default(ArchDefineNone);
942
943 if (defs & ArchDefineName)
944 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
945 if (defs & ArchDefinePpcgr)
946 Builder.defineMacro("_ARCH_PPCGR");
947 if (defs & ArchDefinePpcsq)
948 Builder.defineMacro("_ARCH_PPCSQ");
949 if (defs & ArchDefine440)
Hal Finkel02a84272012-06-11 22:35:19 +0000950 Builder.defineMacro("_ARCH_440");
Hal Finkel39d5fa12012-07-03 16:51:04 +0000951 if (defs & ArchDefine603)
952 Builder.defineMacro("_ARCH_603");
953 if (defs & ArchDefine604)
954 Builder.defineMacro("_ARCH_604");
Bill Schmidt2821e182013-02-01 20:23:10 +0000955 if (defs & ArchDefinePwr4)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000956 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt2821e182013-02-01 20:23:10 +0000957 if (defs & ArchDefinePwr5)
Hal Finkel39d5fa12012-07-03 16:51:04 +0000958 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt2821e182013-02-01 20:23:10 +0000959 if (defs & ArchDefinePwr5x)
960 Builder.defineMacro("_ARCH_PWR5X");
961 if (defs & ArchDefinePwr6)
Hal Finkel02a84272012-06-11 22:35:19 +0000962 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt2821e182013-02-01 20:23:10 +0000963 if (defs & ArchDefinePwr6x)
964 Builder.defineMacro("_ARCH_PWR6X");
965 if (defs & ArchDefinePwr7)
966 Builder.defineMacro("_ARCH_PWR7");
Hal Finkel5ccd3d02013-02-01 05:53:33 +0000967 if (defs & ArchDefineA2)
968 Builder.defineMacro("_ARCH_A2");
969 if (defs & ArchDefineA2q) {
970 Builder.defineMacro("_ARCH_A2Q");
971 Builder.defineMacro("_ARCH_QP");
972 }
973
974 if (getTriple().getVendor() == llvm::Triple::BGQ) {
975 Builder.defineMacro("__bg__");
976 Builder.defineMacro("__THW_BLUEGENE__");
977 Builder.defineMacro("__bgq__");
978 Builder.defineMacro("__TOS_BGQ__");
979 }
Bill Schmidt2821e182013-02-01 20:23:10 +0000980
981 // FIXME: The following are not yet generated here by Clang, but are
982 // generated by GCC:
983 //
984 // _SOFT_FLOAT_
985 // __RECIP_PRECISION__
986 // __APPLE_ALTIVEC__
987 // __VSX__
988 // __RECIP__
989 // __RECIPF__
990 // __RSQRTE__
991 // __RSQRTEF__
992 // _SOFT_DOUBLE_
993 // __NO_LWSYNC__
994 // __HAVE_BSWAP__
995 // __LONGDOUBLE128
996 // __CMODEL_MEDIUM__
997 // __CMODEL_LARGE__
998 // _CALL_SYSV
999 // _CALL_DARWIN
1000 // __NO_FPRS__
Bill Schmidt199402b2013-02-01 02:14:03 +00001001}
1002
1003void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1004 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1005 .Case("7400", true)
1006 .Case("g4", true)
1007 .Case("7450", true)
1008 .Case("g4+", true)
1009 .Case("970", true)
1010 .Case("g5", true)
1011 .Case("pwr6", true)
1012 .Case("pwr7", true)
1013 .Case("ppc64", true)
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001014 .Case("ppc64le", true)
Bill Schmidt199402b2013-02-01 02:14:03 +00001015 .Default(false);
Hal Finkel3c6aaeb2013-02-01 18:44:19 +00001016
1017 Features["qpx"] = (CPU == "a2q");
Bill Schmidt199402b2013-02-01 02:14:03 +00001018}
1019
Douglas Gregore727d212012-01-30 06:38:25 +00001020bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1021 return Feature == "powerpc";
1022}
Chris Lattner393ff042008-04-21 18:56:49 +00001023
Douglas Gregore727d212012-01-30 06:38:25 +00001024
Eli Friedmane4277982008-08-20 23:11:40 +00001025const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnere94e0d42009-09-16 05:05:27 +00001026 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1027 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1028 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1029 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1030 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1031 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1032 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1033 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmane4277982008-08-20 23:11:40 +00001034 "mq", "lr", "ctr", "ap",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001035 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmane4277982008-08-20 23:11:40 +00001036 "xer",
Chris Lattnere94e0d42009-09-16 05:05:27 +00001037 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1038 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1039 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1040 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmane4277982008-08-20 23:11:40 +00001041 "vrsave", "vscr",
1042 "spe_acc", "spefscr",
1043 "sfp"
1044};
Reid Spencer5f016e22007-07-11 17:01:13 +00001045
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001046void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmane4277982008-08-20 23:11:40 +00001047 unsigned &NumNames) const {
1048 Names = GCCRegNames;
1049 NumNames = llvm::array_lengthof(GCCRegNames);
1050}
Reid Spencer5f016e22007-07-11 17:01:13 +00001051
Eli Friedmane4277982008-08-20 23:11:40 +00001052const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1053 // While some of these aliases do map to different registers
1054 // they still share the same register name.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001055 { { "0" }, "r0" },
1056 { { "1"}, "r1" },
1057 { { "2" }, "r2" },
1058 { { "3" }, "r3" },
1059 { { "4" }, "r4" },
1060 { { "5" }, "r5" },
1061 { { "6" }, "r6" },
1062 { { "7" }, "r7" },
1063 { { "8" }, "r8" },
1064 { { "9" }, "r9" },
1065 { { "10" }, "r10" },
1066 { { "11" }, "r11" },
1067 { { "12" }, "r12" },
1068 { { "13" }, "r13" },
1069 { { "14" }, "r14" },
1070 { { "15" }, "r15" },
1071 { { "16" }, "r16" },
1072 { { "17" }, "r17" },
1073 { { "18" }, "r18" },
1074 { { "19" }, "r19" },
1075 { { "20" }, "r20" },
1076 { { "21" }, "r21" },
1077 { { "22" }, "r22" },
1078 { { "23" }, "r23" },
1079 { { "24" }, "r24" },
1080 { { "25" }, "r25" },
1081 { { "26" }, "r26" },
1082 { { "27" }, "r27" },
1083 { { "28" }, "r28" },
1084 { { "29" }, "r29" },
1085 { { "30" }, "r30" },
1086 { { "31" }, "r31" },
1087 { { "fr0" }, "f0" },
1088 { { "fr1" }, "f1" },
1089 { { "fr2" }, "f2" },
1090 { { "fr3" }, "f3" },
1091 { { "fr4" }, "f4" },
1092 { { "fr5" }, "f5" },
1093 { { "fr6" }, "f6" },
1094 { { "fr7" }, "f7" },
1095 { { "fr8" }, "f8" },
1096 { { "fr9" }, "f9" },
Mike Stump10880392009-09-17 21:15:00 +00001097 { { "fr10" }, "f10" },
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00001098 { { "fr11" }, "f11" },
1099 { { "fr12" }, "f12" },
1100 { { "fr13" }, "f13" },
1101 { { "fr14" }, "f14" },
1102 { { "fr15" }, "f15" },
1103 { { "fr16" }, "f16" },
1104 { { "fr17" }, "f17" },
1105 { { "fr18" }, "f18" },
1106 { { "fr19" }, "f19" },
1107 { { "fr20" }, "f20" },
1108 { { "fr21" }, "f21" },
1109 { { "fr22" }, "f22" },
1110 { { "fr23" }, "f23" },
1111 { { "fr24" }, "f24" },
1112 { { "fr25" }, "f25" },
1113 { { "fr26" }, "f26" },
1114 { { "fr27" }, "f27" },
1115 { { "fr28" }, "f28" },
1116 { { "fr29" }, "f29" },
1117 { { "fr30" }, "f30" },
1118 { { "fr31" }, "f31" },
1119 { { "cc" }, "cr0" },
Eli Friedmane4277982008-08-20 23:11:40 +00001120};
1121
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001122void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmane4277982008-08-20 23:11:40 +00001123 unsigned &NumAliases) const {
1124 Aliases = GCCRegAliases;
1125 NumAliases = llvm::array_lengthof(GCCRegAliases);
1126}
1127} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00001128
1129namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001130class PPC32TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001131public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001132 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eli Friedmaned855cb2008-08-21 00:13:15 +00001133 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 +00001134 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
Chris Lattnere03ae302010-02-16 18:14:57 +00001135
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001136 switch (getTriple().getOS()) {
Nico Weber6e1d2ea2012-01-31 02:07:33 +00001137 case llvm::Triple::Linux:
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001138 case llvm::Triple::FreeBSD:
1139 case llvm::Triple::NetBSD:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001140 SizeType = UnsignedInt;
Hal Finkel178a9b82012-03-02 20:54:36 +00001141 PtrDiffType = SignedInt;
1142 IntPtrType = SignedInt;
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001143 break;
Joerg Sonnenberger1a83b432011-07-04 23:11:58 +00001144 default:
Joerg Sonnenberger78542df2011-07-05 14:54:41 +00001145 break;
Joerg Sonnenberger6ac26fa2011-07-04 21:57:55 +00001146 }
Roman Divackye3d175d2012-03-13 16:53:54 +00001147
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001148 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1149 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001150 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001151 }
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001152
1153 // PPC32 supports atomics up to 4 bytes.
1154 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001155 }
1156
Meador Ingec5613b22012-06-16 03:34:49 +00001157 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001158 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Ingec5613b22012-06-16 03:34:49 +00001159 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedmaned855cb2008-08-21 00:13:15 +00001160 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001161};
1162} // end anonymous namespace.
1163
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00001164// Note: ABI differences may eventually require us to have a separate
1165// TargetInfo for little endian.
Reid Spencer5f016e22007-07-11 17:01:13 +00001166namespace {
Eli Friedmane4277982008-08-20 23:11:40 +00001167class PPC64TargetInfo : public PPCTargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00001168public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001169 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00001170 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00001171 IntMaxType = SignedLong;
1172 UIntMaxType = UnsignedLong;
1173 Int64Type = SignedLong;
Roman Divackye3d175d2012-03-13 16:53:54 +00001174
Roman Divackyefe9c0d2012-03-13 19:20:17 +00001175 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1176 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divackye3d175d2012-03-13 16:53:54 +00001177 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001178 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 +00001179 "i64:64:64-f32:32:32-f64:64:64-"
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001180 "v128:128:128-n32:64";
1181 } else
1182 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1183 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
1184 "v128:128:128-n32:64";
Benjamin Kramer7baa7112012-11-17 17:30:55 +00001185
1186 // PPC64 supports atomics up to 8 bytes.
1187 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerf291b102008-05-09 06:17:04 +00001188 }
Meador Ingec5613b22012-06-16 03:34:49 +00001189 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1190 return TargetInfo::CharPtrBuiltinVaList;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001191 }
Eli Friedmane4277982008-08-20 23:11:40 +00001192};
1193} // end anonymous namespace.
1194
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001195
1196namespace {
Roman Divackyc81f2a22011-01-06 08:27:10 +00001197class DarwinPPC32TargetInfo :
1198 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001199public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001200 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1201 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001202 HasAlignMac68kSupport = true;
Roman Divackyc81f2a22011-01-06 08:27:10 +00001203 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
David Fangb5afadd2013-05-16 17:51:48 +00001204 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001205 LongLongAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001206 SuitableAlign = 128;
Anton Yartsev9bc23ba2012-01-17 22:40:00 +00001207 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1208 "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
Roman Divackyc81f2a22011-01-06 08:27:10 +00001209 }
Meador Ingec5613b22012-06-16 03:34:49 +00001210 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1211 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001212 }
1213};
1214
1215class DarwinPPC64TargetInfo :
1216 public DarwinTargetInfo<PPC64TargetInfo> {
1217public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001218 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1219 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001220 HasAlignMac68kSupport = true;
Nick Lewycky9bddf432011-12-21 04:25:47 +00001221 SuitableAlign = 128;
Bill Schmidtdbaf4bc2012-10-29 14:59:24 +00001222 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
1223 "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32:64";
Daniel Dunbar4c6a2262010-05-30 00:07:30 +00001224 }
1225};
1226} // end anonymous namespace.
1227
Reid Spencer5f016e22007-07-11 17:01:13 +00001228namespace {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001229 static const unsigned NVPTXAddrSpaceMap[] = {
1230 1, // opencl_global
1231 3, // opencl_local
1232 4, // opencl_constant
1233 1, // cuda_device
1234 4, // cuda_constant
1235 3, // cuda_shared
1236 };
1237 class NVPTXTargetInfo : public TargetInfo {
1238 static const char * const GCCRegNames[];
Justin Holewinski2c585b92012-05-24 17:43:12 +00001239 static const Builtin::Info BuiltinInfo[];
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001240 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001241 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001242 BigEndian = false;
1243 TLSSupported = false;
1244 LongWidth = LongAlign = 64;
1245 AddrSpaceMap = &NVPTXAddrSpaceMap;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001246 // Define available target features
1247 // These must be defined in sorted order!
Justin Holewinski9903e942012-07-11 15:34:55 +00001248 NoAsmVariants = true;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001249 }
1250 virtual void getTargetDefines(const LangOptions &Opts,
1251 MacroBuilder &Builder) const {
1252 Builder.defineMacro("__PTX__");
Justin Holewinski2c585b92012-05-24 17:43:12 +00001253 Builder.defineMacro("__NVPTX__");
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001254 }
1255 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1256 unsigned &NumRecords) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001257 Records = BuiltinInfo;
1258 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001259 }
1260 virtual bool hasFeature(StringRef Feature) const {
Justin Holewinski2c585b92012-05-24 17:43:12 +00001261 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001262 }
1263
1264 virtual void getGCCRegNames(const char * const *&Names,
1265 unsigned &NumNames) const;
1266 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1267 unsigned &NumAliases) const {
1268 // No aliases.
1269 Aliases = 0;
1270 NumAliases = 0;
1271 }
1272 virtual bool validateAsmConstraint(const char *&Name,
Justin Holewinski0ac428e2013-06-21 18:51:24 +00001273 TargetInfo::ConstraintInfo &Info) const {
1274 switch (*Name) {
1275 default: return false;
1276 case 'c':
1277 case 'h':
1278 case 'r':
1279 case 'l':
1280 case 'f':
1281 case 'd':
1282 Info.setAllowsRegister();
1283 return true;
1284 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001285 }
1286 virtual const char *getClobbers() const {
1287 // FIXME: Is this really right?
1288 return "";
1289 }
Meador Ingec5613b22012-06-16 03:34:49 +00001290 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001291 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00001292 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001293 }
1294 virtual bool setCPU(const std::string &Name) {
Justin Holewinskiaffa3af2013-03-30 14:38:26 +00001295 bool Valid = llvm::StringSwitch<bool>(Name)
1296 .Case("sm_20", true)
1297 .Case("sm_21", true)
1298 .Case("sm_30", true)
1299 .Case("sm_35", true)
1300 .Default(false);
1301
1302 return Valid;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001303 }
Justin Holewinski2c585b92012-05-24 17:43:12 +00001304 };
1305
1306 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1307#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1308#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1309 ALL_LANGUAGES },
1310#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001311 };
1312
1313 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1314 "r0"
1315 };
1316
1317 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1318 unsigned &NumNames) const {
1319 Names = GCCRegNames;
1320 NumNames = llvm::array_lengthof(GCCRegNames);
1321 }
1322
1323 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1324 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001325 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001326 PointerWidth = PointerAlign = 32;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001327 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedInt;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001328 DescriptionString
1329 = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1330 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1331 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001332 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001333 };
1334
1335 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1336 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001337 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001338 PointerWidth = PointerAlign = 64;
Justin Holewinski2c585b92012-05-24 17:43:12 +00001339 SizeType = PtrDiffType = IntPtrType = TargetInfo::UnsignedLongLong;
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001340 DescriptionString
1341 = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
1342 "f32:32:32-f64:64:64-v16:16:16-v32:32:32-v64:64:64-v128:128:128-"
1343 "n16:32:64";
Justin Holewinski2c585b92012-05-24 17:43:12 +00001344 }
Peter Collingbourneedb66f32012-05-20 23:28:41 +00001345 };
1346}
1347
1348namespace {
Eli Friedman6505a292012-10-12 23:32:00 +00001349
1350static const unsigned R600AddrSpaceMap[] = {
1351 1, // opencl_global
1352 3, // opencl_local
1353 2, // opencl_constant
1354 1, // cuda_device
1355 2, // cuda_constant
1356 3 // cuda_shared
1357};
1358
Tom Stellardfd075912013-03-04 17:40:53 +00001359static const char *DescriptionStringR600 =
1360 "e"
1361 "-p:32:32:32"
1362 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32"
1363 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1364 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1365 "-n32:64";
1366
1367static const char *DescriptionStringR600DoubleOps =
1368 "e"
1369 "-p:32:32:32"
1370 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1371 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1372 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1373 "-n32:64";
1374
1375static const char *DescriptionStringSI =
1376 "e"
1377 "-p:64:64:64"
Tom Stellard9a3d2bd2013-08-27 00:55:26 +00001378 "-p3:32:32:32"
Tom Stellardfd075912013-03-04 17:40:53 +00001379 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64"
1380 "-v16:16:16-v24:32:32-v32:32:32-v48:64:64-v64:64:64-v96:128:128-v128:128:128"
1381 "-v192:256:256-v256:256:256-v512:512:512-v1024:1024:1024-v2048:2048:2048"
1382 "-n32:64";
1383
Eli Friedman6505a292012-10-12 23:32:00 +00001384class R600TargetInfo : public TargetInfo {
Tom Stellardfd075912013-03-04 17:40:53 +00001385 /// \brief The GPU profiles supported by the R600 target.
1386 enum GPUKind {
1387 GK_NONE,
1388 GK_R600,
1389 GK_R600_DOUBLE_OPS,
1390 GK_R700,
1391 GK_R700_DOUBLE_OPS,
1392 GK_EVERGREEN,
1393 GK_EVERGREEN_DOUBLE_OPS,
1394 GK_NORTHERN_ISLANDS,
1395 GK_CAYMAN,
1396 GK_SOUTHERN_ISLANDS
1397 } GPU;
1398
Eli Friedman6505a292012-10-12 23:32:00 +00001399public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001400 R600TargetInfo(const llvm::Triple &Triple)
1401 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardfd075912013-03-04 17:40:53 +00001402 DescriptionString = DescriptionStringR600;
Eli Friedman6505a292012-10-12 23:32:00 +00001403 AddrSpaceMap = &R600AddrSpaceMap;
1404 }
1405
1406 virtual const char * getClobbers() const {
1407 return "";
1408 }
1409
1410 virtual void getGCCRegNames(const char * const *&Names,
1411 unsigned &numNames) const {
1412 Names = NULL;
1413 numNames = 0;
1414 }
1415
1416 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
1417 unsigned &NumAliases) const {
1418 Aliases = NULL;
1419 NumAliases = 0;
1420 }
1421
1422 virtual bool validateAsmConstraint(const char *&Name,
1423 TargetInfo::ConstraintInfo &info) const {
1424 return true;
1425 }
1426
1427 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1428 unsigned &NumRecords) const {
1429 Records = NULL;
1430 NumRecords = 0;
1431 }
1432
1433
1434 virtual void getTargetDefines(const LangOptions &Opts,
1435 MacroBuilder &Builder) const {
1436 Builder.defineMacro("__R600__");
1437 }
1438
1439 virtual BuiltinVaListKind getBuiltinVaListKind() const {
1440 return TargetInfo::CharPtrBuiltinVaList;
1441 }
1442
Tom Stellardfd075912013-03-04 17:40:53 +00001443 virtual bool setCPU(const std::string &Name) {
1444 GPU = llvm::StringSwitch<GPUKind>(Name)
1445 .Case("r600" , GK_R600)
1446 .Case("rv610", GK_R600)
1447 .Case("rv620", GK_R600)
1448 .Case("rv630", GK_R600)
1449 .Case("rv635", GK_R600)
1450 .Case("rs780", GK_R600)
1451 .Case("rs880", GK_R600)
1452 .Case("rv670", GK_R600_DOUBLE_OPS)
1453 .Case("rv710", GK_R700)
1454 .Case("rv730", GK_R700)
1455 .Case("rv740", GK_R700_DOUBLE_OPS)
1456 .Case("rv770", GK_R700_DOUBLE_OPS)
1457 .Case("palm", GK_EVERGREEN)
1458 .Case("cedar", GK_EVERGREEN)
1459 .Case("sumo", GK_EVERGREEN)
1460 .Case("sumo2", GK_EVERGREEN)
1461 .Case("redwood", GK_EVERGREEN)
1462 .Case("juniper", GK_EVERGREEN)
1463 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1464 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1465 .Case("barts", GK_NORTHERN_ISLANDS)
1466 .Case("turks", GK_NORTHERN_ISLANDS)
1467 .Case("caicos", GK_NORTHERN_ISLANDS)
1468 .Case("cayman", GK_CAYMAN)
1469 .Case("aruba", GK_CAYMAN)
Tom Stellard3b848ec2013-04-01 20:56:49 +00001470 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardfd075912013-03-04 17:40:53 +00001471 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1472 .Case("verde", GK_SOUTHERN_ISLANDS)
1473 .Case("oland", GK_SOUTHERN_ISLANDS)
1474 .Default(GK_NONE);
1475
1476 if (GPU == GK_NONE) {
1477 return false;
1478 }
1479
1480 // Set the correct data layout
1481 switch (GPU) {
1482 case GK_NONE:
1483 case GK_R600:
1484 case GK_R700:
1485 case GK_EVERGREEN:
1486 case GK_NORTHERN_ISLANDS:
1487 DescriptionString = DescriptionStringR600;
1488 break;
1489 case GK_R600_DOUBLE_OPS:
1490 case GK_R700_DOUBLE_OPS:
1491 case GK_EVERGREEN_DOUBLE_OPS:
1492 case GK_CAYMAN:
1493 DescriptionString = DescriptionStringR600DoubleOps;
1494 break;
1495 case GK_SOUTHERN_ISLANDS:
1496 DescriptionString = DescriptionStringSI;
1497 break;
1498 }
1499
1500 return true;
1501 }
Eli Friedman6505a292012-10-12 23:32:00 +00001502};
1503
1504} // end anonymous namespace
1505
1506namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00001507// Namespace for x86 abstract base class
1508const Builtin::Info BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00001509#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00001510#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00001511 ALL_LANGUAGES },
Chris Lattner6b15cdc2009-06-14 01:05:48 +00001512#include "clang/Basic/BuiltinsX86.def"
Eli Friedman618234a2008-08-20 02:34:37 +00001513};
Eli Friedman61538a72008-05-20 14:21:01 +00001514
Nuno Lopes2550d702009-12-23 17:49:57 +00001515static const char* const GCCRegNames[] = {
Eli Friedman618234a2008-08-20 02:34:37 +00001516 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1517 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher7c9adf92011-07-07 22:55:26 +00001518 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman618234a2008-08-20 02:34:37 +00001519 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1520 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1521 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercfd323d2011-06-21 00:05:20 +00001522 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopherc5f9a012011-12-02 02:12:16 +00001523 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1524 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman618234a2008-08-20 02:34:37 +00001525};
1526
Eric Christophercfd323d2011-06-21 00:05:20 +00001527const TargetInfo::AddlRegName AddlRegNames[] = {
1528 { { "al", "ah", "eax", "rax" }, 0 },
1529 { { "bl", "bh", "ebx", "rbx" }, 3 },
1530 { { "cl", "ch", "ecx", "rcx" }, 2 },
1531 { { "dl", "dh", "edx", "rdx" }, 1 },
1532 { { "esi", "rsi" }, 4 },
1533 { { "edi", "rdi" }, 5 },
1534 { { "esp", "rsp" }, 7 },
1535 { { "ebp", "rbp" }, 6 },
Eli Friedman618234a2008-08-20 02:34:37 +00001536};
1537
1538// X86 target abstract base class; x86-32 and x86-64 are very close, so
1539// most of the implementation can be shared.
1540class X86TargetInfo : public TargetInfo {
Chris Lattner84f0ea82009-03-02 22:40:39 +00001541 enum X86SSEEnum {
Craig Topperb7a95d22013-08-21 03:59:22 +00001542 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Chris Lattner84f0ea82009-03-02 22:40:39 +00001543 } SSELevel;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001544 enum MMX3DNowEnum {
1545 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1546 } MMX3DNowLevel;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00001547 enum XOPEnum {
1548 NoXOP,
1549 SSE4A,
1550 FMA4,
1551 XOP
1552 } XOPLevel;
Anders Carlsson9b0fb622010-01-27 03:47:49 +00001553
Eric Christophereea12d12010-04-02 23:50:19 +00001554 bool HasAES;
Craig Topper3c0bc152012-05-31 05:18:48 +00001555 bool HasPCLMUL;
Craig Topper31ceea02011-12-25 05:06:45 +00001556 bool HasLZCNT;
Benjamin Kramer84f30802012-07-07 09:39:18 +00001557 bool HasRDRND;
Craig Topper31ceea02011-12-25 05:06:45 +00001558 bool HasBMI;
1559 bool HasBMI2;
Craig Toppere14e08b2011-12-29 16:10:46 +00001560 bool HasPOPCNT;
Michael Liao463eb892012-11-10 05:17:46 +00001561 bool HasRTM;
Michael Liao72339a02013-03-26 17:52:08 +00001562 bool HasPRFCHW;
Michael Liao1bfc28c2013-03-29 05:17:55 +00001563 bool HasRDSEED;
Craig Topper2ae95072012-06-03 21:46:30 +00001564 bool HasFMA;
Manman Ren146e5a42012-10-11 00:59:55 +00001565 bool HasF16C;
Craig Topperbca2c4f2013-08-21 05:29:10 +00001566 bool HasAVX512CD, HasAVX512ER, HasAVX512PF;
Bruno Cardoso Lopes7377ed92010-08-04 22:29:13 +00001567
Chandler Carruth499d9722011-09-28 08:55:34 +00001568 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1569 ///
1570 /// Each enumeration represents a particular CPU supported by Clang. These
1571 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1572 enum CPUKind {
1573 CK_Generic,
1574
1575 /// \name i386
1576 /// i386-generation processors.
1577 //@{
1578 CK_i386,
1579 //@}
1580
1581 /// \name i486
1582 /// i486-generation processors.
1583 //@{
1584 CK_i486,
1585 CK_WinChipC6,
1586 CK_WinChip2,
1587 CK_C3,
1588 //@}
1589
1590 /// \name i586
1591 /// i586-generation processors, P5 microarchitecture based.
1592 //@{
1593 CK_i586,
1594 CK_Pentium,
1595 CK_PentiumMMX,
1596 //@}
1597
1598 /// \name i686
1599 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1600 //@{
1601 CK_i686,
1602 CK_PentiumPro,
1603 CK_Pentium2,
1604 CK_Pentium3,
1605 CK_Pentium3M,
1606 CK_PentiumM,
1607 CK_C3_2,
1608
1609 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1610 /// Clang however has some logic to suport this.
1611 // FIXME: Warn, deprecate, and potentially remove this.
1612 CK_Yonah,
1613 //@}
1614
1615 /// \name Netburst
Chandler Carruth83450aa2011-09-28 18:17:30 +00001616 /// Netburst microarchitecture based processors.
Chandler Carruth499d9722011-09-28 08:55:34 +00001617 //@{
1618 CK_Pentium4,
1619 CK_Pentium4M,
1620 CK_Prescott,
1621 CK_Nocona,
1622 //@}
1623
1624 /// \name Core
1625 /// Core microarchitecture based processors.
1626 //@{
1627 CK_Core2,
1628
1629 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1630 /// codename which GCC no longer accepts as an option to -march, but Clang
1631 /// has some logic for recognizing it.
1632 // FIXME: Warn, deprecate, and potentially remove this.
1633 CK_Penryn,
1634 //@}
1635
1636 /// \name Atom
1637 /// Atom processors
1638 //@{
1639 CK_Atom,
1640 //@}
1641
1642 /// \name Nehalem
1643 /// Nehalem microarchitecture based processors.
1644 //@{
1645 CK_Corei7,
1646 CK_Corei7AVX,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001647 CK_CoreAVXi,
Craig Topper2b03bb02011-12-17 19:55:21 +00001648 CK_CoreAVX2,
Chandler Carruth499d9722011-09-28 08:55:34 +00001649 //@}
1650
Craig Topper10c2c682013-08-20 07:09:39 +00001651 /// \name Knights Landing
1652 /// Knights Landing processor.
1653 CK_KNL,
1654
Chandler Carruth499d9722011-09-28 08:55:34 +00001655 /// \name K6
1656 /// K6 architecture processors.
1657 //@{
1658 CK_K6,
1659 CK_K6_2,
1660 CK_K6_3,
1661 //@}
1662
1663 /// \name K7
1664 /// K7 architecture processors.
1665 //@{
1666 CK_Athlon,
1667 CK_AthlonThunderbird,
1668 CK_Athlon4,
1669 CK_AthlonXP,
1670 CK_AthlonMP,
1671 //@}
1672
1673 /// \name K8
1674 /// K8 architecture processors.
1675 //@{
1676 CK_Athlon64,
1677 CK_Athlon64SSE3,
1678 CK_AthlonFX,
1679 CK_K8,
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001680 CK_K8SSE3,
Chandler Carruth499d9722011-09-28 08:55:34 +00001681 CK_Opteron,
1682 CK_OpteronSSE3,
Roman Divacky01c770d2011-10-30 07:48:46 +00001683 CK_AMDFAM10,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001684 //@}
Chandler Carruth499d9722011-09-28 08:55:34 +00001685
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001686 /// \name Bobcat
1687 /// Bobcat architecture processors.
1688 //@{
1689 CK_BTVER1,
Benjamin Kramer63063f52013-05-03 10:47:15 +00001690 CK_BTVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001691 //@}
1692
1693 /// \name Bulldozer
1694 /// Bulldozer architecture processors.
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001695 //@{
1696 CK_BDVER1,
1697 CK_BDVER2,
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001698 //@}
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001699
Chandler Carruth499d9722011-09-28 08:55:34 +00001700 /// This specification is deprecated and will be removed in the future.
1701 /// Users should prefer \see CK_K8.
1702 // FIXME: Warn on this when the CPU is set to it.
1703 CK_x86_64,
1704 //@}
1705
1706 /// \name Geode
1707 /// Geode processors.
1708 //@{
1709 CK_Geode
1710 //@}
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001711 } CPU;
Chandler Carruth499d9722011-09-28 08:55:34 +00001712
Rafael Espindola5389b842013-08-21 21:59:03 +00001713 enum FPMathKind {
1714 FP_Default,
1715 FP_SSE,
1716 FP_387
1717 } FPMath;
1718
Eli Friedman618234a2008-08-20 02:34:37 +00001719public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00001720 X86TargetInfo(const llvm::Triple &Triple)
1721 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00001722 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
1723 HasRDRND(false), HasBMI(false), HasBMI2(false), HasPOPCNT(false),
1724 HasRTM(false), HasPRFCHW(false), HasRDSEED(false), HasFMA(false),
Craig Topperbca2c4f2013-08-21 05:29:10 +00001725 HasF16C(false), HasAVX512CD(false), HasAVX512ER(false),
Rafael Espindola5389b842013-08-21 21:59:03 +00001726 HasAVX512PF(false), CPU(CK_Generic), FPMath(FP_Default) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00001727 BigEndian = false;
Eli Friedman618234a2008-08-20 02:34:37 +00001728 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Reid Spencer5f016e22007-07-11 17:01:13 +00001729 }
Benjamin Kramerb4066692011-12-28 15:47:06 +00001730 virtual unsigned getFloatEvalMethod() const {
1731 // X87 evaluates with 80 bits "long double" precision.
1732 return SSELevel == NoSSE ? 2 : 0;
1733 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001734 virtual void getTargetBuiltins(const Builtin::Info *&Records,
1735 unsigned &NumRecords) const {
Eli Friedman618234a2008-08-20 02:34:37 +00001736 Records = BuiltinInfo;
1737 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Reid Spencer5f016e22007-07-11 17:01:13 +00001738 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001739 virtual void getGCCRegNames(const char * const *&Names,
Eli Friedman618234a2008-08-20 02:34:37 +00001740 unsigned &NumNames) const {
1741 Names = GCCRegNames;
1742 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson3346ae62007-11-24 23:38:12 +00001743 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00001744 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Anders Carlsson3346ae62007-11-24 23:38:12 +00001745 unsigned &NumAliases) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001746 Aliases = 0;
1747 NumAliases = 0;
1748 }
1749 virtual void getGCCAddlRegNames(const AddlRegName *&Names,
Eric Christopher825d3862012-11-14 22:08:59 +00001750 unsigned &NumNames) const {
Eric Christophercfd323d2011-06-21 00:05:20 +00001751 Names = AddlRegNames;
1752 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssonfb5e5ba2007-10-13 00:45:48 +00001753 }
Anders Carlsson066d2ea2009-02-28 17:11:49 +00001754 virtual bool validateAsmConstraint(const char *&Name,
Eli Friedman618234a2008-08-20 02:34:37 +00001755 TargetInfo::ConstraintInfo &info) const;
Stuart Hastings002333f2011-06-07 23:45:05 +00001756 virtual std::string convertConstraint(const char *&Constraint) const;
Anders Carlssond04c6e22007-11-27 04:11:28 +00001757 virtual const char *getClobbers() const {
Eli Friedman618234a2008-08-20 02:34:37 +00001758 return "~{dirflag},~{fpsr},~{flags}";
1759 }
Chris Lattner33328642009-03-20 15:52:06 +00001760 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00001761 MacroBuilder &Builder) const;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00001762 void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
1763 bool Enabled) const;
1764 void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
1765 bool Enabled) const;
1766 void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
1767 bool Enabled) const;
Rafael Espindolaade7cd42013-08-20 15:30:32 +00001768 virtual void setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00001769 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00001770 bool Enabled) const;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001771 virtual void getDefaultFeatures(llvm::StringMap<bool> &Features) const;
Douglas Gregore727d212012-01-30 06:38:25 +00001772 virtual bool hasFeature(StringRef Feature) const;
Rafael Espindola5389b842013-08-21 21:59:03 +00001773 virtual bool HandleTargetFeatures(std::vector<std::string> &Features,
1774 DiagnosticsEngine &Diags);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001775 virtual const char* getABI() const {
Derek Schuffbabaf312012-10-11 15:52:22 +00001776 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001777 return "avx";
Derek Schuffbabaf312012-10-11 15:52:22 +00001778 else if (getTriple().getArch() == llvm::Triple::x86 &&
1779 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanee1ad992011-12-02 00:11:43 +00001780 return "no-mmx";
1781 return "";
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00001782 }
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001783 virtual bool setCPU(const std::string &Name) {
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001784 CPU = llvm::StringSwitch<CPUKind>(Name)
1785 .Case("i386", CK_i386)
1786 .Case("i486", CK_i486)
1787 .Case("winchip-c6", CK_WinChipC6)
1788 .Case("winchip2", CK_WinChip2)
1789 .Case("c3", CK_C3)
1790 .Case("i586", CK_i586)
1791 .Case("pentium", CK_Pentium)
1792 .Case("pentium-mmx", CK_PentiumMMX)
1793 .Case("i686", CK_i686)
1794 .Case("pentiumpro", CK_PentiumPro)
1795 .Case("pentium2", CK_Pentium2)
1796 .Case("pentium3", CK_Pentium3)
1797 .Case("pentium3m", CK_Pentium3M)
1798 .Case("pentium-m", CK_PentiumM)
1799 .Case("c3-2", CK_C3_2)
1800 .Case("yonah", CK_Yonah)
1801 .Case("pentium4", CK_Pentium4)
1802 .Case("pentium4m", CK_Pentium4M)
1803 .Case("prescott", CK_Prescott)
1804 .Case("nocona", CK_Nocona)
1805 .Case("core2", CK_Core2)
1806 .Case("penryn", CK_Penryn)
1807 .Case("atom", CK_Atom)
1808 .Case("corei7", CK_Corei7)
1809 .Case("corei7-avx", CK_Corei7AVX)
1810 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper2b03bb02011-12-17 19:55:21 +00001811 .Case("core-avx2", CK_CoreAVX2)
Craig Topper10c2c682013-08-20 07:09:39 +00001812 .Case("knl", CK_KNL)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001813 .Case("k6", CK_K6)
1814 .Case("k6-2", CK_K6_2)
1815 .Case("k6-3", CK_K6_3)
1816 .Case("athlon", CK_Athlon)
1817 .Case("athlon-tbird", CK_AthlonThunderbird)
1818 .Case("athlon-4", CK_Athlon4)
1819 .Case("athlon-xp", CK_AthlonXP)
1820 .Case("athlon-mp", CK_AthlonMP)
1821 .Case("athlon64", CK_Athlon64)
1822 .Case("athlon64-sse3", CK_Athlon64SSE3)
1823 .Case("athlon-fx", CK_AthlonFX)
1824 .Case("k8", CK_K8)
1825 .Case("k8-sse3", CK_K8SSE3)
1826 .Case("opteron", CK_Opteron)
1827 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky01c770d2011-10-30 07:48:46 +00001828 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001829 .Case("btver1", CK_BTVER1)
Benjamin Kramer63063f52013-05-03 10:47:15 +00001830 .Case("btver2", CK_BTVER2)
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001831 .Case("bdver1", CK_BDVER1)
1832 .Case("bdver2", CK_BDVER2)
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001833 .Case("x86-64", CK_x86_64)
1834 .Case("geode", CK_Geode)
1835 .Default(CK_Generic);
1836
Chandler Carruth26a39142011-09-28 09:45:08 +00001837 // Perform any per-CPU checks necessary to determine if this CPU is
1838 // acceptable.
1839 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
1840 // invalid without explaining *why*.
1841 switch (CPU) {
1842 case CK_Generic:
1843 // No processor selected!
1844 return false;
1845
1846 case CK_i386:
1847 case CK_i486:
1848 case CK_WinChipC6:
1849 case CK_WinChip2:
1850 case CK_C3:
1851 case CK_i586:
1852 case CK_Pentium:
1853 case CK_PentiumMMX:
1854 case CK_i686:
1855 case CK_PentiumPro:
1856 case CK_Pentium2:
1857 case CK_Pentium3:
1858 case CK_Pentium3M:
1859 case CK_PentiumM:
1860 case CK_Yonah:
1861 case CK_C3_2:
1862 case CK_Pentium4:
1863 case CK_Pentium4M:
1864 case CK_Prescott:
1865 case CK_K6:
1866 case CK_K6_2:
1867 case CK_K6_3:
1868 case CK_Athlon:
1869 case CK_AthlonThunderbird:
1870 case CK_Athlon4:
1871 case CK_AthlonXP:
1872 case CK_AthlonMP:
1873 case CK_Geode:
1874 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffbabaf312012-10-11 15:52:22 +00001875 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth26a39142011-09-28 09:45:08 +00001876 return false;
1877
1878 // Fallthrough
1879 case CK_Nocona:
1880 case CK_Core2:
1881 case CK_Penryn:
1882 case CK_Atom:
1883 case CK_Corei7:
1884 case CK_Corei7AVX:
1885 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00001886 case CK_CoreAVX2:
Craig Topper10c2c682013-08-20 07:09:39 +00001887 case CK_KNL:
Chandler Carruth26a39142011-09-28 09:45:08 +00001888 case CK_Athlon64:
1889 case CK_Athlon64SSE3:
1890 case CK_AthlonFX:
1891 case CK_K8:
1892 case CK_K8SSE3:
1893 case CK_Opteron:
1894 case CK_OpteronSSE3:
Roman Divacky01c770d2011-10-30 07:48:46 +00001895 case CK_AMDFAM10:
Benjamin Kramer5660aa62012-01-10 11:50:18 +00001896 case CK_BTVER1:
Benjamin Kramer63063f52013-05-03 10:47:15 +00001897 case CK_BTVER2:
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00001898 case CK_BDVER1:
1899 case CK_BDVER2:
Chandler Carruth26a39142011-09-28 09:45:08 +00001900 case CK_x86_64:
1901 return true;
1902 }
Chandler Carruth5b7803d2011-09-28 10:49:06 +00001903 llvm_unreachable("Unhandled CPU kind");
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00001904 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00001905
Rafael Espindola5389b842013-08-21 21:59:03 +00001906 virtual bool setFPMath(StringRef Name);
1907
Aaron Ballman82bfa192012-10-02 14:26:08 +00001908 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
1909 // We accept all non-ARM calling conventions
1910 return (CC == CC_X86ThisCall ||
1911 CC == CC_X86FastCall ||
Peter Collingbourne7728cdd2013-02-23 00:06:18 +00001912 CC == CC_X86StdCall ||
1913 CC == CC_C ||
Guy Benyei38980082012-12-25 08:53:55 +00001914 CC == CC_X86Pascal ||
1915 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001916 }
1917
Aaron Ballmanfff32482012-12-09 17:45:41 +00001918 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
1919 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00001920 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001921};
Chris Lattner3daed522009-03-02 22:20:04 +00001922
Rafael Espindola5389b842013-08-21 21:59:03 +00001923bool X86TargetInfo::setFPMath(StringRef Name) {
1924 if (Name == "387") {
1925 FPMath = FP_387;
1926 return true;
1927 }
1928 if (Name == "sse") {
1929 FPMath = FP_SSE;
1930 return true;
1931 }
1932 return false;
1933}
1934
Chandler Carruthc3a2e652011-09-28 05:56:05 +00001935void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001936 // FIXME: This *really* should not be here.
1937
1938 // X86_64 always has SSE2.
Derek Schuffbabaf312012-10-11 15:52:22 +00001939 if (getTriple().getArch() == llvm::Triple::x86_64)
Eli Friedman612db2a2012-11-17 01:16:19 +00001940 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00001941
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001942 switch (CPU) {
1943 case CK_Generic:
1944 case CK_i386:
1945 case CK_i486:
1946 case CK_i586:
1947 case CK_Pentium:
1948 case CK_i686:
1949 case CK_PentiumPro:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001950 break;
1951 case CK_PentiumMMX:
1952 case CK_Pentium2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001953 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001954 break;
1955 case CK_Pentium3:
1956 case CK_Pentium3M:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001957 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001958 break;
1959 case CK_PentiumM:
1960 case CK_Pentium4:
1961 case CK_Pentium4M:
1962 case CK_x86_64:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001963 setFeatureEnabled(Features, "sse2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001964 break;
1965 case CK_Yonah:
1966 case CK_Prescott:
1967 case CK_Nocona:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001968 setFeatureEnabled(Features, "sse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001969 break;
1970 case CK_Core2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00001971 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001972 break;
1973 case CK_Penryn:
Benjamin Kramerb3453a82012-01-04 14:36:57 +00001974 setFeatureEnabled(Features, "sse4.1", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001975 break;
1976 case CK_Atom:
Chandler Carruth49defe62011-09-28 10:36:46 +00001977 setFeatureEnabled(Features, "ssse3", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001978 break;
1979 case CK_Corei7:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00001980 setFeatureEnabled(Features, "sse4.2", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001981 break;
1982 case CK_Corei7AVX:
Benjamin Kramer84f30802012-07-07 09:39:18 +00001983 setFeatureEnabled(Features, "avx", true);
1984 setFeatureEnabled(Features, "aes", true);
1985 setFeatureEnabled(Features, "pclmul", true);
1986 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001987 case CK_CoreAVXi:
Craig Topperfd936302012-04-26 07:31:30 +00001988 setFeatureEnabled(Features, "avx", true);
Roman Divackybcaa3b82011-04-05 20:32:44 +00001989 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001990 setFeatureEnabled(Features, "pclmul", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001991 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00001992 setFeatureEnabled(Features, "f16c", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00001993 break;
Craig Topper2b03bb02011-12-17 19:55:21 +00001994 case CK_CoreAVX2:
Craig Topperfd936302012-04-26 07:31:30 +00001995 setFeatureEnabled(Features, "avx2", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00001996 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00001997 setFeatureEnabled(Features, "pclmul", true);
Craig Topper31ceea02011-12-25 05:06:45 +00001998 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer84f30802012-07-07 09:39:18 +00001999 setFeatureEnabled(Features, "rdrnd", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002000 setFeatureEnabled(Features, "f16c", true);
Craig Topper31ceea02011-12-25 05:06:45 +00002001 setFeatureEnabled(Features, "bmi", true);
2002 setFeatureEnabled(Features, "bmi2", true);
Michael Liao463eb892012-11-10 05:17:46 +00002003 setFeatureEnabled(Features, "rtm", true);
Craig Topper2ae95072012-06-03 21:46:30 +00002004 setFeatureEnabled(Features, "fma", true);
Craig Topper2b03bb02011-12-17 19:55:21 +00002005 break;
Craig Topper10c2c682013-08-20 07:09:39 +00002006 case CK_KNL:
Craig Topperbca2c4f2013-08-21 05:29:10 +00002007 setFeatureEnabled(Features, "avx512f", true);
2008 setFeatureEnabled(Features, "avx512cd", true);
2009 setFeatureEnabled(Features, "avx512er", true);
2010 setFeatureEnabled(Features, "avx512pf", true);
Craig Topper10c2c682013-08-20 07:09:39 +00002011 setFeatureEnabled(Features, "aes", true);
2012 setFeatureEnabled(Features, "pclmul", true);
2013 setFeatureEnabled(Features, "lzcnt", true);
2014 setFeatureEnabled(Features, "rdrnd", true);
2015 setFeatureEnabled(Features, "f16c", true);
2016 setFeatureEnabled(Features, "bmi", true);
2017 setFeatureEnabled(Features, "bmi2", true);
2018 setFeatureEnabled(Features, "rtm", true);
2019 setFeatureEnabled(Features, "fma", true);
2020 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002021 case CK_K6:
2022 case CK_WinChipC6:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002023 setFeatureEnabled(Features, "mmx", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002024 break;
2025 case CK_K6_2:
2026 case CK_K6_3:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002027 case CK_WinChip2:
2028 case CK_C3:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002029 setFeatureEnabled(Features, "3dnow", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002030 break;
Chandler Carruth49defe62011-09-28 10:36:46 +00002031 case CK_Athlon:
2032 case CK_AthlonThunderbird:
2033 case CK_Geode:
2034 setFeatureEnabled(Features, "3dnowa", true);
2035 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002036 case CK_Athlon4:
2037 case CK_AthlonXP:
2038 case CK_AthlonMP:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002039 setFeatureEnabled(Features, "sse", true);
2040 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002041 break;
2042 case CK_K8:
2043 case CK_Opteron:
2044 case CK_Athlon64:
2045 case CK_AthlonFX:
Mike Stump1eb44332009-09-09 15:08:12 +00002046 setFeatureEnabled(Features, "sse2", true);
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002047 setFeatureEnabled(Features, "3dnowa", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002048 break;
2049 case CK_K8SSE3:
2050 case CK_OpteronSSE3:
2051 case CK_Athlon64SSE3:
Roman Divacky80b32b82011-10-30 13:47:56 +00002052 setFeatureEnabled(Features, "sse3", true);
2053 setFeatureEnabled(Features, "3dnowa", true);
2054 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002055 case CK_AMDFAM10:
Roman Divackyc8b09a12010-12-29 13:28:29 +00002056 setFeatureEnabled(Features, "sse3", true);
Roman Divacky80b32b82011-10-30 13:47:56 +00002057 setFeatureEnabled(Features, "sse4a", true);
Roman Divackyc8b09a12010-12-29 13:28:29 +00002058 setFeatureEnabled(Features, "3dnowa", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002059 setFeatureEnabled(Features, "lzcnt", true);
2060 setFeatureEnabled(Features, "popcnt", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002061 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002062 case CK_BTVER1:
2063 setFeatureEnabled(Features, "ssse3", true);
2064 setFeatureEnabled(Features, "sse4a", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002065 setFeatureEnabled(Features, "lzcnt", true);
2066 setFeatureEnabled(Features, "popcnt", true);
Craig Topper90ea0362012-05-30 05:54:54 +00002067 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002068 case CK_BTVER2:
2069 setFeatureEnabled(Features, "avx", true);
2070 setFeatureEnabled(Features, "sse4a", true);
2071 setFeatureEnabled(Features, "lzcnt", true);
2072 setFeatureEnabled(Features, "aes", true);
2073 setFeatureEnabled(Features, "pclmul", true);
2074 setFeatureEnabled(Features, "bmi", true);
2075 setFeatureEnabled(Features, "f16c", true);
2076 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002077 case CK_BDVER1:
Craig Topperb6af69e2012-06-09 22:24:14 +00002078 setFeatureEnabled(Features, "xop", true);
Eli Friedmanfaf35382012-11-17 01:43:10 +00002079 setFeatureEnabled(Features, "lzcnt", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002080 setFeatureEnabled(Features, "aes", true);
Craig Topper3c0bc152012-05-31 05:18:48 +00002081 setFeatureEnabled(Features, "pclmul", true);
Eli Friedmanf5824992012-11-26 21:57:28 +00002082 break;
Eli Friedmanfaf35382012-11-17 01:43:10 +00002083 case CK_BDVER2:
2084 setFeatureEnabled(Features, "xop", true);
2085 setFeatureEnabled(Features, "lzcnt", true);
2086 setFeatureEnabled(Features, "aes", true);
2087 setFeatureEnabled(Features, "pclmul", true);
2088 setFeatureEnabled(Features, "bmi", true);
2089 setFeatureEnabled(Features, "fma", true);
2090 setFeatureEnabled(Features, "f16c", true);
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002091 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002092 case CK_C3_2:
Daniel Dunbar3ac79042009-05-06 21:56:32 +00002093 setFeatureEnabled(Features, "sse", true);
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002094 break;
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002095 }
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002096}
2097
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002098void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
2099 X86SSEEnum Level, bool Enabled) const {
2100 if (Enabled) {
2101 switch (Level) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002102 case AVX512F:
2103 Features["avx512f"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002104 case AVX2:
2105 Features["avx2"] = true;
2106 case AVX:
2107 Features["avx"] = true;
2108 case SSE42:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002109 Features["popcnt"] = Features["sse4.2"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002110 case SSE41:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002111 Features["sse4.1"] = true;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002112 case SSSE3:
2113 Features["ssse3"] = true;
2114 case SSE3:
2115 Features["sse3"] = true;
2116 case SSE2:
2117 Features["sse2"] = true;
2118 case SSE1:
Rafael Espindolac84ed542013-08-20 18:57:55 +00002119 if (!Features.count("mmx"))
2120 setMMXLevel(Features, MMX, Enabled);
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002121 Features["sse"] = true;
2122 case NoSSE:
2123 break;
2124 }
2125 return;
2126 }
2127
2128 switch (Level) {
2129 case NoSSE:
2130 case SSE1:
2131 Features["sse"] = false;
2132 case SSE2:
2133 Features["sse2"] = false;
2134 case SSE3:
2135 Features["sse3"] = false;
2136 setXOPLevel(Features, NoXOP, false);
2137 case SSSE3:
2138 Features["ssse3"] = false;
2139 case SSE41:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002140 Features["sse4.1"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002141 case SSE42:
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002142 Features["popcnt"] = Features["sse4.2"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002143 case AVX:
2144 Features["fma"] = Features["avx"] = false;
Rafael Espindola29f26de2013-08-21 13:28:02 +00002145 setXOPLevel(Features, FMA4, false);
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002146 case AVX2:
2147 Features["avx2"] = false;
Craig Topperb7a95d22013-08-21 03:59:22 +00002148 case AVX512F:
Craig Topperbca2c4f2013-08-21 05:29:10 +00002149 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
2150 Features["avx512pf"] = false;
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002151 }
2152}
2153
2154void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
2155 MMX3DNowEnum Level, bool Enabled) const {
2156 if (Enabled) {
2157 switch (Level) {
2158 case AMD3DNowAthlon:
2159 Features["3dnowa"] = true;
2160 case AMD3DNow:
2161 Features["3dnow"] = true;
2162 case MMX:
2163 Features["mmx"] = true;
2164 case NoMMX3DNow:
2165 break;
2166 }
2167 return;
2168 }
2169
2170 switch (Level) {
2171 case NoMMX3DNow:
2172 case MMX:
2173 Features["mmx"] = false;
2174 case AMD3DNow:
2175 Features["3dnow"] = false;
2176 case AMD3DNowAthlon:
2177 Features["3dnowa"] = false;
2178 }
2179}
2180
2181void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2182 bool Enabled) const {
2183 if (Enabled) {
2184 switch (Level) {
2185 case XOP:
2186 Features["xop"] = true;
2187 case FMA4:
2188 Features["fma4"] = true;
2189 setSSELevel(Features, AVX, true);
2190 case SSE4A:
2191 Features["sse4a"] = true;
2192 setSSELevel(Features, SSE3, true);
2193 case NoXOP:
2194 break;
2195 }
2196 return;
2197 }
2198
2199 switch (Level) {
2200 case NoXOP:
2201 case SSE4A:
2202 Features["sse4a"] = false;
2203 case FMA4:
2204 Features["fma4"] = false;
2205 case XOP:
2206 Features["xop"] = false;
2207 }
2208}
2209
Rafael Espindolaade7cd42013-08-20 15:30:32 +00002210void X86TargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
Benjamin Kramer713575a2012-03-05 15:10:44 +00002211 StringRef Name,
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002212 bool Enabled) const {
Eric Christopherd39ebe22010-03-04 02:26:37 +00002213 // FIXME: This *really* should not be here. We need some way of translating
2214 // options into llvm subtarget features.
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002215 if (Name == "sse4")
2216 Name = "sse4.2";
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002217
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002218 Features[Name] = Enabled;
Rafael Espindola53ac3d82011-11-27 20:00:43 +00002219
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002220 if (Name == "mmx")
2221 setMMXLevel(Features, MMX, Enabled);
2222 else if (Name == "sse")
2223 setSSELevel(Features, SSE1, Enabled);
2224 else if (Name == "sse2")
2225 setSSELevel(Features, SSE2, Enabled);
2226 else if (Name == "sse3")
2227 setSSELevel(Features, SSE3, Enabled);
2228 else if (Name == "ssse3")
2229 setSSELevel(Features, SSSE3, Enabled);
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002230 else if (Name == "sse4.2")
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002231 setSSELevel(Features, SSE42, Enabled);
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002232 else if (Name == "sse4.1")
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002233 setSSELevel(Features, SSE41, Enabled);
2234 else if (Name == "3dnow")
2235 setMMXLevel(Features, AMD3DNow, Enabled);
2236 else if (Name == "3dnowa")
2237 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
2238 else if (Name == "aes") {
2239 if (Enabled)
2240 setSSELevel(Features, SSE2, Enabled);
2241 } else if (Name == "pclmul") {
2242 if (Enabled)
2243 setSSELevel(Features, SSE2, Enabled);
2244 } else if (Name == "avx")
2245 setSSELevel(Features, AVX, Enabled);
2246 else if (Name == "avx2")
2247 setSSELevel(Features, AVX2, Enabled);
Craig Topperbca2c4f2013-08-21 05:29:10 +00002248 else if (Name == "avx512f")
Craig Topperb7a95d22013-08-21 03:59:22 +00002249 setSSELevel(Features, AVX512F, Enabled);
Craig Topperbca2c4f2013-08-21 05:29:10 +00002250 else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf") {
2251 if (Enabled)
2252 setSSELevel(Features, AVX512F, Enabled);
2253 } else if (Name == "fma") {
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002254 if (Enabled)
2255 setSSELevel(Features, AVX, Enabled);
2256 } else if (Name == "fma4") {
2257 setXOPLevel(Features, FMA4, Enabled);
2258 } else if (Name == "xop") {
2259 setXOPLevel(Features, XOP, Enabled);
2260 } else if (Name == "sse4a") {
2261 setXOPLevel(Features, SSE4A, Enabled);
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002262 }
Daniel Dunbar17ca3632009-05-06 21:07:50 +00002263}
2264
Daniel Dunbar868bd0a2009-05-06 03:16:41 +00002265/// HandleTargetOptions - Perform initialization based on the user
2266/// configured set of features.
Rafael Espindola5389b842013-08-21 21:59:03 +00002267bool X86TargetInfo::HandleTargetFeatures(std::vector<std::string> &Features,
2268 DiagnosticsEngine &Diags) {
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002269 // Remember the maximum enabled sselevel.
2270 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2271 // Ignore disabled features.
2272 if (Features[i][0] == '-')
2273 continue;
2274
Benjamin Kramer713575a2012-03-05 15:10:44 +00002275 StringRef Feature = StringRef(Features[i]).substr(1);
2276
2277 if (Feature == "aes") {
Eric Christophereea12d12010-04-02 23:50:19 +00002278 HasAES = true;
2279 continue;
2280 }
2281
Craig Topper3c0bc152012-05-31 05:18:48 +00002282 if (Feature == "pclmul") {
2283 HasPCLMUL = true;
2284 continue;
2285 }
2286
Benjamin Kramer713575a2012-03-05 15:10:44 +00002287 if (Feature == "lzcnt") {
Craig Topper31ceea02011-12-25 05:06:45 +00002288 HasLZCNT = true;
2289 continue;
2290 }
2291
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002292 if (Feature == "rdrnd") {
Benjamin Kramer84f30802012-07-07 09:39:18 +00002293 HasRDRND = true;
2294 continue;
2295 }
2296
Benjamin Kramer713575a2012-03-05 15:10:44 +00002297 if (Feature == "bmi") {
Craig Topper31ceea02011-12-25 05:06:45 +00002298 HasBMI = true;
2299 continue;
2300 }
2301
Benjamin Kramer713575a2012-03-05 15:10:44 +00002302 if (Feature == "bmi2") {
Craig Topper31ceea02011-12-25 05:06:45 +00002303 HasBMI2 = true;
2304 continue;
2305 }
2306
Benjamin Kramer713575a2012-03-05 15:10:44 +00002307 if (Feature == "popcnt") {
Craig Toppere14e08b2011-12-29 16:10:46 +00002308 HasPOPCNT = true;
2309 continue;
2310 }
2311
Michael Liao463eb892012-11-10 05:17:46 +00002312 if (Feature == "rtm") {
2313 HasRTM = true;
2314 continue;
2315 }
2316
Michael Liao72339a02013-03-26 17:52:08 +00002317 if (Feature == "prfchw") {
2318 HasPRFCHW = true;
2319 continue;
2320 }
2321
Michael Liao1bfc28c2013-03-29 05:17:55 +00002322 if (Feature == "rdseed") {
2323 HasRDSEED = true;
2324 continue;
2325 }
2326
Craig Topper2ae95072012-06-03 21:46:30 +00002327 if (Feature == "fma") {
2328 HasFMA = true;
2329 continue;
2330 }
2331
Manman Ren146e5a42012-10-11 00:59:55 +00002332 if (Feature == "f16c") {
2333 HasF16C = true;
2334 continue;
2335 }
2336
Craig Topperbca2c4f2013-08-21 05:29:10 +00002337 if (Feature == "avx512cd") {
2338 HasAVX512CD = true;
2339 continue;
2340 }
2341
2342 if (Feature == "avx512er") {
2343 HasAVX512ER = true;
2344 continue;
2345 }
2346
2347 if (Feature == "avx512pf") {
2348 HasAVX512PF = true;
2349 continue;
2350 }
2351
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002352 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer713575a2012-03-05 15:10:44 +00002353 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topperbca2c4f2013-08-21 05:29:10 +00002354 .Case("avx512f", AVX512F)
Craig Topper05fe4b52012-01-09 09:19:09 +00002355 .Case("avx2", AVX2)
2356 .Case("avx", AVX)
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002357 .Case("sse4.2", SSE42)
2358 .Case("sse4.1", SSE41)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002359 .Case("ssse3", SSSE3)
Nuno Lopes33d3bca2010-03-12 10:20:09 +00002360 .Case("sse3", SSE3)
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002361 .Case("sse2", SSE2)
2362 .Case("sse", SSE1)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002363 .Default(NoSSE);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002364 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer20249a12010-10-21 03:16:25 +00002365
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002366 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer713575a2012-03-05 15:10:44 +00002367 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002368 .Case("3dnowa", AMD3DNowAthlon)
2369 .Case("3dnow", AMD3DNow)
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002370 .Case("mmx", MMX)
2371 .Default(NoMMX3DNow);
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002372 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002373
2374 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2375 .Case("xop", XOP)
2376 .Case("fma4", FMA4)
2377 .Case("sse4a", SSE4A)
2378 .Default(NoXOP);
2379 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar29a790b2009-11-11 09:38:56 +00002380 }
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002381
Rafael Espindola5389b842013-08-21 21:59:03 +00002382 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2383 // matches the selected sse level.
2384 if (FPMath == FP_SSE && SSELevel < SSE1) {
2385 Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2386 return false;
2387 } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2388 Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2389 return false;
2390 }
2391
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002392 // Don't tell the backend if we're turning off mmx; it will end up disabling
2393 // SSE, which we don't want.
2394 std::vector<std::string>::iterator it;
2395 it = std::find(Features.begin(), Features.end(), "-mmx");
2396 if (it != Features.end())
2397 Features.erase(it);
Rafael Espindola5389b842013-08-21 21:59:03 +00002398 return true;
Chris Lattner3daed522009-03-02 22:20:04 +00002399}
Chris Lattnerc0f59212009-03-02 22:27:17 +00002400
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002401/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2402/// definitions for this particular subtarget.
Chris Lattner33328642009-03-20 15:52:06 +00002403void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002404 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00002405 // Target identification.
Derek Schuffbabaf312012-10-11 15:52:22 +00002406 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramera9992772010-01-09 17:55:51 +00002407 Builder.defineMacro("__amd64__");
2408 Builder.defineMacro("__amd64");
2409 Builder.defineMacro("__x86_64");
2410 Builder.defineMacro("__x86_64__");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002411 } else {
Benjamin Kramera9992772010-01-09 17:55:51 +00002412 DefineStd(Builder, "i386", Opts);
Chris Lattnerc0f59212009-03-02 22:27:17 +00002413 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002414
Chris Lattnerc0f59212009-03-02 22:27:17 +00002415 // Subtarget options.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002416 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2417 // truly should be based on -mtune options.
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002418 switch (CPU) {
2419 case CK_Generic:
2420 break;
2421 case CK_i386:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002422 // The rest are coming from the i386 define above.
2423 Builder.defineMacro("__tune_i386__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002424 break;
2425 case CK_i486:
2426 case CK_WinChipC6:
2427 case CK_WinChip2:
2428 case CK_C3:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002429 defineCPUMacros(Builder, "i486");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002430 break;
Chandler Carruthf17ba332011-09-28 09:45:05 +00002431 case CK_PentiumMMX:
2432 Builder.defineMacro("__pentium_mmx__");
2433 Builder.defineMacro("__tune_pentium_mmx__");
2434 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002435 case CK_i586:
2436 case CK_Pentium:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002437 defineCPUMacros(Builder, "i586");
2438 defineCPUMacros(Builder, "pentium");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002439 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002440 case CK_Pentium3:
2441 case CK_Pentium3M:
2442 case CK_PentiumM:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002443 Builder.defineMacro("__tune_pentium3__");
2444 // Fallthrough
2445 case CK_Pentium2:
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002446 case CK_C3_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002447 Builder.defineMacro("__tune_pentium2__");
2448 // Fallthrough
2449 case CK_PentiumPro:
2450 Builder.defineMacro("__tune_i686__");
2451 Builder.defineMacro("__tune_pentiumpro__");
2452 // Fallthrough
2453 case CK_i686:
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002454 Builder.defineMacro("__i686");
2455 Builder.defineMacro("__i686__");
2456 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2457 Builder.defineMacro("__pentiumpro");
2458 Builder.defineMacro("__pentiumpro__");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002459 break;
2460 case CK_Pentium4:
2461 case CK_Pentium4M:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002462 defineCPUMacros(Builder, "pentium4");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002463 break;
2464 case CK_Yonah:
2465 case CK_Prescott:
2466 case CK_Nocona:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002467 defineCPUMacros(Builder, "nocona");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002468 break;
2469 case CK_Core2:
2470 case CK_Penryn:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002471 defineCPUMacros(Builder, "core2");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002472 break;
2473 case CK_Atom:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002474 defineCPUMacros(Builder, "atom");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002475 break;
2476 case CK_Corei7:
2477 case CK_Corei7AVX:
2478 case CK_CoreAVXi:
Craig Topper2b03bb02011-12-17 19:55:21 +00002479 case CK_CoreAVX2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002480 defineCPUMacros(Builder, "corei7");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002481 break;
Craig Topper10c2c682013-08-20 07:09:39 +00002482 case CK_KNL:
2483 defineCPUMacros(Builder, "knl");
2484 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002485 case CK_K6_2:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002486 Builder.defineMacro("__k6_2__");
2487 Builder.defineMacro("__tune_k6_2__");
2488 // Fallthrough
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002489 case CK_K6_3:
Chandler Carruthf17ba332011-09-28 09:45:05 +00002490 if (CPU != CK_K6_2) { // In case of fallthrough
2491 // FIXME: GCC may be enabling these in cases where some other k6
2492 // architecture is specified but -m3dnow is explicitly provided. The
2493 // exact semantics need to be determined and emulated here.
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002494 Builder.defineMacro("__k6_3__");
2495 Builder.defineMacro("__tune_k6_3__");
2496 }
Chandler Carruthf17ba332011-09-28 09:45:05 +00002497 // Fallthrough
2498 case CK_K6:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002499 defineCPUMacros(Builder, "k6");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002500 break;
2501 case CK_Athlon:
2502 case CK_AthlonThunderbird:
2503 case CK_Athlon4:
2504 case CK_AthlonXP:
2505 case CK_AthlonMP:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002506 defineCPUMacros(Builder, "athlon");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002507 if (SSELevel != NoSSE) {
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002508 Builder.defineMacro("__athlon_sse__");
Chandler Carruth53bf4f92011-09-28 09:54:11 +00002509 Builder.defineMacro("__tune_athlon_sse__");
2510 }
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002511 break;
2512 case CK_K8:
2513 case CK_K8SSE3:
2514 case CK_x86_64:
2515 case CK_Opteron:
2516 case CK_OpteronSSE3:
2517 case CK_Athlon64:
2518 case CK_Athlon64SSE3:
2519 case CK_AthlonFX:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002520 defineCPUMacros(Builder, "k8");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002521 break;
Roman Divacky01c770d2011-10-30 07:48:46 +00002522 case CK_AMDFAM10:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002523 defineCPUMacros(Builder, "amdfam10");
Roman Divacky01c770d2011-10-30 07:48:46 +00002524 break;
Benjamin Kramer5660aa62012-01-10 11:50:18 +00002525 case CK_BTVER1:
2526 defineCPUMacros(Builder, "btver1");
2527 break;
Benjamin Kramer63063f52013-05-03 10:47:15 +00002528 case CK_BTVER2:
2529 defineCPUMacros(Builder, "btver2");
2530 break;
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002531 case CK_BDVER1:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002532 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002533 break;
2534 case CK_BDVER2:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002535 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer61ea4fe2011-12-01 18:23:59 +00002536 break;
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002537 case CK_Geode:
Benjamin Kramer448f68d2012-01-10 11:50:09 +00002538 defineCPUMacros(Builder, "geode");
Chandler Carruthd9d3ddf2011-09-28 08:55:37 +00002539 break;
Chandler Carruthf6cf1c22011-09-28 02:59:25 +00002540 }
Chris Lattner84f0ea82009-03-02 22:40:39 +00002541
Chandler Carruth88c75b02011-09-28 09:54:07 +00002542 // Target properties.
2543 Builder.defineMacro("__LITTLE_ENDIAN__");
2544 Builder.defineMacro("__REGISTER_PREFIX__", "");
2545
Chris Lattner54175442009-04-19 17:32:33 +00002546 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2547 // functions in glibc header files that use FP Stack inline asm which the
2548 // backend can't deal with (PR879).
Benjamin Kramera9992772010-01-09 17:55:51 +00002549 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002550
Chandler Carruth88c75b02011-09-28 09:54:07 +00002551 if (HasAES)
2552 Builder.defineMacro("__AES__");
2553
Craig Topper3c0bc152012-05-31 05:18:48 +00002554 if (HasPCLMUL)
2555 Builder.defineMacro("__PCLMUL__");
2556
Craig Topper31ceea02011-12-25 05:06:45 +00002557 if (HasLZCNT)
2558 Builder.defineMacro("__LZCNT__");
2559
Benjamin Kramer84f30802012-07-07 09:39:18 +00002560 if (HasRDRND)
2561 Builder.defineMacro("__RDRND__");
2562
Craig Topper31ceea02011-12-25 05:06:45 +00002563 if (HasBMI)
2564 Builder.defineMacro("__BMI__");
2565
2566 if (HasBMI2)
2567 Builder.defineMacro("__BMI2__");
2568
Craig Toppere14e08b2011-12-29 16:10:46 +00002569 if (HasPOPCNT)
2570 Builder.defineMacro("__POPCNT__");
2571
Michael Liao463eb892012-11-10 05:17:46 +00002572 if (HasRTM)
2573 Builder.defineMacro("__RTM__");
2574
Michael Liao72339a02013-03-26 17:52:08 +00002575 if (HasPRFCHW)
2576 Builder.defineMacro("__PRFCHW__");
2577
Michael Liao1bfc28c2013-03-29 05:17:55 +00002578 if (HasRDSEED)
2579 Builder.defineMacro("__RDSEED__");
2580
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002581 switch (XOPLevel) {
2582 case XOP:
2583 Builder.defineMacro("__XOP__");
2584 case FMA4:
Craig Topper6a511e12011-12-30 07:33:42 +00002585 Builder.defineMacro("__FMA4__");
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002586 case SSE4A:
2587 Builder.defineMacro("__SSE4A__");
2588 case NoXOP:
2589 break;
2590 }
Craig Topper6a511e12011-12-30 07:33:42 +00002591
Craig Topper2ae95072012-06-03 21:46:30 +00002592 if (HasFMA)
2593 Builder.defineMacro("__FMA__");
2594
Manman Ren146e5a42012-10-11 00:59:55 +00002595 if (HasF16C)
2596 Builder.defineMacro("__F16C__");
2597
Craig Topperbca2c4f2013-08-21 05:29:10 +00002598 if (HasAVX512CD)
2599 Builder.defineMacro("__AVX512CD__");
2600 if (HasAVX512ER)
2601 Builder.defineMacro("__AVX512ER__");
2602 if (HasAVX512PF)
2603 Builder.defineMacro("__AVX512PF__");
2604
Chris Lattner84f0ea82009-03-02 22:40:39 +00002605 // Each case falls through to the previous one here.
2606 switch (SSELevel) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002607 case AVX512F:
Craig Topper42f98732013-08-20 07:39:54 +00002608 Builder.defineMacro("__AVX512F__");
Craig Topper05fe4b52012-01-09 09:19:09 +00002609 case AVX2:
2610 Builder.defineMacro("__AVX2__");
2611 case AVX:
2612 Builder.defineMacro("__AVX__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002613 case SSE42:
Benjamin Kramera9992772010-01-09 17:55:51 +00002614 Builder.defineMacro("__SSE4_2__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002615 case SSE41:
Benjamin Kramera9992772010-01-09 17:55:51 +00002616 Builder.defineMacro("__SSE4_1__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002617 case SSSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002618 Builder.defineMacro("__SSSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002619 case SSE3:
Benjamin Kramera9992772010-01-09 17:55:51 +00002620 Builder.defineMacro("__SSE3__");
Chris Lattner84f0ea82009-03-02 22:40:39 +00002621 case SSE2:
Benjamin Kramera9992772010-01-09 17:55:51 +00002622 Builder.defineMacro("__SSE2__");
2623 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner84f0ea82009-03-02 22:40:39 +00002624 case SSE1:
Benjamin Kramera9992772010-01-09 17:55:51 +00002625 Builder.defineMacro("__SSE__");
2626 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002627 case NoSSE:
Chris Lattner84f0ea82009-03-02 22:40:39 +00002628 break;
2629 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00002630
Derek Schuffbabaf312012-10-11 15:52:22 +00002631 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002632 switch (SSELevel) {
Craig Topperb7a95d22013-08-21 03:59:22 +00002633 case AVX512F:
Craig Topper05fe4b52012-01-09 09:19:09 +00002634 case AVX2:
2635 case AVX:
Michael J. Spencera764e832010-10-21 08:22:51 +00002636 case SSE42:
2637 case SSE41:
2638 case SSSE3:
2639 case SSE3:
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002640 case SSE2:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002641 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002642 break;
2643 case SSE1:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002644 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002645 break;
2646 default:
Chris Lattner5f9e2722011-07-23 10:55:15 +00002647 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002648 }
2649 }
2650
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002651 // Each case falls through to the previous one here.
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002652 switch (MMX3DNowLevel) {
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002653 case AMD3DNowAthlon:
2654 Builder.defineMacro("__3dNOW_A__");
2655 case AMD3DNow:
2656 Builder.defineMacro("__3dNOW__");
Eli Friedmanc3e0fb42011-07-08 23:31:17 +00002657 case MMX:
2658 Builder.defineMacro("__MMX__");
2659 case NoMMX3DNow:
Anders Carlsson9b0fb622010-01-27 03:47:49 +00002660 break;
2661 }
Michael J. Spencerd1b33942013-04-04 23:53:43 +00002662
2663 if (CPU >= CK_i486) {
2664 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
2665 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
2666 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
2667 }
2668 if (CPU >= CK_i586)
2669 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerc0f59212009-03-02 22:27:17 +00002670}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002671
Douglas Gregore727d212012-01-30 06:38:25 +00002672bool X86TargetInfo::hasFeature(StringRef Feature) const {
2673 return llvm::StringSwitch<bool>(Feature)
2674 .Case("aes", HasAES)
2675 .Case("avx", SSELevel >= AVX)
2676 .Case("avx2", SSELevel >= AVX2)
Craig Topperb7a95d22013-08-21 03:59:22 +00002677 .Case("avx512f", SSELevel >= AVX512F)
Craig Topperbca2c4f2013-08-21 05:29:10 +00002678 .Case("avx512cd", HasAVX512CD)
2679 .Case("avx512er", HasAVX512ER)
2680 .Case("avx512pf", HasAVX512PF)
Douglas Gregore727d212012-01-30 06:38:25 +00002681 .Case("bmi", HasBMI)
2682 .Case("bmi2", HasBMI2)
Craig Topper2ae95072012-06-03 21:46:30 +00002683 .Case("fma", HasFMA)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002684 .Case("fma4", XOPLevel >= FMA4)
Douglas Gregore727d212012-01-30 06:38:25 +00002685 .Case("lzcnt", HasLZCNT)
Benjamin Kramer84f30802012-07-07 09:39:18 +00002686 .Case("rdrnd", HasRDRND)
Douglas Gregore727d212012-01-30 06:38:25 +00002687 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
2688 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
2689 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3c0bc152012-05-31 05:18:48 +00002690 .Case("pclmul", HasPCLMUL)
Douglas Gregore727d212012-01-30 06:38:25 +00002691 .Case("popcnt", HasPOPCNT)
Michael Liao463eb892012-11-10 05:17:46 +00002692 .Case("rtm", HasRTM)
Michael Liao72339a02013-03-26 17:52:08 +00002693 .Case("prfchw", HasPRFCHW)
Michael Liao1bfc28c2013-03-29 05:17:55 +00002694 .Case("rdseed", HasRDSEED)
Douglas Gregore727d212012-01-30 06:38:25 +00002695 .Case("sse", SSELevel >= SSE1)
2696 .Case("sse2", SSELevel >= SSE2)
2697 .Case("sse3", SSELevel >= SSE3)
2698 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola81cde9e2013-08-23 20:21:37 +00002699 .Case("sse4.1", SSELevel >= SSE41)
2700 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002701 .Case("sse4a", XOPLevel >= SSE4A)
Douglas Gregore727d212012-01-30 06:38:25 +00002702 .Case("x86", true)
Derek Schuffbabaf312012-10-11 15:52:22 +00002703 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
2704 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolaf6fe72b2013-08-20 13:44:29 +00002705 .Case("xop", XOPLevel >= XOP)
Manman Ren146e5a42012-10-11 00:59:55 +00002706 .Case("f16c", HasF16C)
Douglas Gregore727d212012-01-30 06:38:25 +00002707 .Default(false);
2708}
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002709
Eli Friedman618234a2008-08-20 02:34:37 +00002710bool
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002711X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00002712 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00002713 switch (*Name) {
Eli Friedman618234a2008-08-20 02:34:37 +00002714 default: return false;
Dale Johannesen545be512010-08-24 22:33:12 +00002715 case 'Y': // first letter of a pair:
2716 switch (*(Name+1)) {
2717 default: return false;
2718 case '0': // First SSE register.
2719 case 't': // Any SSE register, when SSE2 is enabled.
2720 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
2721 case 'm': // any MMX register, when inter-unit moves enabled.
2722 break; // falls through to setAllowsRegister.
2723 }
Eli Friedman618234a2008-08-20 02:34:37 +00002724 case 'a': // eax.
2725 case 'b': // ebx.
2726 case 'c': // ecx.
2727 case 'd': // edx.
2728 case 'S': // esi.
2729 case 'D': // edi.
2730 case 'A': // edx:eax.
Dale Johannesen545be512010-08-24 22:33:12 +00002731 case 'f': // any x87 floating point stack register.
Eli Friedman618234a2008-08-20 02:34:37 +00002732 case 't': // top of floating point stack.
2733 case 'u': // second from top of floating point stack.
2734 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlssonfce09342008-10-06 00:41:45 +00002735 case 'y': // Any MMX register.
Anders Carlssona7406d42008-10-06 19:17:39 +00002736 case 'x': // Any SSE register.
Eli Friedman618234a2008-08-20 02:34:37 +00002737 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen545be512010-08-24 22:33:12 +00002738 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
2739 case 'l': // "Index" registers: any general register that can be used as an
2740 // index in a base+index memory access.
2741 Info.setAllowsRegister();
2742 return true;
2743 case 'C': // SSE floating point constant.
2744 case 'G': // x87 floating point constant.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002745 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002746 // x86_64 instructions.
Anton Korobeynikova7c47172009-05-03 13:42:53 +00002747 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlsson79bc64c2009-01-24 18:03:09 +00002748 // x86_64 instructions.
Eli Friedman618234a2008-08-20 02:34:37 +00002749 return true;
2750 }
2751}
2752
Dale Johannesenf6e2c202010-10-29 23:12:32 +00002753
Eli Friedman618234a2008-08-20 02:34:37 +00002754std::string
Stuart Hastings002333f2011-06-07 23:45:05 +00002755X86TargetInfo::convertConstraint(const char *&Constraint) const {
2756 switch (*Constraint) {
Eli Friedman618234a2008-08-20 02:34:37 +00002757 case 'a': return std::string("{ax}");
2758 case 'b': return std::string("{bx}");
2759 case 'c': return std::string("{cx}");
2760 case 'd': return std::string("{dx}");
2761 case 'S': return std::string("{si}");
2762 case 'D': return std::string("{di}");
Dale Johannesencee55012010-10-22 21:07:10 +00002763 case 'p': // address
2764 return std::string("im");
Eli Friedman618234a2008-08-20 02:34:37 +00002765 case 't': // top of floating point stack.
2766 return std::string("{st}");
2767 case 'u': // second from top of floating point stack.
2768 return std::string("{st(1)}"); // second from top of floating point stack.
2769 default:
Stuart Hastings002333f2011-06-07 23:45:05 +00002770 return std::string(1, *Constraint);
Eli Friedman618234a2008-08-20 02:34:37 +00002771 }
2772}
Eli Friedman618234a2008-08-20 02:34:37 +00002773} // end anonymous namespace
Reid Spencer5f016e22007-07-11 17:01:13 +00002774
2775namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00002776// X86-32 generic target
2777class X86_32TargetInfo : public X86TargetInfo {
Reid Spencer5f016e22007-07-11 17:01:13 +00002778public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002779 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002780 DoubleAlign = LongLongAlign = 32;
2781 LongDoubleWidth = 96;
2782 LongDoubleAlign = 32;
Nick Lewycky9bddf432011-12-21 04:25:47 +00002783 SuitableAlign = 128;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002784 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2785 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hames567c6002011-10-11 00:52:51 +00002786 "a0:0:64-f80:32:32-n8:16:32-S128";
Eli Friedman1afabd92009-03-29 20:31:09 +00002787 SizeType = UnsignedInt;
2788 PtrDiffType = SignedInt;
2789 IntPtrType = SignedInt;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00002790 RegParmMax = 3;
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00002791
2792 // Use fpret for all types.
2793 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
2794 (1 << TargetInfo::Double) |
2795 (1 << TargetInfo::LongDouble));
Eli Friedman2be46072011-10-14 20:59:01 +00002796
2797 // x86-32 has atomics up to 8 bytes
2798 // FIXME: Check that we actually have cmpxchg8b before setting
2799 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
2800 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman618234a2008-08-20 02:34:37 +00002801 }
Meador Ingec5613b22012-06-16 03:34:49 +00002802 virtual BuiltinVaListKind getBuiltinVaListKind() const {
2803 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman618234a2008-08-20 02:34:37 +00002804 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00002805
Chris Lattner21fb98e2009-09-23 06:06:36 +00002806 int getEHDataRegisterNumber(unsigned RegNo) const {
2807 if (RegNo == 0) return 0;
2808 if (RegNo == 1) return 2;
2809 return -1;
2810 }
Bill Wendling68fd6082012-11-12 06:42:51 +00002811 virtual bool validateInputSize(StringRef Constraint,
2812 unsigned Size) const {
2813 switch (Constraint[0]) {
2814 default: break;
2815 case 'a':
2816 case 'b':
2817 case 'c':
2818 case 'd':
Bill Wendlingf634bdf2012-11-12 18:52:32 +00002819 return Size <= 32;
Bill Wendling68fd6082012-11-12 06:42:51 +00002820 }
2821
2822 return true;
2823 }
Eli Friedman618234a2008-08-20 02:34:37 +00002824};
2825} // end anonymous namespace
2826
2827namespace {
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002828class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
2829public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002830 NetBSDI386TargetInfo(const llvm::Triple &Triple)
2831 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger42378be2012-01-06 18:32:26 +00002832
2833 virtual unsigned getFloatEvalMethod() const {
2834 // NetBSD defaults to "double" rounding
2835 return 1;
2836 }
2837};
2838} // end anonymous namespace
2839
2840namespace {
Eli Friedman624c1462009-07-05 18:47:56 +00002841class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
2842public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002843 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
2844 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman624c1462009-07-05 18:47:56 +00002845 SizeType = UnsignedLong;
2846 IntPtrType = SignedLong;
Eli Friedman6036ebe2009-07-05 22:31:18 +00002847 PtrDiffType = SignedLong;
Eli Friedman624c1462009-07-05 18:47:56 +00002848 }
2849};
2850} // end anonymous namespace
2851
2852namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00002853class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
2854public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002855 BitrigI386TargetInfo(const llvm::Triple &Triple)
2856 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman42f74f22012-08-08 23:57:20 +00002857 SizeType = UnsignedLong;
2858 IntPtrType = SignedLong;
2859 PtrDiffType = SignedLong;
2860 }
2861};
2862} // end anonymous namespace
2863
2864namespace {
Torok Edwin5f6c1942009-06-30 17:10:35 +00002865class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman618234a2008-08-20 02:34:37 +00002866public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002867 DarwinI386TargetInfo(const llvm::Triple &Triple)
2868 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman618234a2008-08-20 02:34:37 +00002869 LongDoubleWidth = 128;
2870 LongDoubleAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00002871 SuitableAlign = 128;
Chad Rosierf9e9af72012-07-13 23:57:43 +00002872 MaxVectorAlign = 256;
Eli Friedman1afabd92009-03-29 20:31:09 +00002873 SizeType = UnsignedLong;
2874 IntPtrType = SignedLong;
Eli Friedmaned855cb2008-08-21 00:13:15 +00002875 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2876 "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002877 "a0:0:64-f80:128:128-n8:16:32-S128";
Daniel Dunbar613fd672010-05-27 00:35:16 +00002878 HasAlignMac68kSupport = true;
Torok Edwinb0a5b242009-06-30 17:00:25 +00002879 }
2880
Eli Friedman618234a2008-08-20 02:34:37 +00002881};
Daniel Dunbarf7b8eec2009-06-29 20:52:51 +00002882} // end anonymous namespace
2883
2884namespace {
Eli Friedman29a30502008-08-21 01:40:19 +00002885// x86-32 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00002886class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedman29a30502008-08-21 01:40:19 +00002887public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002888 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
2889 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmanb030f022009-04-19 21:38:35 +00002890 TLSSupported = false;
Chris Lattner85de9e72009-06-24 17:12:15 +00002891 WCharType = UnsignedShort;
Eli Friedman9c2f84e2009-06-08 21:16:17 +00002892 DoubleAlign = LongLongAlign = 64;
2893 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 +00002894 "i64:64:64-f32:32:32-f64:64:64-f80:128:128-v64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002895 "v128:128:128-a0:0:64-f80:32:32-n8:16:32-S32";
Eli Friedman29a30502008-08-21 01:40:19 +00002896 }
Michael J. Spencera764e832010-10-21 08:22:51 +00002897 virtual void getTargetDefines(const LangOptions &Opts,
2898 MacroBuilder &Builder) const {
2899 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
2900 }
2901};
2902} // end anonymous namespace
2903
2904namespace {
2905
2906// x86-32 Windows Visual Studio target
2907class VisualStudioWindowsX86_32TargetInfo : public WindowsX86_32TargetInfo {
2908public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002909 VisualStudioWindowsX86_32TargetInfo(const llvm::Triple &Triple)
2910 : WindowsX86_32TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00002911 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencera764e832010-10-21 08:22:51 +00002912 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
2913 }
2914 virtual void getTargetDefines(const LangOptions &Opts,
2915 MacroBuilder &Builder) const {
2916 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
2917 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
2918 // The value of the following reflects processor type.
2919 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
2920 // We lost the original triple, so we use the default.
2921 Builder.defineMacro("_M_IX86", "600");
2922 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002923};
2924} // end anonymous namespace
2925
2926namespace {
2927// x86-32 MinGW target
2928class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
2929public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002930 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
2931 : WindowsX86_32TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002932 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002933 MacroBuilder &Builder) const {
2934 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00002935 DefineStd(Builder, "WIN32", Opts);
2936 DefineStd(Builder, "WINNT", Opts);
2937 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002938 Builder.defineMacro("__MSVCRT__");
2939 Builder.defineMacro("__MINGW32__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002940
2941 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
2942 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00002943 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00002944 // Provide "as-is" __declspec.
2945 Builder.defineMacro("__declspec", "__declspec");
2946 else
2947 // Provide alias of __attribute__ like mingw32-gcc.
2948 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002949 }
2950};
2951} // end anonymous namespace
2952
2953namespace {
2954// x86-32 Cygwin target
2955class CygwinX86_32TargetInfo : public X86_32TargetInfo {
2956public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002957 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
2958 : X86_32TargetInfo(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002959 TLSSupported = false;
2960 WCharType = UnsignedShort;
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002961 DoubleAlign = LongLongAlign = 64;
2962 DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
2963 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00002964 "a0:0:64-f80:32:32-n8:16:32-S32";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00002965 }
2966 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00002967 MacroBuilder &Builder) const {
2968 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumie72f4d92012-12-14 10:17:26 +00002969 Builder.defineMacro("_X86_");
Benjamin Kramera9992772010-01-09 17:55:51 +00002970 Builder.defineMacro("__CYGWIN__");
2971 Builder.defineMacro("__CYGWIN32__");
2972 DefineStd(Builder, "unix", Opts);
Douglas Gregor2b003fd2010-04-21 05:52:38 +00002973 if (Opts.CPlusPlus)
2974 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanabc4e322009-06-08 06:11:14 +00002975 }
Eli Friedman29a30502008-08-21 01:40:19 +00002976};
2977} // end anonymous namespace
2978
2979namespace {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002980// x86-32 Haiku target
2981class HaikuX86_32TargetInfo : public X86_32TargetInfo {
2982public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00002983 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattner86ed3a32010-04-11 19:29:39 +00002984 SizeType = UnsignedLong;
Chris Lattnerfe1ea7b2010-04-22 17:48:00 +00002985 IntPtrType = SignedLong;
2986 PtrDiffType = SignedLong;
Eli Friedman6902e412012-11-27 02:58:24 +00002987 ProcessIDType = SignedLong;
Rafael Espindola19ddda82010-11-09 16:41:02 +00002988 this->UserLabelPrefix = "";
Benjamin Krameref7bcea2012-11-08 12:59:15 +00002989 this->TLSSupported = false;
Eli Friedmana7e68452010-08-22 01:00:03 +00002990 }
Chris Lattner86ed3a32010-04-11 19:29:39 +00002991 virtual void getTargetDefines(const LangOptions &Opts,
2992 MacroBuilder &Builder) const {
2993 X86_32TargetInfo::getTargetDefines(Opts, Builder);
2994 Builder.defineMacro("__INTEL__");
2995 Builder.defineMacro("__HAIKU__");
2996 }
2997};
2998} // end anonymous namespace
2999
Douglas Gregordca52262011-07-01 22:41:14 +00003000// RTEMS Target
3001template<typename Target>
3002class RTEMSTargetInfo : public OSTargetInfo<Target> {
3003protected:
3004 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3005 MacroBuilder &Builder) const {
3006 // RTEMS defines; list based off of gcc output
3007
Douglas Gregordca52262011-07-01 22:41:14 +00003008 Builder.defineMacro("__rtems__");
3009 Builder.defineMacro("__ELF__");
3010 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00003011
Douglas Gregordca52262011-07-01 22:41:14 +00003012public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003013 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3014 this->UserLabelPrefix = "";
Douglas Gregordca52262011-07-01 22:41:14 +00003015
Benjamin Kramer9df08232013-06-29 16:37:14 +00003016 switch (Triple.getArch()) {
3017 default:
3018 case llvm::Triple::x86:
3019 // this->MCountName = ".mcount";
3020 break;
3021 case llvm::Triple::mips:
3022 case llvm::Triple::mipsel:
3023 case llvm::Triple::ppc:
3024 case llvm::Triple::ppc64:
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00003025 case llvm::Triple::ppc64le:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003026 // this->MCountName = "_mcount";
3027 break;
3028 case llvm::Triple::arm:
3029 // this->MCountName = "__mcount";
3030 break;
Douglas Gregordca52262011-07-01 22:41:14 +00003031 }
Benjamin Kramer9df08232013-06-29 16:37:14 +00003032 }
Douglas Gregordca52262011-07-01 22:41:14 +00003033};
3034
3035namespace {
3036// x86-32 RTEMS target
3037class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3038public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003039 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregordca52262011-07-01 22:41:14 +00003040 SizeType = UnsignedLong;
3041 IntPtrType = SignedLong;
3042 PtrDiffType = SignedLong;
3043 this->UserLabelPrefix = "";
3044 }
3045 virtual void getTargetDefines(const LangOptions &Opts,
3046 MacroBuilder &Builder) const {
3047 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3048 Builder.defineMacro("__INTEL__");
3049 Builder.defineMacro("__rtems__");
3050 }
3051};
3052} // end anonymous namespace
3053
Chris Lattner86ed3a32010-04-11 19:29:39 +00003054namespace {
Eli Friedman618234a2008-08-20 02:34:37 +00003055// x86-64 generic target
3056class X86_64TargetInfo : public X86TargetInfo {
3057public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003058 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Chris Lattnerf291b102008-05-09 06:17:04 +00003059 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman61538a72008-05-20 14:21:01 +00003060 LongDoubleWidth = 128;
3061 LongDoubleAlign = 128;
Rafael Espindola6deecb02010-06-04 23:15:27 +00003062 LargeArrayMinWidth = 128;
3063 LargeArrayAlign = 128;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003064 SuitableAlign = 128;
Chris Lattner06ebe862009-02-05 07:32:46 +00003065 IntMaxType = SignedLong;
3066 UIntMaxType = UnsignedLong;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003067 Int64Type = SignedLong;
Anton Korobeynikov264a76c2009-04-03 23:38:25 +00003068 RegParmMax = 6;
Chris Lattner06ebe862009-02-05 07:32:46 +00003069
Eli Friedmaned855cb2008-08-21 00:13:15 +00003070 DescriptionString = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3071 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003072 "a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128";
Daniel Dunbardacf9dd2010-07-14 23:39:36 +00003073
3074 // Use fpret only for long double.
3075 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman2be46072011-10-14 20:59:01 +00003076
Anders Carlssoneea64802011-10-31 16:27:11 +00003077 // Use fp2ret for _Complex long double.
3078 ComplexLongDoubleUsesFP2Ret = true;
3079
Eli Friedman2be46072011-10-14 20:59:01 +00003080 // x86-64 has atomics up to 16 bytes.
3081 // FIXME: Once the backend is fixed, increase MaxAtomicInlineWidth to 128
3082 // on CPUs with cmpxchg16b
3083 MaxAtomicPromoteWidth = 128;
3084 MaxAtomicInlineWidth = 64;
Reid Spencer5f016e22007-07-11 17:01:13 +00003085 }
Meador Ingec5613b22012-06-16 03:34:49 +00003086 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3087 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson3346ae62007-11-24 23:38:12 +00003088 }
Michael J. Spencer237cf582010-10-18 07:10:59 +00003089
Chris Lattner21fb98e2009-09-23 06:06:36 +00003090 int getEHDataRegisterNumber(unsigned RegNo) const {
3091 if (RegNo == 0) return 0;
3092 if (RegNo == 1) return 1;
3093 return -1;
3094 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003095
3096 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
Charles Davise8519c32013-08-30 04:39:01 +00003097 return (CC == CC_C ||
3098 CC == CC_IntelOclBicc ||
3099 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003100 }
3101
Aaron Ballmanfff32482012-12-09 17:45:41 +00003102 virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const {
3103 return CC_C;
Aaron Ballman82bfa192012-10-02 14:26:08 +00003104 }
3105
Eli Friedman618234a2008-08-20 02:34:37 +00003106};
3107} // end anonymous namespace
3108
3109namespace {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003110// x86-64 Windows target
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003111class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003112public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003113 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3114 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003115 TLSSupported = false;
3116 WCharType = UnsignedShort;
Mike Stumpa55cce82009-10-08 23:00:00 +00003117 LongWidth = LongAlign = 32;
Michael J. Spencer237cf582010-10-18 07:10:59 +00003118 DoubleAlign = LongLongAlign = 64;
Nate Begemandbf8ea42010-07-21 02:02:56 +00003119 IntMaxType = SignedLongLong;
3120 UIntMaxType = UnsignedLongLong;
3121 Int64Type = SignedLongLong;
Cameron Esfahani1484e0d2010-09-15 00:28:12 +00003122 SizeType = UnsignedLongLong;
3123 PtrDiffType = SignedLongLong;
3124 IntPtrType = SignedLongLong;
NAKAMURA Takumi8c959d92011-01-17 22:56:08 +00003125 this->UserLabelPrefix = "";
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003126 }
3127 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003128 MacroBuilder &Builder) const {
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003129 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003130 Builder.defineMacro("_WIN64");
Michael J. Spencera764e832010-10-21 08:22:51 +00003131 }
Meador Ingec5613b22012-06-16 03:34:49 +00003132 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3133 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumi79521992011-01-17 22:56:23 +00003134 }
Charles Davise8519c32013-08-30 04:39:01 +00003135 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3136 return (CC == CC_C ||
3137 CC == CC_IntelOclBicc ||
3138 CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
3139 }
Michael J. Spencera764e832010-10-21 08:22:51 +00003140};
3141} // end anonymous namespace
3142
3143namespace {
3144// x86-64 Windows Visual Studio target
3145class VisualStudioWindowsX86_64TargetInfo : public WindowsX86_64TargetInfo {
3146public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003147 VisualStudioWindowsX86_64TargetInfo(const llvm::Triple &Triple)
3148 : WindowsX86_64TargetInfo(Triple) {
Eli Friedmand9c3fa32011-03-22 21:25:11 +00003149 LongDoubleWidth = LongDoubleAlign = 64;
3150 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencera764e832010-10-21 08:22:51 +00003151 }
3152 virtual void getTargetDefines(const LangOptions &Opts,
3153 MacroBuilder &Builder) const {
3154 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3155 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramera9992772010-01-09 17:55:51 +00003156 Builder.defineMacro("_M_X64");
Michael J. Spencerdae4ac42010-10-21 05:21:48 +00003157 Builder.defineMacro("_M_AMD64");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003158 }
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003159};
3160} // end anonymous namespace
3161
3162namespace {
3163// x86-64 MinGW target
3164class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3165public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003166 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3167 : WindowsX86_64TargetInfo(Triple) {}
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003168 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003169 MacroBuilder &Builder) const {
3170 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencera764e832010-10-21 08:22:51 +00003171 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00003172 Builder.defineMacro("__MSVCRT__");
NAKAMURA Takumi17c964a2011-03-08 12:06:46 +00003173 Builder.defineMacro("__MINGW32__");
Benjamin Kramera9992772010-01-09 17:55:51 +00003174 Builder.defineMacro("__MINGW64__");
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003175
3176 // mingw32-gcc provides __declspec(a) as alias of __attribute__((a)).
3177 // In contrast, clang-cc1 provides __declspec(a) with -fms-extensions.
Francois Pichet62ec1f22011-09-17 17:15:52 +00003178 if (Opts.MicrosoftExt)
NAKAMURA Takumi853134a2011-03-15 02:32:50 +00003179 // Provide "as-is" __declspec.
3180 Builder.defineMacro("__declspec", "__declspec");
3181 else
3182 // Provide alias of __attribute__ like mingw32-gcc.
3183 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00003184 }
3185};
3186} // end anonymous namespace
3187
3188namespace {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003189class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3190public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003191 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3192 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003193 Int64Type = SignedLongLong;
Chad Rosierf9e9af72012-07-13 23:57:43 +00003194 MaxVectorAlign = 256;
Eli Friedman3c7b6e42009-07-01 03:36:11 +00003195 }
3196};
3197} // end anonymous namespace
3198
3199namespace {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003200class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3201public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003202 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3203 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman6036ebe2009-07-05 22:31:18 +00003204 IntMaxType = SignedLongLong;
3205 UIntMaxType = UnsignedLongLong;
3206 Int64Type = SignedLongLong;
3207 }
3208};
3209} // end anonymous namespace
3210
3211namespace {
Eli Friedman42f74f22012-08-08 23:57:20 +00003212class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3213public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003214 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3215 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3216 IntMaxType = SignedLongLong;
3217 UIntMaxType = UnsignedLongLong;
3218 Int64Type = SignedLongLong;
Eli Friedman42f74f22012-08-08 23:57:20 +00003219 }
3220};
Tim Northoverc264e162013-01-31 12:13:10 +00003221}
3222
3223namespace {
3224class AArch64TargetInfo : public TargetInfo {
3225 static const char * const GCCRegNames[];
3226 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Tim Northoverff920ee2013-05-04 07:15:13 +00003227
Tim Northoverb793f0d2013-08-01 09:23:19 +00003228 enum FPUModeEnum {
3229 FPUMode,
3230 NeonMode
3231 };
3232
3233 unsigned FPU;
Tim Northoverff920ee2013-05-04 07:15:13 +00003234 static const Builtin::Info BuiltinInfo[];
Tim Northoverb793f0d2013-08-01 09:23:19 +00003235
Tim Northoverc264e162013-01-31 12:13:10 +00003236public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003237 AArch64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Tim Northoverc264e162013-01-31 12:13:10 +00003238 BigEndian = false;
3239 LongWidth = LongAlign = 64;
3240 LongDoubleWidth = LongDoubleAlign = 128;
3241 PointerWidth = PointerAlign = 64;
3242 SuitableAlign = 128;
3243 DescriptionString = "e-p:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3244 "i64:64:64-i128:128:128-f32:32:32-f64:64:64-"
3245 "f128:128:128-n32:64-S128";
3246
3247 WCharType = UnsignedInt;
3248 LongDoubleFormat = &llvm::APFloat::IEEEquad;
3249
Tim Northover6a93c862013-02-18 12:11:32 +00003250 // AArch64 backend supports 64-bit operations at the moment. In principle
3251 // 128-bit is possible if register-pairs are used.
3252 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
3253
Tim Northoverc264e162013-01-31 12:13:10 +00003254 TheCXXABI.set(TargetCXXABI::GenericAArch64);
3255 }
3256 virtual void getTargetDefines(const LangOptions &Opts,
3257 MacroBuilder &Builder) const {
3258 // GCC defines theses currently
3259 Builder.defineMacro("__aarch64__");
3260 Builder.defineMacro("__AARCH64EL__");
3261
3262 // ACLE predefines. Many can only have one possible value on v8 AArch64.
3263
3264 // FIXME: these were written based on an unreleased version of a 32-bit ACLE
3265 // which was intended to be compatible with a 64-bit implementation. They
3266 // will need updating when a real 64-bit ACLE exists. Particularly pressing
Tim Northoverdabcbf92013-04-05 14:08:55 +00003267 // instances are: __ARM_ARCH_ISA_ARM, __ARM_ARCH_ISA_THUMB, __ARM_PCS.
3268 Builder.defineMacro("__ARM_ACLE", "101");
3269 Builder.defineMacro("__ARM_ARCH", "8");
3270 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
Tim Northoverc264e162013-01-31 12:13:10 +00003271
Tim Northoverdabcbf92013-04-05 14:08:55 +00003272 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
3273 Builder.defineMacro("__ARM_FEATURE_CLZ");
3274 Builder.defineMacro("__ARM_FEATURE_FMA");
Tim Northoverc264e162013-01-31 12:13:10 +00003275
3276 // FIXME: ACLE 1.1 reserves bit 4. Will almost certainly come to mean
3277 // 128-bit LDXP present, at which point this becomes 0x1f.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003278 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xf");
Tim Northoverc264e162013-01-31 12:13:10 +00003279
3280 // 0xe implies support for half, single and double precision operations.
Tim Northoverdabcbf92013-04-05 14:08:55 +00003281 Builder.defineMacro("__ARM_FP", "0xe");
Tim Northoverc264e162013-01-31 12:13:10 +00003282
3283 // PCS specifies this for SysV variants, which is all we support. Other ABIs
Tim Northoverdabcbf92013-04-05 14:08:55 +00003284 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
3285 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
Tim Northoverc264e162013-01-31 12:13:10 +00003286
3287 if (Opts.FastMath || Opts.FiniteMathOnly)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003288 Builder.defineMacro("__ARM_FP_FAST");
Tim Northoverc264e162013-01-31 12:13:10 +00003289
3290 if ((Opts.C99 || Opts.C11) && !Opts.Freestanding)
Tim Northoverdabcbf92013-04-05 14:08:55 +00003291 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
Tim Northoverc264e162013-01-31 12:13:10 +00003292
Tim Northoverdabcbf92013-04-05 14:08:55 +00003293 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
Tim Northoverc264e162013-01-31 12:13:10 +00003294 Opts.ShortWChar ? "2" : "4");
3295
Tim Northoverdabcbf92013-04-05 14:08:55 +00003296 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
Tim Northoverc264e162013-01-31 12:13:10 +00003297 Opts.ShortEnums ? "1" : "4");
3298
3299 if (BigEndian)
Tim Northoverb793f0d2013-08-01 09:23:19 +00003300 Builder.defineMacro("__AARCH_BIG_ENDIAN");
3301
3302 if (FPU == NeonMode) {
3303 Builder.defineMacro("__AARCH_FEATURE_ADVSIMD");
3304
3305 // 64-bit NEON supports half, single and double precision operations.
3306 Builder.defineMacro("__AARCH_ADVSIMD_FP", "0xe");
3307 }
Tim Northoverc264e162013-01-31 12:13:10 +00003308 }
3309 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3310 unsigned &NumRecords) const {
Tim Northoverff920ee2013-05-04 07:15:13 +00003311 Records = BuiltinInfo;
3312 NumRecords = clang::AArch64::LastTSBuiltin-Builtin::FirstTSBuiltin;
Tim Northoverc264e162013-01-31 12:13:10 +00003313 }
3314 virtual bool hasFeature(StringRef Feature) const {
Tim Northoverb793f0d2013-08-01 09:23:19 +00003315 return Feature == "aarch64" || (Feature == "neon" && FPU == NeonMode);
Tim Northoverc264e162013-01-31 12:13:10 +00003316 }
Tim Northoverb793f0d2013-08-01 09:23:19 +00003317
Rafael Espindola5389b842013-08-21 21:59:03 +00003318 virtual bool HandleTargetFeatures(std::vector<std::string> &Features,
3319 DiagnosticsEngine &Diags) {
Tim Northoverb793f0d2013-08-01 09:23:19 +00003320 FPU = FPUMode;
3321 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3322 if (Features[i] == "+neon")
3323 FPU = NeonMode;
3324 }
Rafael Espindola5389b842013-08-21 21:59:03 +00003325 return true;
Tim Northoverb793f0d2013-08-01 09:23:19 +00003326 }
3327
3328 virtual void getGCCRegNames(const char *const *&Names,
Tim Northoverc264e162013-01-31 12:13:10 +00003329 unsigned &NumNames) const;
3330 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
3331 unsigned &NumAliases) const;
3332
3333 virtual bool isCLZForZeroUndef() const { return false; }
3334
3335 virtual bool validateAsmConstraint(const char *&Name,
3336 TargetInfo::ConstraintInfo &Info) const {
3337 switch (*Name) {
3338 default: return false;
3339 case 'w': // An FP/SIMD vector register
3340 Info.setAllowsRegister();
3341 return true;
3342 case 'I': // Constant that can be used with an ADD instruction
3343 case 'J': // Constant that can be used with a SUB instruction
3344 case 'K': // Constant that can be used with a 32-bit logical instruction
3345 case 'L': // Constant that can be used with a 64-bit logical instruction
3346 case 'M': // Constant that can be used as a 32-bit MOV immediate
3347 case 'N': // Constant that can be used as a 64-bit MOV immediate
3348 case 'Y': // Floating point constant zero
3349 case 'Z': // Integer constant zero
3350 return true;
3351 case 'Q': // A memory reference with base register and no offset
3352 Info.setAllowsMemory();
3353 return true;
3354 case 'S': // A symbolic address
3355 Info.setAllowsRegister();
3356 return true;
3357 case 'U':
3358 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
3359 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
3360 // Usa: An absolute symbolic address
3361 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
3362 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
3363 }
3364 }
3365
3366 virtual const char *getClobbers() const {
3367 // There are no AArch64 clobbers shared by all asm statements.
3368 return "";
3369 }
3370
3371 virtual BuiltinVaListKind getBuiltinVaListKind() const {
3372 return TargetInfo::AArch64ABIBuiltinVaList;
3373 }
3374};
3375
3376const char * const AArch64TargetInfo::GCCRegNames[] = {
3377 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7",
3378 "w8", "w9", "w10", "w11", "w12", "w13", "w14", "w15",
3379 "w16", "w17", "w18", "w19", "w20", "w21", "w22", "w23",
3380 "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp", "wzr",
3381
3382 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7",
3383 "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15",
3384 "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
3385 "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", "xzr",
3386
3387 "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7",
3388 "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15",
3389 "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23",
3390 "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31",
3391
3392 "h0", "h1", "h2", "h3", "h4", "h5", "h6", "h7",
3393 "h8", "h9", "h10", "h11", "h12", "h13", "h14", "h15",
3394 "h16", "h17", "h18", "h19", "h20", "h21", "h22", "h23",
3395 "h24", "h25", "h26", "h27", "h28", "h29", "h30", "h31",
3396
3397 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3398 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3399 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
3400 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
3401
3402 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3403 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
3404 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3405 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
3406
3407 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3408 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15",
3409 "q16", "q17", "q18", "q19", "q20", "q21", "q22", "q23",
3410 "q24", "q25", "q26", "q27", "q28", "q29", "q30", "q31"
3411};
3412
3413void AArch64TargetInfo::getGCCRegNames(const char * const *&Names,
3414 unsigned &NumNames) const {
3415 Names = GCCRegNames;
3416 NumNames = llvm::array_lengthof(GCCRegNames);
3417}
3418
3419const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
3420 { { "x16" }, "ip0"},
3421 { { "x17" }, "ip1"},
3422 { { "x29" }, "fp" },
3423 { { "x30" }, "lr" }
3424};
3425
3426void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3427 unsigned &NumAliases) const {
3428 Aliases = GCCRegAliases;
3429 NumAliases = llvm::array_lengthof(GCCRegAliases);
3430
3431}
Tim Northoverff920ee2013-05-04 07:15:13 +00003432
3433const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
3434#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
3435#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
3436 ALL_LANGUAGES },
3437#include "clang/Basic/BuiltinsAArch64.def"
3438};
3439
Eli Friedman42f74f22012-08-08 23:57:20 +00003440} // end anonymous namespace
3441
3442namespace {
Eli Friedmana9f54962008-08-20 07:44:10 +00003443class ARMTargetInfo : public TargetInfo {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003444 // Possible FPU choices.
3445 enum FPUMode {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003446 VFP2FPU = (1 << 0),
3447 VFP3FPU = (1 << 1),
3448 VFP4FPU = (1 << 2),
3449 NeonFPU = (1 << 3)
Daniel Dunbara91320b2009-12-21 23:28:17 +00003450 };
3451
3452 static bool FPUModeIsVFP(FPUMode Mode) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003453 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU);
Daniel Dunbara91320b2009-12-21 23:28:17 +00003454 }
3455
3456 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3457 static const char * const GCCRegNames[];
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003458
Daniel Dunbareac7c532009-12-18 18:42:37 +00003459 std::string ABI, CPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003460
Rafael Espindola5389b842013-08-21 21:59:03 +00003461 enum {
3462 FP_Default,
3463 FP_VFP,
3464 FP_Neon
3465 } FPMath;
3466
Bob Wilsoncfaab002012-09-29 23:52:52 +00003467 unsigned FPU : 4;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003468
Logan Chieneae5a8202012-10-10 06:56:20 +00003469 unsigned IsAAPCS : 1;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003470 unsigned IsThumb : 1;
3471
3472 // Initialized via features.
3473 unsigned SoftFloat : 1;
3474 unsigned SoftFloatABI : 1;
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003475
Chris Lattner2752c012010-03-03 19:03:45 +00003476 static const Builtin::Info BuiltinInfo[];
3477
Rafael Espindola620c0af2013-05-13 20:09:47 +00003478 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
3479 // On linux, binaries targeting old cpus call functions in libgcc to
3480 // perform atomic operations. The implementation in libgcc then calls into
3481 // the kernel which on armv6 and newer uses ldrex and strex. The net result
3482 // is that if we assume the kernel is at least as recent as the hardware,
3483 // it is safe to use atomic instructions on armv6 and newer.
Rafael Espindolae1e03422013-06-17 20:00:15 +00003484 if (T.getOS() != llvm::Triple::Linux &&
3485 T.getOS() != llvm::Triple::FreeBSD &&
3486 T.getOS() != llvm::Triple::Bitrig)
Ed Schouten04491632013-06-15 09:40:14 +00003487 return false;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003488 StringRef ArchName = T.getArchName();
Rafael Espindola69db5552013-05-14 00:44:24 +00003489 if (T.getArch() == llvm::Triple::arm) {
3490 if (!ArchName.startswith("armv"))
3491 return false;
3492 StringRef VersionStr = ArchName.substr(4);
3493 unsigned Version;
3494 if (VersionStr.getAsInteger(10, Version))
3495 return false;
3496 return Version >= 6;
3497 }
3498 assert(T.getArch() == llvm::Triple::thumb);
3499 if (!ArchName.startswith("thumbv"))
3500 return false;
3501 StringRef VersionStr = ArchName.substr(6);
3502 unsigned Version;
3503 if (VersionStr.getAsInteger(10, Version))
3504 return false;
3505 return Version >= 7;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003506 }
3507
Chris Lattner393ff042008-04-21 18:56:49 +00003508public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003509 ARMTargetInfo(const llvm::Triple &Triple)
3510 : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
Rafael Espindola5389b842013-08-21 21:59:03 +00003511 FPMath(FP_Default), IsAAPCS(true) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003512 BigEndian = false;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003513 SizeType = UnsignedInt;
3514 PtrDiffType = SignedInt;
James Molloya6d81f92011-11-23 13:35:08 +00003515 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3516 WCharType = UnsignedInt;
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003517
Chris Lattner9bffb072010-04-23 16:29:58 +00003518 // {} in inline assembly are neon specifiers, not assembly variant
3519 // specifiers.
3520 NoAsmVariants = true;
Michael J. Spencer20249a12010-10-21 03:16:25 +00003521
Daniel Dunbareac7c532009-12-18 18:42:37 +00003522 // FIXME: Should we just treat this as a feature?
Daniel Dunbar0791aa52009-12-18 19:57:13 +00003523 IsThumb = getTriple().getArchName().startswith("thumb");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003524 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003525 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3526 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003527 DescriptionString = ("e-p:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-"
3528 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003529 "v64:64:64-v128:64:128-a0:0:32-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003530 } else {
3531 DescriptionString = ("e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
3532 "i64:64:64-f32:32:32-f64:64:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003533 "v64:64:64-v128:64:128-a0:0:64-n32-S64");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003534 }
John McCallee79a4c2010-08-21 22:46:04 +00003535
3536 // ARM targets default to using the ARM C++ ABI.
John McCallb8b2c9d2013-01-25 22:30:49 +00003537 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman2be46072011-10-14 20:59:01 +00003538
3539 // ARM has atomics up to 8 bytes
Eli Friedman2be46072011-10-14 20:59:01 +00003540 MaxAtomicPromoteWidth = 64;
Rafael Espindola620c0af2013-05-13 20:09:47 +00003541 if (shouldUseInlineAtomic(getTriple()))
3542 MaxAtomicInlineWidth = 64;
James Molloye45b9b72012-03-12 09:14:10 +00003543
3544 // Do force alignment of members that follow zero length bitfields. If
3545 // the alignment of the zero-length bitfield is greater than the member
3546 // that follows it, `bar', `bar' will be aligned as the type of the
3547 // zero length bitfield.
3548 UseZeroLengthBitfieldAlignment = true;
Eli Friedman61538a72008-05-20 14:21:01 +00003549 }
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003550 virtual const char *getABI() const { return ABI.c_str(); }
Daniel Dunbara2a41612009-09-14 00:02:24 +00003551 virtual bool setABI(const std::string &Name) {
Daniel Dunbar018ba5a2009-09-14 00:35:03 +00003552 ABI = Name;
3553
Daniel Dunbara2a41612009-09-14 00:02:24 +00003554 // The defaults (above) are for AAPCS, check if we need to change them.
3555 //
3556 // FIXME: We need support for -meabi... we could just mangle it into the
3557 // name.
3558 if (Name == "apcs-gnu") {
Nick Lewycky7ec59c72011-12-16 22:34:14 +00003559 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindola27fa2362012-12-13 04:17:14 +00003560 // size_t is unsigned int on FreeBSD.
3561 if (getTriple().getOS() != llvm::Triple::FreeBSD)
3562 SizeType = UnsignedLong;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003563
James Molloya6d81f92011-11-23 13:35:08 +00003564 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3565 WCharType = SignedInt;
3566
Daniel Dunbar684de632010-04-22 16:14:54 +00003567 // Do not respect the alignment of bit-field types when laying out
3568 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3569 UseBitFieldTypeAlignment = false;
3570
Chad Rosier61a62212011-08-04 01:21:14 +00003571 /// gcc forces the alignment to 4 bytes, regardless of the type of the
Chad Rosier6e43f3f2011-08-04 17:52:43 +00003572 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3573 /// gcc.
Chad Rosier61a62212011-08-04 01:21:14 +00003574 ZeroLengthBitfieldBoundary = 32;
3575
Logan Chieneae5a8202012-10-10 06:56:20 +00003576 IsAAPCS = false;
3577
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003578 if (IsThumb) {
Sandeep Patel3a41d142011-04-04 22:58:12 +00003579 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3580 // so set preferred for small types to 32.
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003581 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 +00003582 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003583 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003584 } else {
3585 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 +00003586 "i64:32:64-f32:32:32-f64:32:64-"
Lang Hamesf4f50032011-10-10 23:44:43 +00003587 "v64:32:64-v128:32:128-a0:0:32-n32-S32");
Daniel Dunbardff10dc2009-09-22 21:44:58 +00003588 }
3589
Chad Rosier9f1210c2011-07-26 07:03:04 +00003590 // FIXME: Override "preferred align" for double and long long.
David Tweedb16abb12012-10-25 13:33:01 +00003591 } else if (Name == "aapcs" || Name == "aapcs-vfp") {
Bob Wilsone4bce7a2013-06-18 05:36:04 +00003592 // size_t is unsigned long on Darwin.
3593 if (getTriple().isOSDarwin())
3594 SizeType = UnsignedLong;
Logan Chieneae5a8202012-10-10 06:56:20 +00003595 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003596 // FIXME: Enumerated types are variable width in straight AAPCS.
3597 } else if (Name == "aapcs-linux") {
Logan Chieneae5a8202012-10-10 06:56:20 +00003598 IsAAPCS = true;
Daniel Dunbara2a41612009-09-14 00:02:24 +00003599 } else
3600 return false;
3601
3602 return true;
3603 }
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003604
Chandler Carruthc3a2e652011-09-28 05:56:05 +00003605 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbara91320b2009-12-21 23:28:17 +00003606 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3607 Features["vfp2"] = true;
Bob Wilsoncfaab002012-09-29 23:52:52 +00003608 else if (CPU == "cortex-a8" || CPU == "cortex-a15" ||
3609 CPU == "cortex-a9" || CPU == "cortex-a9-mp")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003610 Features["neon"] = true;
Bob Wilsonfc553452013-03-04 22:37:46 +00003611 else if (CPU == "swift" || CPU == "cortex-a7") {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003612 Features["vfp4"] = true;
3613 Features["neon"] = true;
3614 }
Daniel Dunbara91320b2009-12-21 23:28:17 +00003615 }
Michael J. Spencer20249a12010-10-21 03:16:25 +00003616
Rafael Espindola5389b842013-08-21 21:59:03 +00003617 virtual bool HandleTargetFeatures(std::vector<std::string> &Features,
3618 DiagnosticsEngine &Diags) {
Bob Wilsoncfaab002012-09-29 23:52:52 +00003619 FPU = 0;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003620 SoftFloat = SoftFloatABI = false;
3621 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
3622 if (Features[i] == "+soft-float")
3623 SoftFloat = true;
3624 else if (Features[i] == "+soft-float-abi")
3625 SoftFloatABI = true;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003626 else if (Features[i] == "+vfp2")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003627 FPU |= VFP2FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003628 else if (Features[i] == "+vfp3")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003629 FPU |= VFP3FPU;
3630 else if (Features[i] == "+vfp4")
3631 FPU |= VFP4FPU;
Daniel Dunbara91320b2009-12-21 23:28:17 +00003632 else if (Features[i] == "+neon")
Bob Wilsoncfaab002012-09-29 23:52:52 +00003633 FPU |= NeonFPU;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003634 }
3635
Rafael Espindola5389b842013-08-21 21:59:03 +00003636 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
3637 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
3638 return false;
3639 }
3640
3641 if (FPMath == FP_Neon)
3642 Features.push_back("+neonfp");
3643 else if (FPMath == FP_VFP)
3644 Features.push_back("-neonfp");
3645
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003646 // Remove front-end specific options which the backend handles differently.
3647 std::vector<std::string>::iterator it;
3648 it = std::find(Features.begin(), Features.end(), "+soft-float");
3649 if (it != Features.end())
3650 Features.erase(it);
3651 it = std::find(Features.begin(), Features.end(), "+soft-float-abi");
3652 if (it != Features.end())
3653 Features.erase(it);
Rafael Espindola5389b842013-08-21 21:59:03 +00003654 return true;
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003655 }
3656
Douglas Gregore727d212012-01-30 06:38:25 +00003657 virtual bool hasFeature(StringRef Feature) const {
3658 return llvm::StringSwitch<bool>(Feature)
3659 .Case("arm", true)
3660 .Case("softfloat", SoftFloat)
3661 .Case("thumb", IsThumb)
3662 .Case("neon", FPU == NeonFPU && !SoftFloat &&
3663 StringRef(getCPUDefineSuffix(CPU)).startswith("7"))
3664 .Default(false);
3665 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003666 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner5f9e2722011-07-23 10:55:15 +00003667 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbareac7c532009-12-18 18:42:37 +00003668 return llvm::StringSwitch<const char*>(Name)
3669 .Cases("arm8", "arm810", "4")
3670 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3671 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3672 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3673 .Case("ep9312", "4T")
3674 .Cases("arm10tdmi", "arm1020t", "5T")
3675 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3676 .Case("arm926ej-s", "5TEJ")
3677 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3678 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003679 .Case("arm1136j-s", "6J")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003680 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbara91320b2009-12-21 23:28:17 +00003681 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003682 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonfc553452013-03-04 22:37:46 +00003683 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
3684 .Cases("cortex-a9", "cortex-a15", "7A")
Quentin Colombetab137512012-12-21 17:57:47 +00003685 .Case("cortex-r5", "7R")
Bob Wilson336bfa32012-09-29 23:52:50 +00003686 .Case("cortex-a9-mp", "7F")
3687 .Case("swift", "7S")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003688 .Cases("cortex-m3", "cortex-m4", "7M")
Bob Wilsona291d5f2011-03-21 21:55:25 +00003689 .Case("cortex-m0", "6M")
Joey Gouly4ec8d5b2013-06-26 17:19:48 +00003690 .Case("cortex-a53", "8A")
Daniel Dunbareac7c532009-12-18 18:42:37 +00003691 .Default(0);
3692 }
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003693 static const char *getCPUProfile(StringRef Name) {
3694 return llvm::StringSwitch<const char*>(Name)
3695 .Cases("cortex-a8", "cortex-a9", "A")
3696 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "M")
Quentin Colombetab137512012-12-21 17:57:47 +00003697 .Case("cortex-r5", "R")
Anton Korobeynikov8b0703d2012-09-08 08:22:13 +00003698 .Default("");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003699 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003700 virtual bool setCPU(const std::string &Name) {
3701 if (!getCPUDefineSuffix(Name))
3702 return false;
3703
3704 CPU = Name;
3705 return true;
3706 }
Rafael Espindola5389b842013-08-21 21:59:03 +00003707 virtual bool setFPMath(StringRef Name);
Chris Lattner33328642009-03-20 15:52:06 +00003708 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00003709 MacroBuilder &Builder) const {
Chris Lattnerc0f59212009-03-02 22:27:17 +00003710 // Target identification.
Benjamin Kramera9992772010-01-09 17:55:51 +00003711 Builder.defineMacro("__arm");
3712 Builder.defineMacro("__arm__");
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003713
Chris Lattnerc0f59212009-03-02 22:27:17 +00003714 // Target properties.
Benjamin Kramera9992772010-01-09 17:55:51 +00003715 Builder.defineMacro("__ARMEL__");
3716 Builder.defineMacro("__LITTLE_ENDIAN__");
3717 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003718
Chris Lattner5f9e2722011-07-23 10:55:15 +00003719 StringRef CPUArch = getCPUDefineSuffix(CPU);
Benjamin Kramera9992772010-01-09 17:55:51 +00003720 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003721 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
3722 StringRef CPUProfile = getCPUProfile(CPU);
3723 if (!CPUProfile.empty())
3724 Builder.defineMacro("__ARM_ARCH_PROFILE", CPUProfile);
3725
Mike Stump437bb4b2009-04-08 02:07:04 +00003726 // Subtarget options.
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003727
Daniel Dunbareac7c532009-12-18 18:42:37 +00003728 // FIXME: It's more complicated than this and we don't really support
3729 // interworking.
3730 if ('5' <= CPUArch[0] && CPUArch[0] <= '7')
Benjamin Kramera9992772010-01-09 17:55:51 +00003731 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003732
David Tweedb16abb12012-10-25 13:33:01 +00003733 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Daniel Dunbar849289e2012-10-22 18:51:13 +00003734 // M-class CPUs on Darwin follow AAPCS, but not EABI.
Daniel Dunbar4d3ee9b2012-10-22 18:56:43 +00003735 if (!(getTriple().isOSDarwin() && CPUProfile == "M"))
Daniel Dunbar849289e2012-10-22 18:51:13 +00003736 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003737 Builder.defineMacro("__ARM_PCS", "1");
3738
David Tweedb16abb12012-10-25 13:33:01 +00003739 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikov70a5cca2012-09-08 08:08:27 +00003740 Builder.defineMacro("__ARM_PCS_VFP", "1");
3741 }
Daniel Dunbareac7c532009-12-18 18:42:37 +00003742
Daniel Dunbar97f52ac2009-12-19 04:15:38 +00003743 if (SoftFloat)
Benjamin Kramera9992772010-01-09 17:55:51 +00003744 Builder.defineMacro("__SOFTFP__");
Daniel Dunbareac7c532009-12-18 18:42:37 +00003745
3746 if (CPU == "xscale")
Benjamin Kramera9992772010-01-09 17:55:51 +00003747 Builder.defineMacro("__XSCALE__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003748
Bob Wilson84f95cf2011-05-13 18:56:03 +00003749 bool IsARMv7 = CPUArch.startswith("7");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003750 if (IsThumb) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003751 Builder.defineMacro("__THUMBEL__");
3752 Builder.defineMacro("__thumb__");
Bob Wilson84f95cf2011-05-13 18:56:03 +00003753 if (CPUArch == "6T2" || IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003754 Builder.defineMacro("__thumb2__");
Daniel Dunbare1f63b32009-09-17 16:21:10 +00003755 }
3756
3757 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramera9992772010-01-09 17:55:51 +00003758 Builder.defineMacro("__APCS_32__");
Daniel Dunbara91320b2009-12-21 23:28:17 +00003759
Bob Wilsoncfaab002012-09-29 23:52:52 +00003760 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramera9992772010-01-09 17:55:51 +00003761 Builder.defineMacro("__VFP_FP__");
Bob Wilsoncfaab002012-09-29 23:52:52 +00003762 if (FPU & VFP2FPU)
3763 Builder.defineMacro("__ARM_VFPV2__");
3764 if (FPU & VFP3FPU)
3765 Builder.defineMacro("__ARM_VFPV3__");
3766 if (FPU & VFP4FPU)
3767 Builder.defineMacro("__ARM_VFPV4__");
3768 }
3769
Daniel Dunbara91320b2009-12-21 23:28:17 +00003770 // This only gets set when Neon instructions are actually available, unlike
3771 // the VFP define, hence the soft float and arch check. This is subtly
3772 // different from gcc, we follow the intent which was that it should be set
3773 // when Neon instructions are actually available.
Bob Wilsoncfaab002012-09-29 23:52:52 +00003774 if ((FPU & NeonFPU) && !SoftFloat && IsARMv7)
Benjamin Kramera9992772010-01-09 17:55:51 +00003775 Builder.defineMacro("__ARM_NEON__");
Chris Lattner393ff042008-04-21 18:56:49 +00003776 }
3777 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3778 unsigned &NumRecords) const {
Chris Lattner2752c012010-03-03 19:03:45 +00003779 Records = BuiltinInfo;
3780 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner393ff042008-04-21 18:56:49 +00003781 }
Bob Wilson8b30a932012-01-26 22:14:27 +00003782 virtual bool isCLZForZeroUndef() const { return false; }
Meador Ingec5613b22012-06-16 03:34:49 +00003783 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Logan Chieneae5a8202012-10-10 06:56:20 +00003784 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner393ff042008-04-21 18:56:49 +00003785 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003786 virtual void getGCCRegNames(const char * const *&Names,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003787 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00003788 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003789 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003790 virtual bool validateAsmConstraint(const char *&Name,
Chris Lattner44def072009-04-26 07:16:29 +00003791 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson066d2ea2009-02-28 17:11:49 +00003792 switch (*Name) {
Eric Christophera0dfca12012-08-16 23:50:41 +00003793 default: break;
Nate Begemanad487f42008-04-22 05:03:19 +00003794 case 'l': // r0-r7
3795 case 'h': // r8-r15
3796 case 'w': // VFP Floating point register single precision
3797 case 'P': // VFP Floating point register double precision
Chris Lattner44def072009-04-26 07:16:29 +00003798 Info.setAllowsRegister();
Nate Begemanad487f42008-04-22 05:03:19 +00003799 return true;
Eric Christopher895d4222011-07-29 21:20:35 +00003800 case 'Q': // A memory address that is a single base register.
3801 Info.setAllowsMemory();
3802 return true;
Stuart Hastings002333f2011-06-07 23:45:05 +00003803 case 'U': // a memory reference...
3804 switch (Name[1]) {
3805 case 'q': // ...ARMV4 ldrsb
3806 case 'v': // ...VFP load/store (reg+constant offset)
3807 case 'y': // ...iWMMXt load/store
Eric Christopherdda231a2011-06-17 01:40:49 +00003808 case 't': // address valid for load/store opaque types wider
Eric Christopher825d3862012-11-14 22:08:59 +00003809 // than 128-bits
Eric Christopherdda231a2011-06-17 01:40:49 +00003810 case 'n': // valid address for Neon doubleword vector load/store
3811 case 'm': // valid address for Neon element and structure load/store
3812 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopher825d3862012-11-14 22:08:59 +00003813 // values in four ARM registers
Stuart Hastings002333f2011-06-07 23:45:05 +00003814 Info.setAllowsMemory();
3815 Name++;
3816 return true;
3817 }
Nate Begemanad487f42008-04-22 05:03:19 +00003818 }
Chris Lattner393ff042008-04-21 18:56:49 +00003819 return false;
3820 }
Evan Cheng8bfa2572011-06-16 19:13:15 +00003821 virtual std::string convertConstraint(const char *&Constraint) const {
Stuart Hastings002333f2011-06-07 23:45:05 +00003822 std::string R;
3823 switch (*Constraint) {
3824 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings6ce33d62011-06-08 16:06:31 +00003825 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings002333f2011-06-07 23:45:05 +00003826 Constraint++;
3827 break;
Eric Christopher283f4472011-06-17 00:40:18 +00003828 case 'p': // 'p' should be translated to 'r' by default.
3829 R = std::string("r");
3830 break;
Stuart Hastings002333f2011-06-07 23:45:05 +00003831 default:
3832 return std::string(1, *Constraint);
3833 }
3834 return R;
3835 }
Bill Wendling50d46ca2012-10-25 23:28:48 +00003836 virtual bool validateConstraintModifier(StringRef Constraint,
3837 const char Modifier,
3838 unsigned Size) const {
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003839 bool isOutput = (Constraint[0] == '=');
Bill Wendling6e6330c2012-11-30 23:46:56 +00003840 bool isInOut = (Constraint[0] == '+');
Bill Wendlinge2dbaa92012-11-30 23:18:12 +00003841
Bill Wendling50d46ca2012-10-25 23:28:48 +00003842 // Strip off constraint modifiers.
3843 while (Constraint[0] == '=' ||
3844 Constraint[0] == '+' ||
3845 Constraint[0] == '&')
3846 Constraint = Constraint.substr(1);
3847
3848 switch (Constraint[0]) {
3849 default: break;
3850 case 'r': {
3851 switch (Modifier) {
3852 default:
Bob Wilson221a8902013-06-03 23:57:13 +00003853 return (isInOut || isOutput || Size <= 32);
Bill Wendling50d46ca2012-10-25 23:28:48 +00003854 case 'q':
3855 // A register of size 32 cannot fit a vector type.
3856 return false;
3857 }
3858 }
3859 }
3860
3861 return true;
3862 }
Chris Lattner393ff042008-04-21 18:56:49 +00003863 virtual const char *getClobbers() const {
Eli Friedmana9f54962008-08-20 07:44:10 +00003864 // FIXME: Is this really right?
Chris Lattner393ff042008-04-21 18:56:49 +00003865 return "";
3866 }
Aaron Ballman82bfa192012-10-02 14:26:08 +00003867
3868 virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const {
3869 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
3870 }
Logan Chiena8f7a972013-02-23 04:24:36 +00003871
3872 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
3873 if (RegNo == 0) return 0;
3874 if (RegNo == 1) return 1;
3875 return -1;
3876 }
Chris Lattner393ff042008-04-21 18:56:49 +00003877};
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003878
Rafael Espindola5389b842013-08-21 21:59:03 +00003879bool ARMTargetInfo::setFPMath(StringRef Name) {
3880 if (Name == "neon") {
3881 FPMath = FP_Neon;
3882 return true;
3883 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
3884 Name == "vfp4") {
3885 FPMath = FP_VFP;
3886 return true;
3887 }
3888 return false;
3889}
3890
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003891const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003892 // Integer registers
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003893 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003894 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
3895
3896 // Float registers
3897 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
3898 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
3899 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003900 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbarbf3d5522010-08-11 02:17:20 +00003901
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003902 // Double registers
3903 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
3904 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend1455352010-10-28 01:05:37 +00003905 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
3906 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003907
3908 // Quad registers
Dale Johannesend1455352010-10-28 01:05:37 +00003909 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
3910 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003911};
3912
3913void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003914 unsigned &NumNames) const {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003915 Names = GCCRegNames;
3916 NumNames = llvm::array_lengthof(GCCRegNames);
3917}
3918
3919const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003920 { { "a1" }, "r0" },
3921 { { "a2" }, "r1" },
3922 { { "a3" }, "r2" },
3923 { { "a4" }, "r3" },
3924 { { "v1" }, "r4" },
3925 { { "v2" }, "r5" },
3926 { { "v3" }, "r6" },
3927 { { "v4" }, "r7" },
3928 { { "v5" }, "r8" },
3929 { { "v6", "rfp" }, "r9" },
3930 { { "sl" }, "r10" },
3931 { { "fp" }, "r11" },
3932 { { "ip" }, "r12" },
Daniel Dunbar1fd71712010-08-11 02:17:11 +00003933 { { "r13" }, "sp" },
3934 { { "r14" }, "lr" },
3935 { { "r15" }, "pc" },
Dale Johannesen20eb49b2010-10-27 23:34:42 +00003936 // The S, D and Q registers overlap, but aren't really aliases; we
3937 // don't want to substitute one of these for a different-sized one.
Daniel Dunbarc1f2cdd2009-09-17 07:03:19 +00003938};
3939
3940void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
3941 unsigned &NumAliases) const {
3942 Aliases = GCCRegAliases;
3943 NumAliases = llvm::array_lengthof(GCCRegAliases);
3944}
Chris Lattner2752c012010-03-03 19:03:45 +00003945
3946const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmane7e66f72011-07-05 21:53:01 +00003947#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahanian67aba812010-11-30 17:35:24 +00003948#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmane7e66f72011-07-05 21:53:01 +00003949 ALL_LANGUAGES },
Chris Lattner2752c012010-03-03 19:03:45 +00003950#include "clang/Basic/BuiltinsARM.def"
3951};
Chris Lattner393ff042008-04-21 18:56:49 +00003952} // end anonymous namespace.
3953
Eli Friedmana9f54962008-08-20 07:44:10 +00003954namespace {
Mike Stump1eb44332009-09-09 15:08:12 +00003955class DarwinARMTargetInfo :
Torok Edwin5f6c1942009-06-30 17:10:35 +00003956 public DarwinTargetInfo<ARMTargetInfo> {
3957protected:
Daniel Dunbar1752ee42009-08-24 09:10:05 +00003958 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramera9992772010-01-09 17:55:51 +00003959 MacroBuilder &Builder) const {
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00003960 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmanb030f022009-04-19 21:38:35 +00003961 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003962
Torok Edwin5f6c1942009-06-30 17:10:35 +00003963public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003964 DarwinARMTargetInfo(const llvm::Triple &Triple)
3965 : DarwinTargetInfo<ARMTargetInfo>(Triple) {
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003966 HasAlignMac68kSupport = true;
Eli Friedman2be46072011-10-14 20:59:01 +00003967 // iOS always has 64-bit atomic instructions.
3968 // FIXME: This should be based off of the target features in ARMTargetInfo.
3969 MaxAtomicInlineWidth = 64;
John McCallb8b2c9d2013-01-25 22:30:49 +00003970
3971 // Darwin on iOS uses a variant of the ARM C++ ABI.
3972 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar350b9f32010-05-27 07:00:26 +00003973 }
Eli Friedmana9f54962008-08-20 07:44:10 +00003974};
3975} // end anonymous namespace.
3976
Tony Linthicum96319392011-12-12 21:14:55 +00003977
3978namespace {
3979// Hexagon abstract base class
3980class HexagonTargetInfo : public TargetInfo {
3981 static const Builtin::Info BuiltinInfo[];
3982 static const char * const GCCRegNames[];
3983 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3984 std::string CPU;
3985public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00003986 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00003987 BigEndian = false;
Tony Linthicum96319392011-12-12 21:14:55 +00003988 DescriptionString = ("e-p:32:32:32-"
Anshuman Dasgupta1a090f12013-01-02 21:25:57 +00003989 "i64:64:64-i32:32:32-i16:16:16-i1:32:32-"
Sirish Pande5f9688b2012-05-10 20:19:54 +00003990 "f64:64:64-f32:32:32-a0:0-n32");
Tony Linthicum96319392011-12-12 21:14:55 +00003991
3992 // {} in inline assembly are packet specifiers, not assembly variant
3993 // specifiers.
3994 NoAsmVariants = true;
3995 }
3996
3997 virtual void getTargetBuiltins(const Builtin::Info *&Records,
3998 unsigned &NumRecords) const {
3999 Records = BuiltinInfo;
4000 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4001 }
4002
4003 virtual bool validateAsmConstraint(const char *&Name,
4004 TargetInfo::ConstraintInfo &Info) const {
4005 return true;
4006 }
4007
4008 virtual void getTargetDefines(const LangOptions &Opts,
4009 MacroBuilder &Builder) const;
4010
Douglas Gregore727d212012-01-30 06:38:25 +00004011 virtual bool hasFeature(StringRef Feature) const {
4012 return Feature == "hexagon";
4013 }
4014
Meador Ingec5613b22012-06-16 03:34:49 +00004015 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4016 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum96319392011-12-12 21:14:55 +00004017 }
4018 virtual void getGCCRegNames(const char * const *&Names,
4019 unsigned &NumNames) const;
4020 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4021 unsigned &NumAliases) const;
4022 virtual const char *getClobbers() const {
4023 return "";
4024 }
Sebastian Pop43115d42012-01-13 20:37:10 +00004025
4026 static const char *getHexagonCPUSuffix(StringRef Name) {
4027 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop43115d42012-01-13 20:37:10 +00004028 .Case("hexagonv4", "4")
Sirish Pande5f9688b2012-05-10 20:19:54 +00004029 .Case("hexagonv5", "5")
Sebastian Pop43115d42012-01-13 20:37:10 +00004030 .Default(0);
4031 }
4032
Tony Linthicum96319392011-12-12 21:14:55 +00004033 virtual bool setCPU(const std::string &Name) {
Sebastian Pop43115d42012-01-13 20:37:10 +00004034 if (!getHexagonCPUSuffix(Name))
4035 return false;
4036
Tony Linthicum96319392011-12-12 21:14:55 +00004037 CPU = Name;
4038 return true;
4039 }
4040};
4041
4042void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4043 MacroBuilder &Builder) const {
4044 Builder.defineMacro("qdsp6");
4045 Builder.defineMacro("__qdsp6", "1");
4046 Builder.defineMacro("__qdsp6__", "1");
4047
4048 Builder.defineMacro("hexagon");
4049 Builder.defineMacro("__hexagon", "1");
4050 Builder.defineMacro("__hexagon__", "1");
4051
4052 if(CPU == "hexagonv1") {
4053 Builder.defineMacro("__HEXAGON_V1__");
4054 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4055 if(Opts.HexagonQdsp6Compat) {
4056 Builder.defineMacro("__QDSP6_V1__");
4057 Builder.defineMacro("__QDSP6_ARCH__", "1");
4058 }
4059 }
4060 else if(CPU == "hexagonv2") {
4061 Builder.defineMacro("__HEXAGON_V2__");
4062 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4063 if(Opts.HexagonQdsp6Compat) {
4064 Builder.defineMacro("__QDSP6_V2__");
4065 Builder.defineMacro("__QDSP6_ARCH__", "2");
4066 }
4067 }
4068 else if(CPU == "hexagonv3") {
4069 Builder.defineMacro("__HEXAGON_V3__");
4070 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4071 if(Opts.HexagonQdsp6Compat) {
4072 Builder.defineMacro("__QDSP6_V3__");
4073 Builder.defineMacro("__QDSP6_ARCH__", "3");
4074 }
4075 }
4076 else if(CPU == "hexagonv4") {
4077 Builder.defineMacro("__HEXAGON_V4__");
4078 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4079 if(Opts.HexagonQdsp6Compat) {
4080 Builder.defineMacro("__QDSP6_V4__");
4081 Builder.defineMacro("__QDSP6_ARCH__", "4");
4082 }
4083 }
Sirish Pande5f9688b2012-05-10 20:19:54 +00004084 else if(CPU == "hexagonv5") {
4085 Builder.defineMacro("__HEXAGON_V5__");
4086 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4087 if(Opts.HexagonQdsp6Compat) {
4088 Builder.defineMacro("__QDSP6_V5__");
4089 Builder.defineMacro("__QDSP6_ARCH__", "5");
4090 }
4091 }
Tony Linthicum96319392011-12-12 21:14:55 +00004092}
4093
4094const char * const HexagonTargetInfo::GCCRegNames[] = {
4095 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4096 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4097 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4098 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4099 "p0", "p1", "p2", "p3",
4100 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4101};
4102
4103void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4104 unsigned &NumNames) const {
4105 Names = GCCRegNames;
4106 NumNames = llvm::array_lengthof(GCCRegNames);
4107}
4108
4109
4110const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4111 { { "sp" }, "r29" },
4112 { { "fp" }, "r30" },
4113 { { "lr" }, "r31" },
4114 };
4115
4116void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4117 unsigned &NumAliases) const {
4118 Aliases = GCCRegAliases;
4119 NumAliases = llvm::array_lengthof(GCCRegAliases);
4120}
4121
4122
4123const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
4124#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4125#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4126 ALL_LANGUAGES },
4127#include "clang/Basic/BuiltinsHexagon.def"
4128};
4129}
4130
4131
Reid Spencer5f016e22007-07-11 17:01:13 +00004132namespace {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004133// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
4134class SparcTargetInfo : public TargetInfo {
Chris Lattnere957f532009-01-27 01:58:38 +00004135 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4136 static const char * const GCCRegNames[];
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004137 bool SoftFloat;
Gabor Greif26658672008-02-21 16:29:08 +00004138public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004139 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004140
Rafael Espindola5389b842013-08-21 21:59:03 +00004141 virtual bool HandleTargetFeatures(std::vector<std::string> &Features,
4142 DiagnosticsEngine &Diags) {
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004143 SoftFloat = false;
4144 for (unsigned i = 0, e = Features.size(); i != e; ++i)
4145 if (Features[i] == "+soft-float")
4146 SoftFloat = true;
Rafael Espindola5389b842013-08-21 21:59:03 +00004147 return true;
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004148 }
Chris Lattner33328642009-03-20 15:52:06 +00004149 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004150 MacroBuilder &Builder) const {
4151 DefineStd(Builder, "sparc", Opts);
Benjamin Kramera9992772010-01-09 17:55:51 +00004152 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopes9284d212010-11-09 17:21:19 +00004153
4154 if (SoftFloat)
4155 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif26658672008-02-21 16:29:08 +00004156 }
Douglas Gregore727d212012-01-30 06:38:25 +00004157
4158 virtual bool hasFeature(StringRef Feature) const {
4159 return llvm::StringSwitch<bool>(Feature)
4160 .Case("softfloat", SoftFloat)
4161 .Case("sparc", true)
4162 .Default(false);
4163 }
4164
Gabor Greif26658672008-02-21 16:29:08 +00004165 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4166 unsigned &NumRecords) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004167 // FIXME: Implement!
Gabor Greif26658672008-02-21 16:29:08 +00004168 }
Meador Ingec5613b22012-06-16 03:34:49 +00004169 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4170 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif26658672008-02-21 16:29:08 +00004171 }
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004172 virtual void getGCCRegNames(const char * const *&Names,
Chris Lattnere957f532009-01-27 01:58:38 +00004173 unsigned &NumNames) const;
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004174 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Chris Lattnere957f532009-01-27 01:58:38 +00004175 unsigned &NumAliases) const;
Anders Carlsson066d2ea2009-02-28 17:11:49 +00004176 virtual bool validateAsmConstraint(const char *&Name,
Gabor Greif26658672008-02-21 16:29:08 +00004177 TargetInfo::ConstraintInfo &info) const {
Eli Friedman01b86682008-08-20 07:28:14 +00004178 // FIXME: Implement!
4179 return false;
Gabor Greif26658672008-02-21 16:29:08 +00004180 }
4181 virtual const char *getClobbers() const {
Eli Friedman01b86682008-08-20 07:28:14 +00004182 // FIXME: Implement!
4183 return "";
Gabor Greif26658672008-02-21 16:29:08 +00004184 }
4185};
4186
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004187const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattnere957f532009-01-27 01:58:38 +00004188 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4189 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4190 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4191 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
4192};
4193
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004194void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
4195 unsigned &NumNames) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004196 Names = GCCRegNames;
4197 NumNames = llvm::array_lengthof(GCCRegNames);
4198}
4199
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004200const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikova7c47172009-05-03 13:42:53 +00004201 { { "g0" }, "r0" },
4202 { { "g1" }, "r1" },
4203 { { "g2" }, "r2" },
4204 { { "g3" }, "r3" },
4205 { { "g4" }, "r4" },
4206 { { "g5" }, "r5" },
4207 { { "g6" }, "r6" },
4208 { { "g7" }, "r7" },
4209 { { "o0" }, "r8" },
4210 { { "o1" }, "r9" },
4211 { { "o2" }, "r10" },
4212 { { "o3" }, "r11" },
4213 { { "o4" }, "r12" },
4214 { { "o5" }, "r13" },
4215 { { "o6", "sp" }, "r14" },
4216 { { "o7" }, "r15" },
4217 { { "l0" }, "r16" },
4218 { { "l1" }, "r17" },
4219 { { "l2" }, "r18" },
4220 { { "l3" }, "r19" },
4221 { { "l4" }, "r20" },
4222 { { "l5" }, "r21" },
4223 { { "l6" }, "r22" },
4224 { { "l7" }, "r23" },
4225 { { "i0" }, "r24" },
4226 { { "i1" }, "r25" },
4227 { { "i2" }, "r26" },
4228 { { "i3" }, "r27" },
4229 { { "i4" }, "r28" },
4230 { { "i5" }, "r29" },
4231 { { "i6", "fp" }, "r30" },
4232 { { "i7" }, "r31" },
Chris Lattnere957f532009-01-27 01:58:38 +00004233};
4234
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004235void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4236 unsigned &NumAliases) const {
Chris Lattnere957f532009-01-27 01:58:38 +00004237 Aliases = GCCRegAliases;
4238 NumAliases = llvm::array_lengthof(GCCRegAliases);
4239}
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004240
4241// SPARC v8 is the 32-bit mode selected by Triple::sparc.
4242class SparcV8TargetInfo : public SparcTargetInfo {
4243public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004244 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004245 // FIXME: Support Sparc quad-precision long double?
4246 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4247 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
4248 }
4249
4250 virtual void getTargetDefines(const LangOptions &Opts,
4251 MacroBuilder &Builder) const {
4252 SparcTargetInfo::getTargetDefines(Opts, Builder);
4253 Builder.defineMacro("__sparcv8");
4254 }
4255};
4256
4257// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
4258class SparcV9TargetInfo : public SparcTargetInfo {
4259public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004260 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004261 // FIXME: Support Sparc quad-precision long double?
4262 DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
4263 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
Jakob Stoklund Olesenfcec0c92013-05-15 03:22:33 +00004264 // This is an LP64 platform.
4265 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen5ac8c4f2013-05-19 17:53:37 +00004266
4267 // OpenBSD uses long long for int64_t and intmax_t.
4268 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
4269 IntMaxType = SignedLongLong;
4270 UIntMaxType = UnsignedLongLong;
4271 } else {
4272 IntMaxType = SignedLong;
4273 UIntMaxType = UnsignedLong;
4274 }
4275 Int64Type = IntMaxType;
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004276 }
4277
4278 virtual void getTargetDefines(const LangOptions &Opts,
4279 MacroBuilder &Builder) const {
4280 SparcTargetInfo::getTargetDefines(Opts, Builder);
4281 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesen44f72d32013-04-24 04:36:38 +00004282 Builder.defineMacro("__arch64__");
4283 // Solaris and its derivative AuroraUX don't need these variants, but the
4284 // BSDs do.
4285 if (getTriple().getOS() != llvm::Triple::Solaris &&
4286 getTriple().getOS() != llvm::Triple::AuroraUX) {
4287 Builder.defineMacro("__sparc64__");
4288 Builder.defineMacro("__sparc_v9__");
4289 Builder.defineMacro("__sparcv9__");
4290 }
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00004291 }
4292};
4293
Gabor Greif26658672008-02-21 16:29:08 +00004294} // end anonymous namespace.
4295
Eli Friedman01b86682008-08-20 07:28:14 +00004296namespace {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004297class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
4298public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004299 AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
4300 : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00004301 SizeType = UnsignedInt;
4302 PtrDiffType = SignedInt;
4303 }
4304};
Torok Edwin5f6c1942009-06-30 17:10:35 +00004305class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedman01b86682008-08-20 07:28:14 +00004306public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004307 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
4308 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmanf509d732008-11-02 02:43:55 +00004309 SizeType = UnsignedInt;
4310 PtrDiffType = SignedInt;
Eli Friedman01b86682008-08-20 07:28:14 +00004311 }
4312};
4313} // end anonymous namespace.
Reid Spencer5f016e22007-07-11 17:01:13 +00004314
Chris Lattner2621fd12008-05-08 05:58:21 +00004315namespace {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004316 class SystemZTargetInfo : public TargetInfo {
4317 static const char *const GCCRegNames[];
4318
4319 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004320 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Ulrich Weigandb8409212013-05-06 16:26:41 +00004321 TLSSupported = true;
4322 IntWidth = IntAlign = 32;
4323 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
4324 PointerWidth = PointerAlign = 64;
4325 LongDoubleWidth = 128;
4326 LongDoubleAlign = 64;
4327 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4328 MinGlobalAlign = 16;
4329 DescriptionString = "E-p:64:64:64-i1:8:16-i8:8:16-i16:16-i32:32-i64:64"
4330 "-f32:32-f64:64-f128:64-a0:8:16-n32:64";
4331 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
4332 }
4333 virtual void getTargetDefines(const LangOptions &Opts,
4334 MacroBuilder &Builder) const {
4335 Builder.defineMacro("__s390__");
4336 Builder.defineMacro("__s390x__");
4337 Builder.defineMacro("__zarch__");
4338 Builder.defineMacro("__LONG_DOUBLE_128__");
4339 }
4340 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4341 unsigned &NumRecords) const {
4342 // FIXME: Implement.
4343 Records = 0;
4344 NumRecords = 0;
4345 }
4346
4347 virtual void getGCCRegNames(const char *const *&Names,
4348 unsigned &NumNames) const;
4349 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4350 unsigned &NumAliases) const {
4351 // No aliases.
4352 Aliases = 0;
4353 NumAliases = 0;
4354 }
4355 virtual bool validateAsmConstraint(const char *&Name,
4356 TargetInfo::ConstraintInfo &info) const;
4357 virtual const char *getClobbers() const {
4358 // FIXME: Is this really right?
4359 return "";
4360 }
4361 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4362 return TargetInfo::SystemZBuiltinVaList;
4363 }
Richard Sandiford5c92b9a2013-07-19 16:51:51 +00004364 virtual bool setCPU(const std::string &Name) {
4365 bool CPUKnown = llvm::StringSwitch<bool>(Name)
4366 .Case("z10", true)
4367 .Case("z196", true)
4368 .Case("zEC12", true)
4369 .Default(false);
4370
4371 // No need to store the CPU yet. There aren't any CPU-specific
4372 // macros to define.
4373 return CPUKnown;
4374 }
Ulrich Weigandb8409212013-05-06 16:26:41 +00004375 };
4376
4377 const char *const SystemZTargetInfo::GCCRegNames[] = {
4378 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4379 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4380 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
4381 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
4382 };
4383
4384 void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
4385 unsigned &NumNames) const {
4386 Names = GCCRegNames;
4387 NumNames = llvm::array_lengthof(GCCRegNames);
4388 }
4389
4390 bool SystemZTargetInfo::
4391 validateAsmConstraint(const char *&Name,
4392 TargetInfo::ConstraintInfo &Info) const {
4393 switch (*Name) {
4394 default:
4395 return false;
4396
4397 case 'a': // Address register
4398 case 'd': // Data register (equivalent to 'r')
4399 case 'f': // Floating-point register
4400 Info.setAllowsRegister();
4401 return true;
4402
4403 case 'I': // Unsigned 8-bit constant
4404 case 'J': // Unsigned 12-bit constant
4405 case 'K': // Signed 16-bit constant
4406 case 'L': // Signed 20-bit displacement (on all targets we support)
4407 case 'M': // 0x7fffffff
4408 return true;
4409
4410 case 'Q': // Memory with base and unsigned 12-bit displacement
4411 case 'R': // Likewise, plus an index
4412 case 'S': // Memory with base and signed 20-bit displacement
4413 case 'T': // Likewise, plus an index
4414 Info.setAllowsMemory();
4415 return true;
4416 }
4417 }
4418}
4419
4420namespace {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004421 class MSP430TargetInfo : public TargetInfo {
4422 static const char * const GCCRegNames[];
4423 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004424 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004425 BigEndian = false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004426 TLSSupported = false;
Anton Korobeynikov09f52a62010-01-30 12:55:11 +00004427 IntWidth = 16; IntAlign = 16;
4428 LongWidth = 32; LongLongWidth = 64;
4429 LongAlign = LongLongAlign = 16;
4430 PointerWidth = 16; PointerAlign = 16;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004431 SuitableAlign = 16;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004432 SizeType = UnsignedInt;
Anton Korobeynikov18a295d2013-07-01 19:42:40 +00004433 IntMaxType = SignedLongLong;
4434 UIntMaxType = UnsignedLongLong;
4435 IntPtrType = SignedInt;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004436 PtrDiffType = SignedInt;
Edward O'Callaghan9cf910e2009-11-21 00:49:54 +00004437 SigAtomicType = SignedLong;
Anton Korobeynikov5d7c2512009-12-19 01:32:37 +00004438 DescriptionString = "e-p:16:16:16-i8:8:8-i16:16:16-i32:16:32-n8:16";
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004439 }
4440 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004441 MacroBuilder &Builder) const {
4442 Builder.defineMacro("MSP430");
4443 Builder.defineMacro("__MSP430__");
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004444 // FIXME: defines for different 'flavours' of MCU
4445 }
4446 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4447 unsigned &NumRecords) const {
4448 // FIXME: Implement.
4449 Records = 0;
4450 NumRecords = 0;
4451 }
Douglas Gregore727d212012-01-30 06:38:25 +00004452 virtual bool hasFeature(StringRef Feature) const {
4453 return Feature == "msp430";
4454 }
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004455 virtual void getGCCRegNames(const char * const *&Names,
4456 unsigned &NumNames) const;
4457 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4458 unsigned &NumAliases) const {
4459 // No aliases.
4460 Aliases = 0;
4461 NumAliases = 0;
4462 }
4463 virtual bool validateAsmConstraint(const char *&Name,
4464 TargetInfo::ConstraintInfo &info) const {
Anton Korobeynikov03265b62009-10-15 23:17:13 +00004465 // No target constraints for now.
4466 return false;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004467 }
4468 virtual const char *getClobbers() const {
4469 // FIXME: Is this really right?
4470 return "";
4471 }
Meador Ingec5613b22012-06-16 03:34:49 +00004472 virtual BuiltinVaListKind getBuiltinVaListKind() const {
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004473 // FIXME: implement
Meador Ingec5613b22012-06-16 03:34:49 +00004474 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikov73c64e52009-05-03 13:43:08 +00004475 }
4476 };
4477
4478 const char * const MSP430TargetInfo::GCCRegNames[] = {
4479 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4480 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
4481 };
4482
4483 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
4484 unsigned &NumNames) const {
4485 Names = GCCRegNames;
4486 NumNames = llvm::array_lengthof(GCCRegNames);
4487 }
4488}
4489
Jakob Stoklund Olesen1eb43432009-08-17 20:08:44 +00004490namespace {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004491
Mike Stump1eb44332009-09-09 15:08:12 +00004492 // LLVM and Clang cannot be used directly to output native binaries for
4493 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmanb63decf2009-08-19 20:47:07 +00004494 // type and alignment information.
Mike Stump1eb44332009-09-09 15:08:12 +00004495 //
4496 // TCE uses the llvm bitcode as input and uses it for generating customized
4497 // target processor and program binary. TCE co-design environment is
Eli Friedmanb63decf2009-08-19 20:47:07 +00004498 // publicly available in http://tce.cs.tut.fi
4499
Eli Friedman209f5bb2011-10-07 19:51:42 +00004500 static const unsigned TCEOpenCLAddrSpaceMap[] = {
4501 3, // opencl_global
4502 4, // opencl_local
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00004503 5, // opencl_constant
4504 0, // cuda_device
4505 0, // cuda_constant
4506 0 // cuda_shared
Eli Friedman209f5bb2011-10-07 19:51:42 +00004507 };
4508
Eli Friedmanb63decf2009-08-19 20:47:07 +00004509 class TCETargetInfo : public TargetInfo{
4510 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004511 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmanb63decf2009-08-19 20:47:07 +00004512 TLSSupported = false;
4513 IntWidth = 32;
4514 LongWidth = LongLongWidth = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004515 PointerWidth = 32;
4516 IntAlign = 32;
4517 LongAlign = LongLongAlign = 32;
4518 PointerAlign = 32;
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004519 SuitableAlign = 32;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004520 SizeType = UnsignedInt;
4521 IntMaxType = SignedLong;
4522 UIntMaxType = UnsignedLong;
4523 IntPtrType = SignedInt;
4524 PtrDiffType = SignedInt;
4525 FloatWidth = 32;
4526 FloatAlign = 32;
4527 DoubleWidth = 32;
4528 DoubleAlign = 32;
4529 LongDoubleWidth = 32;
4530 LongDoubleAlign = 32;
4531 FloatFormat = &llvm::APFloat::IEEEsingle;
4532 DoubleFormat = &llvm::APFloat::IEEEsingle;
4533 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Chris Lattner3a47c4e2010-03-04 21:07:38 +00004534 DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:32-"
4535 "i16:16:32-i32:32:32-i64:32:32-"
NAKAMURA Takumic9109292011-02-18 08:44:38 +00004536 "f32:32:32-f64:32:32-v64:32:32-"
4537 "v128:32:32-a0:0:32-n32";
Eli Friedman209f5bb2011-10-07 19:51:42 +00004538 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004539 }
4540
4541 virtual void getTargetDefines(const LangOptions &Opts,
Benjamin Kramera9992772010-01-09 17:55:51 +00004542 MacroBuilder &Builder) const {
4543 DefineStd(Builder, "tce", Opts);
4544 Builder.defineMacro("__TCE__");
4545 Builder.defineMacro("__TCE_V1__");
Eli Friedmanb63decf2009-08-19 20:47:07 +00004546 }
Douglas Gregore727d212012-01-30 06:38:25 +00004547 virtual bool hasFeature(StringRef Feature) const {
4548 return Feature == "tce";
4549 }
4550
Eli Friedmanb63decf2009-08-19 20:47:07 +00004551 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4552 unsigned &NumRecords) const {}
Daniel Dunbar55cc2ed2009-08-24 09:54:37 +00004553 virtual const char *getClobbers() const {
4554 return "";
4555 }
Meador Ingec5613b22012-06-16 03:34:49 +00004556 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4557 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmanb63decf2009-08-19 20:47:07 +00004558 }
Eli Friedmanb63decf2009-08-19 20:47:07 +00004559 virtual void getGCCRegNames(const char * const *&Names,
4560 unsigned &NumNames) const {}
4561 virtual bool validateAsmConstraint(const char *&Name,
4562 TargetInfo::ConstraintInfo &info) const {
4563 return true;
4564 }
4565 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4566 unsigned &NumAliases) const {}
4567 };
4568}
4569
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004570namespace {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004571class MipsTargetInfoBase : public TargetInfo {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004572 static const Builtin::Info BuiltinInfo[];
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004573 std::string CPU;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004574 bool IsMips16;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004575 bool IsMicromips;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004576 bool IsSingleFloat;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004577 enum MipsFloatABI {
Simon Atanasyand96e3152013-04-14 14:07:30 +00004578 HardFloat, SoftFloat
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004579 } FloatABI;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004580 enum DspRevEnum {
4581 NoDSP, DSP1, DSP2
4582 } DspRev;
Jack Carterc613b672013-08-12 17:20:29 +00004583 bool HasMSA;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004584
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004585protected:
4586 std::string ABI;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004587
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004588public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004589 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
4590 const std::string &CPUStr)
4591 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Jack Carterc613b672013-08-12 17:20:29 +00004592 IsSingleFloat(false), FloatABI(HardFloat), DspRev(NoDSP),
4593 HasMSA(false), ABI(ABIStr) {}
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004594
Eric Christophered734732010-03-02 02:41:08 +00004595 virtual const char *getABI() const { return ABI.c_str(); }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004596 virtual bool setABI(const std::string &Name) = 0;
Eric Christophered734732010-03-02 02:41:08 +00004597 virtual bool setCPU(const std::string &Name) {
4598 CPU = Name;
4599 return true;
4600 }
Chandler Carruthc3a2e652011-09-28 05:56:05 +00004601 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Eric Christophered734732010-03-02 02:41:08 +00004602 Features[ABI] = true;
4603 Features[CPU] = true;
4604 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004605
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004606 virtual void getTargetDefines(const LangOptions &Opts,
4607 MacroBuilder &Builder) const {
Simon Atanasyand4935a02012-08-29 19:14:58 +00004608 DefineStd(Builder, "mips", Opts);
4609 Builder.defineMacro("_mips");
4610 Builder.defineMacro("__REGISTER_PREFIX__", "");
4611
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004612 switch (FloatABI) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004613 case HardFloat:
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004614 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004615 break;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004616 case SoftFloat:
4617 Builder.defineMacro("__mips_soft_float", Twine(1));
4618 break;
Simon Atanasyan3dbcc882012-06-05 13:06:56 +00004619 }
Simon Atanasyan90913892012-04-05 19:28:31 +00004620
Simon Atanasyand96e3152013-04-14 14:07:30 +00004621 if (IsSingleFloat)
4622 Builder.defineMacro("__mips_single_float", Twine(1));
4623
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004624 if (IsMips16)
4625 Builder.defineMacro("__mips16", Twine(1));
4626
Simon Atanasyan321ae792013-04-14 14:07:51 +00004627 if (IsMicromips)
4628 Builder.defineMacro("__mips_micromips", Twine(1));
4629
Simon Atanasyana1b62272012-07-05 20:16:22 +00004630 switch (DspRev) {
4631 default:
4632 break;
4633 case DSP1:
4634 Builder.defineMacro("__mips_dsp_rev", Twine(1));
4635 Builder.defineMacro("__mips_dsp", Twine(1));
4636 break;
4637 case DSP2:
4638 Builder.defineMacro("__mips_dsp_rev", Twine(2));
4639 Builder.defineMacro("__mips_dspr2", Twine(1));
4640 Builder.defineMacro("__mips_dsp", Twine(1));
4641 break;
4642 }
4643
Jack Carterc613b672013-08-12 17:20:29 +00004644 if (HasMSA)
4645 Builder.defineMacro("__mips_msa", Twine(1));
4646
Simon Atanasyan90913892012-04-05 19:28:31 +00004647 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
4648 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
4649 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan260e5062012-08-29 15:17:29 +00004650
4651 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
4652 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004653 }
4654
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004655 virtual void getTargetBuiltins(const Builtin::Info *&Records,
4656 unsigned &NumRecords) const {
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004657 Records = BuiltinInfo;
4658 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004659 }
Douglas Gregore727d212012-01-30 06:38:25 +00004660 virtual bool hasFeature(StringRef Feature) const {
4661 return Feature == "mips";
4662 }
Meador Ingec5613b22012-06-16 03:34:49 +00004663 virtual BuiltinVaListKind getBuiltinVaListKind() const {
4664 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004665 }
4666 virtual void getGCCRegNames(const char * const *&Names,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004667 unsigned &NumNames) const {
4668 static const char * const GCCRegNames[] = {
Eric Christopherd1f853d2012-03-27 19:56:11 +00004669 // CPU register names
4670 // Must match second column of GCCRegAliases
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004671 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
4672 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
4673 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004674 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
4675 // Floating point register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004676 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
4677 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
4678 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
4679 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopherd1f853d2012-03-27 19:56:11 +00004680 // Hi/lo and condition register names
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004681 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
4682 "$fcc5","$fcc6","$fcc7"
4683 };
4684 Names = GCCRegNames;
4685 NumNames = llvm::array_lengthof(GCCRegNames);
4686 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004687 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004688 unsigned &NumAliases) const = 0;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004689 virtual bool validateAsmConstraint(const char *&Name,
4690 TargetInfo::ConstraintInfo &Info) const {
4691 switch (*Name) {
4692 default:
Douglas Gregor21a25162011-11-02 20:52:01 +00004693 return false;
4694
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004695 case 'r': // CPU registers.
4696 case 'd': // Equivalent to "r" unless generating MIPS16 code.
4697 case 'y': // Equivalent to "r", backwards compatibility only.
4698 case 'f': // floating-point registers.
Eric Christopher0ea61642012-04-03 01:16:32 +00004699 case 'c': // $25 for indirect jumps
4700 case 'l': // lo register
4701 case 'x': // hilo register pair
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004702 Info.setAllowsRegister();
4703 return true;
Jack Carter97102302013-03-05 19:10:54 +00004704 case 'R': // An address that can be used in a non-macro load or store
Jack Carterd2ab6d32013-03-04 21:36:11 +00004705 Info.setAllowsMemory();
4706 return true;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004707 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004708 }
4709
4710 virtual const char *getClobbers() const {
4711 // FIXME: Implement!
4712 return "";
4713 }
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004714
Rafael Espindola5389b842013-08-21 21:59:03 +00004715 virtual bool HandleTargetFeatures(std::vector<std::string> &Features,
4716 DiagnosticsEngine &Diags) {
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004717 IsMips16 = false;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004718 IsMicromips = false;
Simon Atanasyand96e3152013-04-14 14:07:30 +00004719 IsSingleFloat = false;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004720 FloatABI = HardFloat;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004721 DspRev = NoDSP;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004722
4723 for (std::vector<std::string>::iterator it = Features.begin(),
4724 ie = Features.end(); it != ie; ++it) {
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004725 if (*it == "+single-float")
Simon Atanasyand96e3152013-04-14 14:07:30 +00004726 IsSingleFloat = true;
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004727 else if (*it == "+soft-float")
4728 FloatABI = SoftFloat;
Simon Atanasyan1176bcd2012-07-05 16:06:06 +00004729 else if (*it == "+mips16")
4730 IsMips16 = true;
Simon Atanasyan321ae792013-04-14 14:07:51 +00004731 else if (*it == "+micromips")
4732 IsMicromips = true;
Simon Atanasyana1b62272012-07-05 20:16:22 +00004733 else if (*it == "+dsp")
4734 DspRev = std::max(DspRev, DSP1);
4735 else if (*it == "+dspr2")
4736 DspRev = std::max(DspRev, DSP2);
Jack Carterc613b672013-08-12 17:20:29 +00004737 else if (*it == "+msa")
4738 HasMSA = true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004739 }
Simon Atanasyanbbd99162012-07-05 15:32:46 +00004740
4741 // Remove front-end specific option.
4742 std::vector<std::string>::iterator it =
4743 std::find(Features.begin(), Features.end(), "+soft-float");
4744 if (it != Features.end())
4745 Features.erase(it);
Rafael Espindola5389b842013-08-21 21:59:03 +00004746
4747 return true;
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004748 }
Logan Chiena8f7a972013-02-23 04:24:36 +00004749
4750 virtual int getEHDataRegisterNumber(unsigned RegNo) const {
4751 if (RegNo == 0) return 4;
4752 if (RegNo == 1) return 5;
4753 return -1;
4754 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004755};
4756
Simon Atanasyanfbf70052012-06-28 18:23:16 +00004757const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
4758#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4759#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4760 ALL_LANGUAGES },
4761#include "clang/Basic/BuiltinsMips.def"
4762};
4763
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004764class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004765public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004766 Mips32TargetInfoBase(const llvm::Triple &Triple)
4767 : MipsTargetInfoBase(Triple, "o32", "mips32") {
Akira Hatanaka148735e2011-11-05 01:48:34 +00004768 SizeType = UnsignedInt;
4769 PtrDiffType = SignedInt;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004770 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka148735e2011-11-05 01:48:34 +00004771 }
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004772 virtual bool setABI(const std::string &Name) {
4773 if ((Name == "o32") || (Name == "eabi")) {
4774 ABI = Name;
4775 return true;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004776 } else if (Name == "32") {
4777 ABI = "o32";
4778 return true;
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004779 } else
4780 return false;
4781 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004782 virtual void getTargetDefines(const LangOptions &Opts,
4783 MacroBuilder &Builder) const {
4784 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004785
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004786 if (ABI == "o32") {
4787 Builder.defineMacro("__mips_o32");
4788 Builder.defineMacro("_ABIO32", "1");
4789 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
4790 }
4791 else if (ABI == "eabi")
4792 Builder.defineMacro("__mips_eabi");
4793 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004794 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004795 }
4796 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4797 unsigned &NumAliases) const {
4798 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4799 { { "at" }, "$1" },
4800 { { "v0" }, "$2" },
4801 { { "v1" }, "$3" },
4802 { { "a0" }, "$4" },
4803 { { "a1" }, "$5" },
4804 { { "a2" }, "$6" },
4805 { { "a3" }, "$7" },
4806 { { "t0" }, "$8" },
4807 { { "t1" }, "$9" },
4808 { { "t2" }, "$10" },
4809 { { "t3" }, "$11" },
4810 { { "t4" }, "$12" },
4811 { { "t5" }, "$13" },
4812 { { "t6" }, "$14" },
4813 { { "t7" }, "$15" },
4814 { { "s0" }, "$16" },
4815 { { "s1" }, "$17" },
4816 { { "s2" }, "$18" },
4817 { { "s3" }, "$19" },
4818 { { "s4" }, "$20" },
4819 { { "s5" }, "$21" },
4820 { { "s6" }, "$22" },
4821 { { "s7" }, "$23" },
4822 { { "t8" }, "$24" },
4823 { { "t9" }, "$25" },
4824 { { "k0" }, "$26" },
4825 { { "k1" }, "$27" },
4826 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004827 { { "sp","$sp" }, "$29" },
4828 { { "fp","$fp" }, "$30" },
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004829 { { "ra" }, "$31" }
4830 };
4831 Aliases = GCCRegAliases;
4832 NumAliases = llvm::array_lengthof(GCCRegAliases);
4833 }
4834};
4835
4836class Mips32EBTargetInfo : public Mips32TargetInfoBase {
4837public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004838 Mips32EBTargetInfo(const llvm::Triple &Triple)
4839 : Mips32TargetInfoBase(Triple) {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004840 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 +00004841 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004842 }
4843 virtual void getTargetDefines(const LangOptions &Opts,
4844 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004845 DefineStd(Builder, "MIPSEB", Opts);
4846 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004847 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004848 }
4849};
4850
4851class Mips32ELTargetInfo : public Mips32TargetInfoBase {
4852public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004853 Mips32ELTargetInfo(const llvm::Triple &Triple)
4854 : Mips32TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004855 BigEndian = false;
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004856 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 +00004857 "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32-S64";
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004858 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004859 virtual void getTargetDefines(const LangOptions &Opts,
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004860 MacroBuilder &Builder) const {
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004861 DefineStd(Builder, "MIPSEL", Opts);
4862 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004863 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakab6a37b32011-09-20 19:00:23 +00004864 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00004865};
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004866
4867class Mips64TargetInfoBase : public MipsTargetInfoBase {
4868 virtual void SetDescriptionString(const std::string &Name) = 0;
4869public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004870 Mips64TargetInfoBase(const llvm::Triple &Triple)
4871 : MipsTargetInfoBase(Triple, "n64", "mips64") {
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004872 LongWidth = LongAlign = 64;
4873 PointerWidth = PointerAlign = 64;
4874 LongDoubleWidth = LongDoubleAlign = 128;
4875 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnall6e399b42012-12-08 09:06:08 +00004876 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
4877 LongDoubleWidth = LongDoubleAlign = 64;
4878 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4879 }
Nick Lewycky7ec59c72011-12-16 22:34:14 +00004880 SuitableAlign = 128;
Akira Hatanakadbee9492013-01-18 21:58:11 +00004881 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004882 }
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004883 virtual bool setABI(const std::string &Name) {
4884 SetDescriptionString(Name);
Akira Hatanakac7d0ab12011-10-22 00:07:27 +00004885 if (Name == "n32") {
4886 LongWidth = LongAlign = 32;
4887 PointerWidth = PointerAlign = 32;
Simon Atanasyane9616a42013-02-27 14:55:49 +00004888 ABI = Name;
4889 return true;
4890 } else if (Name == "n64") {
4891 ABI = Name;
4892 return true;
4893 } else if (Name == "64") {
4894 ABI = "n64";
4895 return true;
4896 } else
4897 return false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004898 }
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004899 virtual void getTargetDefines(const LangOptions &Opts,
4900 MacroBuilder &Builder) const {
4901 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaad8d8a32012-03-23 23:07:09 +00004902
Simon Atanasyan600a5132012-08-29 20:50:11 +00004903 Builder.defineMacro("__mips64");
4904 Builder.defineMacro("__mips64__");
4905
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004906 if (ABI == "n32") {
4907 Builder.defineMacro("__mips_n32");
4908 Builder.defineMacro("_ABIN32", "2");
4909 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
4910 }
4911 else if (ABI == "n64") {
4912 Builder.defineMacro("__mips_n64");
4913 Builder.defineMacro("_ABI64", "3");
4914 Builder.defineMacro("_MIPS_SIM", "_ABI64");
4915 }
4916 else
David Blaikieb219cfc2011-09-23 05:06:16 +00004917 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004918 }
4919 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
4920 unsigned &NumAliases) const {
4921 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
4922 { { "at" }, "$1" },
4923 { { "v0" }, "$2" },
4924 { { "v1" }, "$3" },
4925 { { "a0" }, "$4" },
4926 { { "a1" }, "$5" },
4927 { { "a2" }, "$6" },
4928 { { "a3" }, "$7" },
4929 { { "a4" }, "$8" },
4930 { { "a5" }, "$9" },
4931 { { "a6" }, "$10" },
4932 { { "a7" }, "$11" },
4933 { { "t0" }, "$12" },
4934 { { "t1" }, "$13" },
4935 { { "t2" }, "$14" },
4936 { { "t3" }, "$15" },
4937 { { "s0" }, "$16" },
4938 { { "s1" }, "$17" },
4939 { { "s2" }, "$18" },
4940 { { "s3" }, "$19" },
4941 { { "s4" }, "$20" },
4942 { { "s5" }, "$21" },
4943 { { "s6" }, "$22" },
4944 { { "s7" }, "$23" },
4945 { { "t8" }, "$24" },
4946 { { "t9" }, "$25" },
4947 { { "k0" }, "$26" },
4948 { { "k1" }, "$27" },
4949 { { "gp" }, "$28" },
Eric Christopherd1f853d2012-03-27 19:56:11 +00004950 { { "sp","$sp" }, "$29" },
4951 { { "fp","$fp" }, "$30" },
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004952 { { "ra" }, "$31" }
4953 };
4954 Aliases = GCCRegAliases;
4955 NumAliases = llvm::array_lengthof(GCCRegAliases);
4956 }
4957};
4958
4959class Mips64EBTargetInfo : public Mips64TargetInfoBase {
4960 virtual void SetDescriptionString(const std::string &Name) {
4961 // Change DescriptionString only if ABI is n32.
4962 if (Name == "n32")
4963 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 +00004964 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004965 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004966 }
4967public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004968 Mips64EBTargetInfo(const llvm::Triple &Triple)
4969 : Mips64TargetInfoBase(Triple) {
4970 // Default ABI is n64.
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004971 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 +00004972 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004973 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004974 }
4975 virtual void getTargetDefines(const LangOptions &Opts,
4976 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004977 DefineStd(Builder, "MIPSEB", Opts);
4978 Builder.defineMacro("_MIPSEB");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00004979 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004980 }
4981};
4982
4983class Mips64ELTargetInfo : public Mips64TargetInfoBase {
4984 virtual void SetDescriptionString(const std::string &Name) {
4985 // Change DescriptionString only if ABI is n32.
4986 if (Name == "n32")
4987 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 +00004988 "i64:64:64-f32:32:32-f64:64:64-f128:128:128"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004989 "-v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004990 }
4991public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00004992 Mips64ELTargetInfo(const llvm::Triple &Triple)
4993 : Mips64TargetInfoBase(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00004994 // Default ABI is n64.
4995 BigEndian = false;
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004996 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 +00004997 "i64:64:64-f32:32:32-f64:64:64-f128:128:128-"
Akira Hatanaka390a70f2013-01-05 02:04:34 +00004998 "v64:64:64-n32:64-S128";
Akira Hatanakabf5851a2011-09-20 19:21:49 +00004999 }
5000 virtual void getTargetDefines(const LangOptions &Opts,
5001 MacroBuilder &Builder) const {
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005002 DefineStd(Builder, "MIPSEL", Opts);
5003 Builder.defineMacro("_MIPSEL");
Simon Atanasyan1d8ae1d2012-08-29 19:59:32 +00005004 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005005 }
5006};
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005007} // end anonymous namespace.
5008
Ivan Krasinef05abd2011-08-24 20:22:22 +00005009namespace {
5010class PNaClTargetInfo : public TargetInfo {
5011public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005012 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmane6a24e82011-12-22 03:51:45 +00005013 BigEndian = false;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005014 this->UserLabelPrefix = "";
5015 this->LongAlign = 32;
5016 this->LongWidth = 32;
5017 this->PointerAlign = 32;
5018 this->PointerWidth = 32;
5019 this->IntMaxType = TargetInfo::SignedLongLong;
5020 this->UIntMaxType = TargetInfo::UnsignedLongLong;
5021 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005022 this->DoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005023 this->LongDoubleWidth = 64;
Ivan Krasinf619cdc2011-08-29 22:39:12 +00005024 this->LongDoubleAlign = 64;
Ivan Krasin68018db2011-09-20 14:56:54 +00005025 this->SizeType = TargetInfo::UnsignedInt;
5026 this->PtrDiffType = TargetInfo::SignedInt;
5027 this->IntPtrType = TargetInfo::SignedInt;
Eli Benderskyc0783dc2013-04-08 21:31:01 +00005028 this->RegParmMax = 0; // Disallow regparm
Ivan Krasinef05abd2011-08-24 20:22:22 +00005029 DescriptionString = "e-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"
5030 "f32:32:32-f64:64:64-p:32:32:32-v128:32:32";
5031 }
5032
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005033 void getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Ivan Krasinef05abd2011-08-24 20:22:22 +00005034 }
5035 virtual void getArchDefines(const LangOptions &Opts,
5036 MacroBuilder &Builder) const {
5037 Builder.defineMacro("__le32__");
5038 Builder.defineMacro("__pnacl__");
5039 }
5040 virtual void getTargetDefines(const LangOptions &Opts,
5041 MacroBuilder &Builder) const {
Jan Wen Voungdde3bdb2012-03-29 00:05:59 +00005042 Builder.defineMacro("__LITTLE_ENDIAN__");
Ivan Krasinef05abd2011-08-24 20:22:22 +00005043 getArchDefines(Opts, Builder);
5044 }
Douglas Gregore727d212012-01-30 06:38:25 +00005045 virtual bool hasFeature(StringRef Feature) const {
5046 return Feature == "pnacl";
5047 }
Ivan Krasinef05abd2011-08-24 20:22:22 +00005048 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5049 unsigned &NumRecords) const {
5050 }
Meador Ingec5613b22012-06-16 03:34:49 +00005051 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5052 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasinef05abd2011-08-24 20:22:22 +00005053 }
5054 virtual void getGCCRegNames(const char * const *&Names,
5055 unsigned &NumNames) const;
5056 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5057 unsigned &NumAliases) const;
5058 virtual bool validateAsmConstraint(const char *&Name,
5059 TargetInfo::ConstraintInfo &Info) const {
5060 return false;
5061 }
5062
5063 virtual const char *getClobbers() const {
5064 return "";
5065 }
5066};
5067
5068void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
5069 unsigned &NumNames) const {
5070 Names = NULL;
5071 NumNames = 0;
5072}
5073
5074void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5075 unsigned &NumAliases) const {
5076 Aliases = NULL;
5077 NumAliases = 0;
5078}
5079} // end anonymous namespace.
5080
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005081namespace {
5082 static const unsigned SPIRAddrSpaceMap[] = {
5083 1, // opencl_global
5084 3, // opencl_local
5085 2, // opencl_constant
5086 0, // cuda_device
5087 0, // cuda_constant
5088 0 // cuda_shared
5089 };
5090 class SPIRTargetInfo : public TargetInfo {
5091 static const char * const GCCRegNames[];
5092 static const Builtin::Info BuiltinInfo[];
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005093 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005094 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005095 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
5096 "SPIR target must use unknown OS");
5097 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
5098 "SPIR target must use unknown environment type");
5099 BigEndian = false;
5100 TLSSupported = false;
5101 LongWidth = LongAlign = 64;
5102 AddrSpaceMap = &SPIRAddrSpaceMap;
5103 // Define available target features
5104 // These must be defined in sorted order!
5105 NoAsmVariants = true;
5106 }
5107 virtual void getTargetDefines(const LangOptions &Opts,
5108 MacroBuilder &Builder) const {
5109 DefineStd(Builder, "SPIR", Opts);
5110 }
5111 virtual bool hasFeature(StringRef Feature) const {
5112 return Feature == "spir";
5113 }
5114
5115 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5116 unsigned &NumRecords) const {}
5117 virtual const char *getClobbers() const {
5118 return "";
5119 }
5120 virtual void getGCCRegNames(const char * const *&Names,
5121 unsigned &NumNames) const {}
5122 virtual bool validateAsmConstraint(const char *&Name,
5123 TargetInfo::ConstraintInfo &info) const {
5124 return true;
5125 }
5126 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5127 unsigned &NumAliases) const {}
5128 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5129 return TargetInfo::VoidPtrBuiltinVaList;
5130 }
5131 };
5132
5133
5134 class SPIR32TargetInfo : public SPIRTargetInfo {
5135 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005136 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005137 PointerWidth = PointerAlign = 32;
5138 SizeType = TargetInfo::UnsignedInt;
5139 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
5140 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005141 = "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 +00005142 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5143 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5144 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005145 }
5146 virtual void getTargetDefines(const LangOptions &Opts,
5147 MacroBuilder &Builder) const {
5148 DefineStd(Builder, "SPIR32", Opts);
5149 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005150 };
5151
5152 class SPIR64TargetInfo : public SPIRTargetInfo {
5153 public:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005154 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005155 PointerWidth = PointerAlign = 64;
5156 SizeType = TargetInfo::UnsignedLong;
5157 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
5158 DescriptionString
Guy Benyeif3ddf632013-03-07 13:06:10 +00005159 = "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 +00005160 "f32:32:32-f64:64:64-v16:16:16-v24:32:32-v32:32:32-v48:64:64-"
5161 "v64:64:64-v96:128:128-v128:128:128-v192:256:256-v256:256:256-"
5162 "v512:512:512-v1024:1024:1024";
Guy Benyeif3ddf632013-03-07 13:06:10 +00005163 }
5164 virtual void getTargetDefines(const LangOptions &Opts,
5165 MacroBuilder &Builder) const {
5166 DefineStd(Builder, "SPIR64", Opts);
5167 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005168 };
5169}
5170
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005171namespace {
5172class XCoreTargetInfo : public TargetInfo {
5173 static const Builtin::Info BuiltinInfo[];
5174public:
5175 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5176 BigEndian = false;
5177 NoAsmVariants = true;
5178 LongLongAlign = 32;
5179 SuitableAlign = 32;
5180 DoubleAlign = LongDoubleAlign = 32;
5181 UseZeroLengthBitfieldAlignment = true;
5182 DescriptionString = "e-p:32:32:32-a0:0:32-n32"
5183 "-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:32"
5184 "-f16:16:32-f32:32:32-f64:32:32";
5185 }
5186 virtual void getTargetDefines(const LangOptions &Opts,
5187 MacroBuilder &Builder) const {
5188 Builder.defineMacro("__XS1B__");
5189 }
5190 virtual void getTargetBuiltins(const Builtin::Info *&Records,
5191 unsigned &NumRecords) const {
5192 Records = BuiltinInfo;
5193 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
5194 }
5195 virtual BuiltinVaListKind getBuiltinVaListKind() const {
5196 return TargetInfo::VoidPtrBuiltinVaList;
5197 }
5198 virtual const char *getClobbers() const {
5199 return "";
5200 }
5201 virtual void getGCCRegNames(const char * const *&Names,
5202 unsigned &NumNames) const {
5203 static const char * const GCCRegNames[] = {
5204 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5205 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
5206 };
5207 Names = GCCRegNames;
5208 NumNames = llvm::array_lengthof(GCCRegNames);
5209 }
5210 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
5211 unsigned &NumAliases) const {
5212 Aliases = NULL;
5213 NumAliases = 0;
5214 }
5215 virtual bool validateAsmConstraint(const char *&Name,
5216 TargetInfo::ConstraintInfo &Info) const {
5217 return false;
5218 }
5219};
5220
5221const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
5222#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5223#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5224 ALL_LANGUAGES },
5225#include "clang/Basic/BuiltinsXCore.def"
5226};
5227} // end anonymous namespace.
5228
Ivan Krasinef05abd2011-08-24 20:22:22 +00005229
Reid Spencer5f016e22007-07-11 17:01:13 +00005230//===----------------------------------------------------------------------===//
5231// Driver code
5232//===----------------------------------------------------------------------===//
5233
Benjamin Kramer9df08232013-06-29 16:37:14 +00005234static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005235 llvm::Triple::OSType os = Triple.getOS();
Eli Friedman61538a72008-05-20 14:21:01 +00005236
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005237 switch (Triple.getArch()) {
5238 default:
5239 return NULL;
Eli Friedman61538a72008-05-20 14:21:01 +00005240
Robert Lytton5f15f4d2013-08-13 09:43:10 +00005241 case llvm::Triple::xcore:
5242 return new XCoreTargetInfo(Triple);
5243
Tony Linthicum96319392011-12-12 21:14:55 +00005244 case llvm::Triple::hexagon:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005245 return new HexagonTargetInfo(Triple);
Tony Linthicum96319392011-12-12 21:14:55 +00005246
Tim Northoverc264e162013-01-31 12:13:10 +00005247 case llvm::Triple::aarch64:
5248 switch (os) {
5249 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005250 return new LinuxTargetInfo<AArch64TargetInfo>(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005251 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005252 return new AArch64TargetInfo(Triple);
Tim Northoverc264e162013-01-31 12:13:10 +00005253 }
5254
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005255 case llvm::Triple::arm:
Daniel Dunbarf4aa4f612009-09-11 01:14:50 +00005256 case llvm::Triple::thumb:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005257 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005258 return new DarwinARMTargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005259
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005260 switch (os) {
Rafael Espindola022a8a52010-06-10 00:46:51 +00005261 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005262 return new LinuxTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005263 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005264 return new FreeBSDTargetInfo<ARMTargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005265 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005266 return new NetBSDTargetInfo<ARMTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005267 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005268 return new OpenBSDTargetInfo<ARMTargetInfo>(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005269 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005270 return new BitrigTargetInfo<ARMTargetInfo>(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005271 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005272 return new RTEMSTargetInfo<ARMTargetInfo>(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005273 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005274 return new NaClTargetInfo<ARMTargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005275 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005276 return new ARMTargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005277 }
Eli Friedman61538a72008-05-20 14:21:01 +00005278
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005279 case llvm::Triple::msp430:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005280 return new MSP430TargetInfo(Triple);
Eli Friedman61538a72008-05-20 14:21:01 +00005281
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005282 case llvm::Triple::mips:
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005283 switch (os) {
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005284 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005285 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005286 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005287 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005288 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005289 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005290 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005291 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005292 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005293 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerfa9772b2011-07-05 18:05:54 +00005294 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005295
5296 case llvm::Triple::mipsel:
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005297 switch (os) {
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005298 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005299 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005300 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005301 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005302 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005303 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005304 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005305 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005306 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005307 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger94c9ce52011-07-05 18:24:04 +00005308 }
Edward O'Callaghan84423a82009-11-15 10:22:07 +00005309
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005310 case llvm::Triple::mips64:
5311 switch (os) {
5312 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005313 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005314 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005315 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005316 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005317 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005318 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005319 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005320 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005321 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005322 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005323 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005324 }
5325
5326 case llvm::Triple::mips64el:
5327 switch (os) {
5328 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005329 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005330 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005331 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005332 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005333 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005334 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005335 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005336 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005337 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005338 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005339 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabf5851a2011-09-20 19:21:49 +00005340 }
5341
Ivan Krasinef05abd2011-08-24 20:22:22 +00005342 case llvm::Triple::le32:
5343 switch (os) {
Eli Bendersky441d9f72012-12-04 18:38:10 +00005344 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005345 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasinef05abd2011-08-24 20:22:22 +00005346 default:
5347 return NULL;
5348 }
5349
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005350 case llvm::Triple::ppc:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005351 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005352 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005353 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005354 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005355 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005356 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005357 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005358 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005359 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005360 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005361 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005362 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005363 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005364 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005365 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005366 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005367
5368 case llvm::Triple::ppc64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005369 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005370 return new DarwinPPC64TargetInfo(Triple);
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<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005374 case llvm::Triple::Lv2:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005375 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005376 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005377 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005378 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005379 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005380 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005381 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005382 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005383
Bill Schmidtea7fb0c2013-07-26 01:36:11 +00005384 case llvm::Triple::ppc64le:
5385 switch (os) {
5386 case llvm::Triple::Linux:
5387 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
5388 default:
5389 return new PPC64TargetInfo(Triple);
5390 }
5391
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005392 case llvm::Triple::nvptx:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005393 return new NVPTX32TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005394 case llvm::Triple::nvptx64:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005395 return new NVPTX64TargetInfo(Triple);
Peter Collingbourneedb66f32012-05-20 23:28:41 +00005396
Eli Friedman6505a292012-10-12 23:32:00 +00005397 case llvm::Triple::r600:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005398 return new R600TargetInfo(Triple);
Eli Friedman6505a292012-10-12 23:32:00 +00005399
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005400 case llvm::Triple::sparc:
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005401 switch (os) {
Anton Korobeynikov7e1812f2011-10-12 09:30:58 +00005402 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005403 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005404 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005405 return new AuroraUXSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005406 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005407 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005408 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005409 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg5e601dc2012-08-02 13:45:48 +00005410 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005411 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005412 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005413 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005414 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005415 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger9a11b742011-07-04 21:59:44 +00005416 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005417
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005418 case llvm::Triple::sparcv9:
5419 switch (os) {
5420 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005421 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005422 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005423 return new AuroraUXTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005424 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005425 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005426 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005427 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005428 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005429 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005430 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005431 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005432 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005433 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen56e1f1f2013-04-16 15:17:49 +00005434 }
5435
Ulrich Weigandb8409212013-05-06 16:26:41 +00005436 case llvm::Triple::systemz:
5437 switch (os) {
5438 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005439 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005440 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005441 return new SystemZTargetInfo(Triple);
Ulrich Weigandb8409212013-05-06 16:26:41 +00005442 }
5443
Eli Friedmanb63decf2009-08-19 20:47:07 +00005444 case llvm::Triple::tce:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005445 return new TCETargetInfo(Triple);
Eli Friedmanb63decf2009-08-19 20:47:07 +00005446
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005447 case llvm::Triple::x86:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005448 if (Triple.isOSDarwin())
Benjamin Kramer9df08232013-06-29 16:37:14 +00005449 return new DarwinI386TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005450
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005451 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005452 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005453 return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005454 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005455 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005456 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005457 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005458 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005459 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005460 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005461 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005462 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005463 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005464 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005465 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner38e317d2010-07-07 16:01:42 +00005466 case llvm::Triple::Minix:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005467 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005468 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005469 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005470 case llvm::Triple::Cygwin:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005471 return new CygwinX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005472 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005473 return new MinGWX86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005474 case llvm::Triple::Win32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005475 return new VisualStudioWindowsX86_32TargetInfo(Triple);
Chris Lattner86ed3a32010-04-11 19:29:39 +00005476 case llvm::Triple::Haiku:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005477 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregordca52262011-07-01 22:41:14 +00005478 case llvm::Triple::RTEMS:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005479 return new RTEMSX86_32TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005480 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005481 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005482 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005483 return new X86_32TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005484 }
5485
5486 case llvm::Triple::x86_64:
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005487 if (Triple.isOSDarwin() || Triple.getEnvironment() == llvm::Triple::MachO)
Benjamin Kramer9df08232013-06-29 16:37:14 +00005488 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbardb57a4c2011-04-19 21:43:27 +00005489
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005490 switch (os) {
Edward O'Callaghan991f9a72009-10-18 13:33:59 +00005491 case llvm::Triple::AuroraUX:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005492 return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005493 case llvm::Triple::Linux:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005494 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner7a7ca282010-01-09 05:41:14 +00005495 case llvm::Triple::DragonFly:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005496 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005497 case llvm::Triple::NetBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005498 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005499 case llvm::Triple::OpenBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005500 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman42f74f22012-08-08 23:57:20 +00005501 case llvm::Triple::Bitrig:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005502 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005503 case llvm::Triple::FreeBSD:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005504 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005505 case llvm::Triple::Solaris:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005506 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
NAKAMURA Takumi0aa20572011-02-17 08:51:38 +00005507 case llvm::Triple::MinGW32:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005508 return new MinGWX86_64TargetInfo(Triple);
Daniel Dunbar9fe4a5d2009-09-23 07:31:35 +00005509 case llvm::Triple::Win32: // This is what Triple.h supports now.
Benjamin Kramer9df08232013-06-29 16:37:14 +00005510 return new VisualStudioWindowsX86_64TargetInfo(Triple);
Eli Bendersky441d9f72012-12-04 18:38:10 +00005511 case llvm::Triple::NaCl:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005512 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005513 default:
Benjamin Kramer9df08232013-06-29 16:37:14 +00005514 return new X86_64TargetInfo(Triple);
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005515 }
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005516
5517 case llvm::Triple::spir: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005518 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005519 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005520 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005521 return new SPIR32TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005522 }
5523 case llvm::Triple::spir64: {
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005524 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramer9df08232013-06-29 16:37:14 +00005525 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005526 return NULL;
Benjamin Kramer9df08232013-06-29 16:37:14 +00005527 return new SPIR64TargetInfo(Triple);
Guy Benyeibd5da3c2012-12-11 21:38:14 +00005528 }
Daniel Dunbar9d6fa612009-08-18 05:47:58 +00005529 }
Reid Spencer5f016e22007-07-11 17:01:13 +00005530}
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005531
5532/// CreateTargetInfo - Return the target info object for the specified target
5533/// triple.
David Blaikied6471f72011-09-25 23:23:43 +00005534TargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Douglas Gregor49a87542012-11-16 04:24:59 +00005535 TargetOptions *Opts) {
5536 llvm::Triple Triple(Opts->Triple);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005537
5538 // Construct the target
Benjamin Kramer9df08232013-06-29 16:37:14 +00005539 OwningPtr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005540 if (!Target) {
5541 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
5542 return 0;
5543 }
Douglas Gregor9a022bb2012-10-15 16:45:32 +00005544 Target->setTargetOpts(Opts);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005545
Daniel Dunbareac7c532009-12-18 18:42:37 +00005546 // Set the target CPU if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005547 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
5548 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Daniel Dunbareac7c532009-12-18 18:42:37 +00005549 return 0;
5550 }
5551
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005552 // Set the target ABI if specified.
Douglas Gregor49a87542012-11-16 04:24:59 +00005553 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
5554 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005555 return 0;
5556 }
5557
Charles Davis98b7c5c2010-06-11 01:06:47 +00005558 // Set the target C++ ABI.
Douglas Gregor49a87542012-11-16 04:24:59 +00005559 if (!Opts->CXXABI.empty() && !Target->setCXXABI(Opts->CXXABI)) {
5560 Diags.Report(diag::err_target_unknown_cxxabi) << Opts->CXXABI;
Charles Davis98b7c5c2010-06-11 01:06:47 +00005561 return 0;
5562 }
5563
Rafael Espindola5389b842013-08-21 21:59:03 +00005564 // Set the fp math unit.
5565 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
5566 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
5567 return 0;
5568 }
5569
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005570 // Compute the default target features, we need the target to handle this
5571 // because features may have dependencies on one another.
5572 llvm::StringMap<bool> Features;
Chandler Carruthc3a2e652011-09-28 05:56:05 +00005573 Target->getDefaultFeatures(Features);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005574
Rafael Espindolac84ed542013-08-20 18:57:55 +00005575 // Apply the user specified deltas.
5576 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
5577 I < N; ++I) {
5578 const char *Name = Opts->FeaturesAsWritten[I].c_str();
Rafael Espindola53ac3d82011-11-27 20:00:43 +00005579 // Apply the feature via the target.
Rafael Espindolac84ed542013-08-20 18:57:55 +00005580 bool Enabled = Name[0] == '+';
5581 Target->setFeatureEnabled(Features, Name + 1, Enabled);
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005582 }
5583
5584 // Add the features to the compile options.
5585 //
5586 // FIXME: If we are completely confident that we have the right set, we only
5587 // need to pass the minuses.
Douglas Gregor49a87542012-11-16 04:24:59 +00005588 Opts->Features.clear();
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005589 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
5590 ie = Features.end(); it != ie; ++it)
Douglas Gregor49a87542012-11-16 04:24:59 +00005591 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
Rafael Espindola5389b842013-08-21 21:59:03 +00005592 if (!Target->HandleTargetFeatures(Opts->Features, Diags))
5593 return 0;
Daniel Dunbard58c03f2009-11-15 06:48:46 +00005594
5595 return Target.take();
5596}