blob: 4604b1cfa0fce59011e47838ecf069df98fed71c [file] [log] [blame]
Chris Lattner5ba61f02006-10-14 07:39:34 +00001//===--- Targets.cpp - Implement -arch option and targets -----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner5ba61f02006-10-14 07:39:34 +00007//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000010// This file implements construction of a TargetInfo object from a
Ted Kremenek6f6ff372007-12-12 18:05:32 +000011// target triple.
Chris Lattner5ba61f02006-10-14 07:39:34 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner5ba61f02006-10-14 07:39:34 +000015#include "clang/Basic/TargetInfo.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000016#include "clang/Basic/Builtins.h"
17#include "clang/Basic/Diagnostic.h"
Chris Lattnerc7c6dd42008-12-04 22:54:33 +000018#include "clang/Basic/LangOptions.h"
Chandler Carruth26b29a02010-01-20 06:13:02 +000019#include "clang/Basic/MacroBuilder.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000020#include "clang/Basic/TargetBuiltins.h"
21#include "clang/Basic/TargetOptions.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000022#include "llvm/ADT/APFloat.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000023#include "llvm/ADT/STLExtras.h"
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +000024#include "llvm/ADT/StringExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000025#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000026#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000027#include "llvm/ADT/Triple.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000028#include "llvm/IR/Type.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000031#include <algorithm>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000032#include <memory>
Chris Lattner5ba61f02006-10-14 07:39:34 +000033using namespace clang;
34
Chris Lattner5ba61f02006-10-14 07:39:34 +000035//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000036// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000037//===----------------------------------------------------------------------===//
38
Chris Lattner1e1c0b92009-03-20 16:06:38 +000039/// DefineStd - Define a macro name and standard variants. For example if
40/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
41/// when in GNU mode.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000042static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000043 const LangOptions &Opts) {
44 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000045
Chris Lattner1e1c0b92009-03-20 16:06:38 +000046 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
47 // in the user's namespace.
48 if (Opts.GNUMode)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000049 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000050
Chris Lattner1e1c0b92009-03-20 16:06:38 +000051 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000052 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000053
Chris Lattner1e1c0b92009-03-20 16:06:38 +000054 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000055 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000056}
57
Benjamin Kramere3b442d2012-01-10 11:50:09 +000058static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
59 bool Tuning = true) {
60 Builder.defineMacro("__" + CPUName);
61 Builder.defineMacro("__" + CPUName + "__");
62 if (Tuning)
63 Builder.defineMacro("__tune_" + CPUName + "__");
64}
65
Chris Lattner09d98f52008-10-05 21:50:58 +000066//===----------------------------------------------------------------------===//
67// Defines specific to certain operating systems.
68//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000069
Torok Edwinb2b37c62009-06-30 17:10:35 +000070namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000071template<typename TgtInfo>
72class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000073protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000074 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000075 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000076public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +000077 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +000078 void getTargetDefines(const LangOptions &Opts,
79 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000080 TgtInfo::getTargetDefines(Opts, Builder);
81 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000082 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000083
84};
Chris Lattner859c37a2009-08-12 06:24:27 +000085} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000086
Chris Lattner30ba6742009-08-10 19:03:04 +000087
Daniel Dunbard86666f2010-01-26 01:44:04 +000088static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000089 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000090 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000091 VersionTuple &PlatformMinVersion) {
Bob Wilson834400b2013-08-19 20:23:37 +000092 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000093 Builder.defineMacro("__APPLE__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000094 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenkob4f81902012-09-20 10:10:01 +000095 // AddressSanitizer doesn't play well with source fortification, which is on
96 // by default on Darwin.
Will Dietzf54319c2013-01-18 11:30:38 +000097 if (Opts.Sanitize.Address) Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000098
John McCall5d36a8c2011-06-16 00:03:19 +000099 if (!Opts.ObjCAutoRefCount) {
John McCall31168b02011-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 Korobeynikov9d026dd2009-05-03 13:42:53 +0000102
John McCall31168b02011-06-15 23:02:42 +0000103 // Darwin defines __strong even in C mode (just to nothing).
Douglas Gregor79a91412011-09-13 17:21:33 +0000104 if (Opts.getGC() != LangOptions::NonGC)
John McCall31168b02011-06-15 23:02:42 +0000105 Builder.defineMacro("__strong", "__attribute__((objc_gc(strong)))");
106 else
107 Builder.defineMacro("__strong", "");
Eric Christopher0c912c52011-07-07 22:55:26 +0000108
John McCall31168b02011-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 McCall31168b02011-06-15 23:02:42 +0000113 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000114
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000115 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000116 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000117 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000118 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000119
120 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000121 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000122
Daniel Dunbarecf13562011-04-19 21:40:34 +0000123 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000124 unsigned Maj, Min, Rev;
Bob Wilson8e5acc52012-01-31 23:52:58 +0000125 if (Triple.isMacOSX()) {
126 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbarecf13562011-04-19 21:40:34 +0000127 PlatformName = "macosx";
Daniel Dunbarecf13562011-04-19 21:40:34 +0000128 } else {
Bob Wilson8e5acc52012-01-31 23:52:58 +0000129 Triple.getOSVersion(Maj, Min, Rev);
130 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000131 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000132
Sebastian Pop422377c2012-01-20 22:01:23 +0000133 // If -target arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000134 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-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
Evan Cheng31dd9a62014-01-26 23:12:43 +0000141 // Set the appropriate OS version define.
142 if (Triple.isiOS()) {
143 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
144 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__",
152 Str);
153 } else if (Triple.isMacOSX()) {
154 // Note that the Driver allows versions which aren't representable in the
155 // define (because we only get a single digit for the minor and micro
156 // revision numbers). So, we limit them to the maximum representable
157 // version.
158 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Bob Wilson2a3710e2014-08-08 21:45:53 +0000159 char Str[7];
160 if (Maj < 10 || (Maj == 10 && Min < 10)) {
161 Str[0] = '0' + (Maj / 10);
162 Str[1] = '0' + (Maj % 10);
163 Str[2] = '0' + std::min(Min, 9U);
164 Str[3] = '0' + std::min(Rev, 9U);
165 Str[4] = '\0';
166 } else {
167 // Handle versions > 10.9.
168 Str[0] = '0' + (Maj / 10);
169 Str[1] = '0' + (Maj % 10);
170 Str[2] = '0' + (Min / 10);
171 Str[3] = '0' + (Min % 10);
172 Str[4] = '0' + (Rev / 10);
173 Str[5] = '0' + (Rev % 10);
174 Str[6] = '\0';
175 }
Evan Cheng31dd9a62014-01-26 23:12:43 +0000176 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000177 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000178
Tim Northover157d9112014-01-16 08:48:16 +0000179 // Tell users about the kernel if there is one.
180 if (Triple.isOSDarwin())
181 Builder.defineMacro("__MACH__");
182
Daniel Dunbarecf13562011-04-19 21:40:34 +0000183 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000184}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000185
Chris Lattner30ba6742009-08-10 19:03:04 +0000186namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000187template<typename Target>
188class DarwinTargetInfo : public OSTargetInfo<Target> {
189protected:
Craig Topper3164f332014-03-11 03:39:26 +0000190 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
191 MacroBuilder &Builder) const override {
Eric Christopher0c912c52011-07-07 22:55:26 +0000192 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000193 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000194 }
Mike Stump11289f42009-09-09 15:08:12 +0000195
Torok Edwinb2b37c62009-06-30 17:10:35 +0000196public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000197 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
198 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
199 this->MCountName = "\01mcount";
200 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000201
Craig Topper3164f332014-03-11 03:39:26 +0000202 std::string isValidSectionSpecifier(StringRef SR) const override {
Chris Lattner30ba6742009-08-10 19:03:04 +0000203 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000204 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000205 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000206 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000207 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000208 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000209 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000210
Craig Topper3164f332014-03-11 03:39:26 +0000211 const char *getStaticInitSectionSpecifier() const override {
Anders Carlsson851318a2010-06-08 22:47:50 +0000212 // FIXME: We should return 0 when building kexts.
213 return "__TEXT,__StaticInit,regular,pure_instructions";
214 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000215
John McCalleed64c72012-01-29 01:20:30 +0000216 /// Darwin does not support protected visibility. Darwin's "default"
217 /// is very similar to ELF's "protected"; Darwin requires a "weak"
218 /// attribute on declarations that can be dynamically replaced.
Craig Topper3164f332014-03-11 03:39:26 +0000219 bool hasProtectedVisibility() const override {
John McCalleed64c72012-01-29 01:20:30 +0000220 return false;
221 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000222};
223
Chris Lattner30ba6742009-08-10 19:03:04 +0000224
Torok Edwinb2b37c62009-06-30 17:10:35 +0000225// DragonFlyBSD Target
226template<typename Target>
227class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
228protected:
Craig Topper3164f332014-03-11 03:39:26 +0000229 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
230 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000231 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000232 Builder.defineMacro("__DragonFly__");
233 Builder.defineMacro("__DragonFly_cc_version", "100001");
234 Builder.defineMacro("__ELF__");
235 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
236 Builder.defineMacro("__tune_i386__");
237 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000238 }
239public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000240 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
241 : OSTargetInfo<Target>(Triple) {
242 this->UserLabelPrefix = "";
Eli Friedman4286fba2012-02-10 23:02:29 +0000243
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000244 switch (Triple.getArch()) {
245 default:
246 case llvm::Triple::x86:
247 case llvm::Triple::x86_64:
248 this->MCountName = ".mcount";
249 break;
250 }
Eli Friedman4286fba2012-02-10 23:02:29 +0000251 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000252};
253
254// FreeBSD Target
255template<typename Target>
256class FreeBSDTargetInfo : public OSTargetInfo<Target> {
257protected:
Craig Topper3164f332014-03-11 03:39:26 +0000258 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
259 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000260 // FreeBSD defines; list based off of gcc output
261
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000262 unsigned Release = Triple.getOSMajorVersion();
263 if (Release == 0U)
264 Release = 8;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000265
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000266 Builder.defineMacro("__FreeBSD__", Twine(Release));
267 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000268 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
269 DefineStd(Builder, "unix", Opts);
270 Builder.defineMacro("__ELF__");
Ed Schoutend0621462013-09-29 07:54:52 +0000271
272 // On FreeBSD, wchar_t contains the number of the code point as
273 // used by the character set of the locale. These character sets are
274 // not necessarily a superset of ASCII.
275 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000276 }
277public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000278 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
279 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000280
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000281 switch (Triple.getArch()) {
282 default:
283 case llvm::Triple::x86:
284 case llvm::Triple::x86_64:
285 this->MCountName = ".mcount";
286 break;
287 case llvm::Triple::mips:
288 case llvm::Triple::mipsel:
289 case llvm::Triple::ppc:
290 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +0000291 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000292 this->MCountName = "_mcount";
293 break;
294 case llvm::Triple::arm:
295 this->MCountName = "__mcount";
296 break;
Duncan Sands9cb27e92009-07-08 13:55:08 +0000297 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000298 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000299};
300
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000301// GNU/kFreeBSD Target
302template<typename Target>
303class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
304protected:
Craig Topper3164f332014-03-11 03:39:26 +0000305 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
306 MacroBuilder &Builder) const override {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000307 // GNU/kFreeBSD defines; list based off of gcc output
308
309 DefineStd(Builder, "unix", Opts);
310 Builder.defineMacro("__FreeBSD_kernel__");
311 Builder.defineMacro("__GLIBC__");
312 Builder.defineMacro("__ELF__");
313 if (Opts.POSIXThreads)
314 Builder.defineMacro("_REENTRANT");
315 if (Opts.CPlusPlus)
316 Builder.defineMacro("_GNU_SOURCE");
317 }
318public:
Sylvestre Ledru15832282013-09-05 13:58:07 +0000319 KFreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000320 this->UserLabelPrefix = "";
321 }
322};
323
Chris Lattner3e2ee142010-07-07 16:01:42 +0000324// Minix Target
325template<typename Target>
326class MinixTargetInfo : public OSTargetInfo<Target> {
327protected:
Craig Topper3164f332014-03-11 03:39:26 +0000328 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
329 MacroBuilder &Builder) const override {
Chris Lattner3e2ee142010-07-07 16:01:42 +0000330 // Minix defines
331
332 Builder.defineMacro("__minix", "3");
333 Builder.defineMacro("_EM_WSIZE", "4");
334 Builder.defineMacro("_EM_PSIZE", "4");
335 Builder.defineMacro("_EM_SSIZE", "2");
336 Builder.defineMacro("_EM_LSIZE", "4");
337 Builder.defineMacro("_EM_FSIZE", "4");
338 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000339 Builder.defineMacro("__ELF__");
Chris Lattner3e2ee142010-07-07 16:01:42 +0000340 DefineStd(Builder, "unix", Opts);
341 }
342public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000343 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
344 this->UserLabelPrefix = "";
345 }
Chris Lattner3e2ee142010-07-07 16:01:42 +0000346};
347
Torok Edwinb2b37c62009-06-30 17:10:35 +0000348// Linux target
349template<typename Target>
350class LinuxTargetInfo : public OSTargetInfo<Target> {
351protected:
Craig Topper3164f332014-03-11 03:39:26 +0000352 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
353 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000354 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000355 DefineStd(Builder, "unix", Opts);
356 DefineStd(Builder, "linux", Opts);
357 Builder.defineMacro("__gnu_linux__");
358 Builder.defineMacro("__ELF__");
Logan Chienc6fd8202012-09-02 09:30:11 +0000359 if (Triple.getEnvironment() == llvm::Triple::Android)
Evgeniy Stepanov94dc4c92012-04-26 12:08:09 +0000360 Builder.defineMacro("__ANDROID__", "1");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000361 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000362 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000363 if (Opts.CPlusPlus)
364 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000365 }
366public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000367 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000368 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000369 this->WIntType = TargetInfo::UnsignedInt;
Hal Finkelecdb4542014-03-30 13:00:06 +0000370
371 switch (Triple.getArch()) {
372 default:
373 break;
374 case llvm::Triple::ppc:
375 case llvm::Triple::ppc64:
376 case llvm::Triple::ppc64le:
377 this->MCountName = "_mcount";
378 break;
379 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000380 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000381
Craig Topper3164f332014-03-11 03:39:26 +0000382 const char *getStaticInitSectionSpecifier() const override {
Benjamin Kramera518b222011-10-15 17:53:33 +0000383 return ".text.startup";
384 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000385};
386
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000387// NetBSD Target
388template<typename Target>
389class NetBSDTargetInfo : public OSTargetInfo<Target> {
390protected:
Craig Topper3164f332014-03-11 03:39:26 +0000391 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
392 MacroBuilder &Builder) const override {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000393 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000394 Builder.defineMacro("__NetBSD__");
395 Builder.defineMacro("__unix__");
396 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000397 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000398 Builder.defineMacro("_POSIX_THREADS");
Joerg Sonnenbergercc1edb52014-05-13 18:58:36 +0000399
400 switch (Triple.getArch()) {
401 default:
402 break;
403 case llvm::Triple::arm:
404 case llvm::Triple::armeb:
405 case llvm::Triple::thumb:
406 case llvm::Triple::thumbeb:
407 Builder.defineMacro("__ARM_DWARF_EH__");
408 break;
409 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000410 }
411public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000412 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
413 this->UserLabelPrefix = "";
414 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000415};
416
Torok Edwinb2b37c62009-06-30 17:10:35 +0000417// OpenBSD Target
418template<typename Target>
419class OpenBSDTargetInfo : public OSTargetInfo<Target> {
420protected:
Craig Topper3164f332014-03-11 03:39:26 +0000421 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
422 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000423 // OpenBSD defines; list based off of gcc output
424
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000425 Builder.defineMacro("__OpenBSD__");
426 DefineStd(Builder, "unix", Opts);
427 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000428 if (Opts.POSIXThreads)
Chris Lattner024e12d2012-04-25 06:12:24 +0000429 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000430 }
431public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000432 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
433 this->UserLabelPrefix = "";
434 this->TLSSupported = false;
Eli Friedman3715d1f2011-12-15 02:15:56 +0000435
Eli Friedman3715d1f2011-12-15 02:15:56 +0000436 switch (Triple.getArch()) {
437 default:
438 case llvm::Triple::x86:
439 case llvm::Triple::x86_64:
440 case llvm::Triple::arm:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000441 case llvm::Triple::sparc:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000442 this->MCountName = "__mcount";
443 break;
444 case llvm::Triple::mips64:
445 case llvm::Triple::mips64el:
446 case llvm::Triple::ppc:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000447 case llvm::Triple::sparcv9:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000448 this->MCountName = "_mcount";
449 break;
450 }
451 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000452};
453
Eli Friedman9fa28852012-08-08 23:57:20 +0000454// Bitrig Target
455template<typename Target>
456class BitrigTargetInfo : public OSTargetInfo<Target> {
457protected:
Craig Topper3164f332014-03-11 03:39:26 +0000458 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
459 MacroBuilder &Builder) const override {
Eli Friedman9fa28852012-08-08 23:57:20 +0000460 // Bitrig defines; list based off of gcc output
461
462 Builder.defineMacro("__Bitrig__");
463 DefineStd(Builder, "unix", Opts);
464 Builder.defineMacro("__ELF__");
465 if (Opts.POSIXThreads)
466 Builder.defineMacro("_REENTRANT");
467 }
468public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000469 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
470 this->UserLabelPrefix = "";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000471 this->MCountName = "__mcount";
Eli Friedman9fa28852012-08-08 23:57:20 +0000472 }
473};
474
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000475// PSP Target
476template<typename Target>
477class PSPTargetInfo : public OSTargetInfo<Target> {
478protected:
Craig Topper3164f332014-03-11 03:39:26 +0000479 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
480 MacroBuilder &Builder) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000481 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000482 Builder.defineMacro("PSP");
483 Builder.defineMacro("_PSP");
484 Builder.defineMacro("__psp__");
485 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000486 }
487public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000488 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000489 this->UserLabelPrefix = "";
490 }
491};
492
John Thompsone467e192009-11-19 17:18:50 +0000493// PS3 PPU Target
494template<typename Target>
495class PS3PPUTargetInfo : public OSTargetInfo<Target> {
496protected:
Craig Topper3164f332014-03-11 03:39:26 +0000497 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
498 MacroBuilder &Builder) const override {
John Thompsone467e192009-11-19 17:18:50 +0000499 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000500 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000501 Builder.defineMacro("__PPU__");
502 Builder.defineMacro("__CELLOS_LV2__");
503 Builder.defineMacro("__ELF__");
504 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000505 Builder.defineMacro("_ARCH_PPC64");
506 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000507 }
508public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000509 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompsone467e192009-11-19 17:18:50 +0000510 this->UserLabelPrefix = "";
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000511 this->LongWidth = this->LongAlign = 32;
512 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000513 this->IntMaxType = TargetInfo::SignedLongLong;
John Thompson07a61a42010-06-24 22:44:13 +0000514 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000515 this->SizeType = TargetInfo::UnsignedInt;
Rafael Espindolac418ae92014-01-03 19:22:05 +0000516 this->DescriptionString = "E-m:e-p:32:32-i64:64-n32:64";
John Thompsone467e192009-11-19 17:18:50 +0000517 }
518};
519
Torok Edwinb2b37c62009-06-30 17:10:35 +0000520// Solaris target
521template<typename Target>
522class SolarisTargetInfo : public OSTargetInfo<Target> {
523protected:
Craig Topper3164f332014-03-11 03:39:26 +0000524 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
525 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000526 DefineStd(Builder, "sun", Opts);
527 DefineStd(Builder, "unix", Opts);
528 Builder.defineMacro("__ELF__");
529 Builder.defineMacro("__svr4__");
530 Builder.defineMacro("__SVR4");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000531 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
532 // newer, but to 500 for everything else. feature_test.h has a check to
533 // ensure that you are not using C99 with an old version of X/Open or C89
Richard Smithab506ad2014-10-20 23:26:58 +0000534 // with a new version.
535 if (Opts.C99)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000536 Builder.defineMacro("_XOPEN_SOURCE", "600");
537 else
538 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnalle04307e2012-03-02 10:49:52 +0000539 if (Opts.CPlusPlus)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000540 Builder.defineMacro("__C99FEATURES__");
David Chisnall0c1941cb2012-02-17 18:35:11 +0000541 Builder.defineMacro("_LARGEFILE_SOURCE");
542 Builder.defineMacro("_LARGEFILE64_SOURCE");
543 Builder.defineMacro("__EXTENSIONS__");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000544 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000545 }
546public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000547 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000548 this->UserLabelPrefix = "";
David Chisnallb526e932012-03-28 18:04:14 +0000549 this->WCharType = this->SignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000550 // FIXME: WIntType should be SignedLong
551 }
552};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000553
554// Windows target
555template<typename Target>
556class WindowsTargetInfo : public OSTargetInfo<Target> {
557protected:
Craig Topper3164f332014-03-11 03:39:26 +0000558 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
559 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000560 Builder.defineMacro("_WIN32");
561 }
562 void getVisualStudioDefines(const LangOptions &Opts,
563 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000564 if (Opts.CPlusPlus) {
David Majnemerf6072342014-07-01 22:24:56 +0000565 if (Opts.RTTIData)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000566 Builder.defineMacro("_CPPRTTI");
567
568 if (Opts.Exceptions)
569 Builder.defineMacro("_CPPUNWIND");
570 }
571
572 if (!Opts.CharIsSigned)
573 Builder.defineMacro("_CHAR_UNSIGNED");
574
575 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
576 // but it works for now.
577 if (Opts.POSIXThreads)
578 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000579
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +0000580 if (Opts.MSCompatibilityVersion) {
581 Builder.defineMacro("_MSC_VER",
582 Twine(Opts.MSCompatibilityVersion / 100000));
583 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000584 // FIXME We cannot encode the revision information into 32-bits
585 Builder.defineMacro("_MSC_BUILD", Twine(1));
586 }
Reid Kleckner6f6e76d2014-04-16 20:10:16 +0000587
588 if (Opts.MicrosoftExt) {
589 Builder.defineMacro("_MSC_EXTENSIONS");
590
591 if (Opts.CPlusPlus11) {
592 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
593 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
594 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
595 }
596 }
597
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000598 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000599 }
600
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000601public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000602 WindowsTargetInfo(const llvm::Triple &Triple)
603 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000604};
605
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000606template <typename Target>
607class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000608protected:
Craig Topper3164f332014-03-11 03:39:26 +0000609 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
610 MacroBuilder &Builder) const override {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000611 if (Opts.POSIXThreads)
612 Builder.defineMacro("_REENTRANT");
613 if (Opts.CPlusPlus)
614 Builder.defineMacro("_GNU_SOURCE");
615
616 DefineStd(Builder, "unix", Opts);
617 Builder.defineMacro("__ELF__");
618 Builder.defineMacro("__native_client__");
619 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000620
621public:
622 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000623 this->UserLabelPrefix = "";
624 this->LongAlign = 32;
625 this->LongWidth = 32;
626 this->PointerAlign = 32;
627 this->PointerWidth = 32;
628 this->IntMaxType = TargetInfo::SignedLongLong;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000629 this->Int64Type = TargetInfo::SignedLongLong;
630 this->DoubleAlign = 64;
631 this->LongDoubleWidth = 64;
632 this->LongDoubleAlign = 64;
Jan Wen Voung1f9c4ee2014-01-15 21:42:41 +0000633 this->LongLongWidth = 64;
634 this->LongLongAlign = 64;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000635 this->SizeType = TargetInfo::UnsignedInt;
636 this->PtrDiffType = TargetInfo::SignedInt;
637 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +0000638 // RegParmMax is inherited from the underlying architecture
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000639 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Rafael Espindola1c09b262013-12-18 23:41:04 +0000640 if (Triple.getArch() == llvm::Triple::arm) {
Tim Northoverb98dc4b2014-10-14 20:57:29 +0000641 this->DescriptionString = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000642 } else if (Triple.getArch() == llvm::Triple::x86) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000643 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000644 } else if (Triple.getArch() == llvm::Triple::x86_64) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000645 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000646 } else if (Triple.getArch() == llvm::Triple::mipsel) {
647 // Handled on mips' setDescriptionString.
648 } else {
649 assert(Triple.getArch() == llvm::Triple::le32);
650 this->DescriptionString = "e-p:32:32-i64:64";
651 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000652 }
Craig Topper3164f332014-03-11 03:39:26 +0000653 typename Target::CallingConvCheckResult checkCallingConvention(
654 CallingConv CC) const override {
Derek Schuffa2020962012-10-16 22:30:41 +0000655 return CC == CC_PnaclCall ? Target::CCCR_OK :
656 Target::checkCallingConvention(CC);
657 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000658};
Mike Stump11289f42009-09-09 15:08:12 +0000659} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000660
Chris Lattner09d98f52008-10-05 21:50:58 +0000661//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000662// Specific target implementations.
663//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000664
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000665namespace {
666// PPC abstract base class
667class PPCTargetInfo : public TargetInfo {
668 static const Builtin::Info BuiltinInfo[];
669 static const char * const GCCRegNames[];
670 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel8eb59282012-06-11 22:35:19 +0000671 std::string CPU;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000672
673 // Target cpu features.
674 bool HasVSX;
Bill Schmidt8c184e32014-10-10 17:21:23 +0000675 bool HasP8Vector;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000676
Ulrich Weigand8afad612014-07-28 13:17:52 +0000677protected:
678 std::string ABI;
679
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000680public:
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000681 PPCTargetInfo(const llvm::Triple &Triple)
Bill Schmidt8c184e32014-10-10 17:21:23 +0000682 : TargetInfo(Triple), HasVSX(false), HasP8Vector(false) {
Bill Schmidt778d3872013-07-26 01:36:11 +0000683 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber3435ede2012-01-31 02:07:33 +0000684 LongDoubleWidth = LongDoubleAlign = 128;
685 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
686 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000687
Hal Finkel6b984f02012-07-03 16:51:04 +0000688 /// \brief Flags for architecture specific defines.
689 typedef enum {
690 ArchDefineNone = 0,
691 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
692 ArchDefinePpcgr = 1 << 1,
693 ArchDefinePpcsq = 1 << 2,
694 ArchDefine440 = 1 << 3,
695 ArchDefine603 = 1 << 4,
696 ArchDefine604 = 1 << 5,
697 ArchDefinePwr4 = 1 << 6,
Bill Schmidt38378a02013-02-01 20:23:10 +0000698 ArchDefinePwr5 = 1 << 7,
699 ArchDefinePwr5x = 1 << 8,
700 ArchDefinePwr6 = 1 << 9,
701 ArchDefinePwr6x = 1 << 10,
702 ArchDefinePwr7 = 1 << 11,
Will Schmidtf0487512014-06-26 13:34:10 +0000703 ArchDefinePwr8 = 1 << 12,
704 ArchDefineA2 = 1 << 13,
705 ArchDefineA2q = 1 << 14
Hal Finkel6b984f02012-07-03 16:51:04 +0000706 } ArchDefineTypes;
707
Bill Schmidt38378a02013-02-01 20:23:10 +0000708 // Note: GCC recognizes the following additional cpus:
709 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
710 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
711 // titan, rs64.
Craig Topper3164f332014-03-11 03:39:26 +0000712 bool setCPU(const std::string &Name) override {
Hal Finkel8eb59282012-06-11 22:35:19 +0000713 bool CPUKnown = llvm::StringSwitch<bool>(Name)
714 .Case("generic", true)
715 .Case("440", true)
716 .Case("450", true)
717 .Case("601", true)
718 .Case("602", true)
719 .Case("603", true)
720 .Case("603e", true)
721 .Case("603ev", true)
722 .Case("604", true)
723 .Case("604e", true)
724 .Case("620", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000725 .Case("630", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000726 .Case("g3", true)
727 .Case("7400", true)
728 .Case("g4", true)
729 .Case("7450", true)
730 .Case("g4+", true)
731 .Case("750", true)
732 .Case("970", true)
733 .Case("g5", true)
734 .Case("a2", true)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +0000735 .Case("a2q", true)
Hal Finkelf6d6cb02012-09-18 22:25:03 +0000736 .Case("e500mc", true)
737 .Case("e5500", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000738 .Case("power3", true)
739 .Case("pwr3", true)
740 .Case("power4", true)
741 .Case("pwr4", true)
742 .Case("power5", true)
743 .Case("pwr5", true)
744 .Case("power5x", true)
745 .Case("pwr5x", true)
746 .Case("power6", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000747 .Case("pwr6", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000748 .Case("power6x", true)
749 .Case("pwr6x", true)
750 .Case("power7", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000751 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +0000752 .Case("power8", true)
753 .Case("pwr8", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000754 .Case("powerpc", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000755 .Case("ppc", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000756 .Case("powerpc64", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000757 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +0000758 .Case("powerpc64le", true)
759 .Case("ppc64le", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000760 .Default(false);
761
762 if (CPUKnown)
763 CPU = Name;
764
765 return CPUKnown;
766 }
767
Ulrich Weigand8afad612014-07-28 13:17:52 +0000768
769 StringRef getABI() const override { return ABI; }
770
Craig Topper3164f332014-03-11 03:39:26 +0000771 void getTargetBuiltins(const Builtin::Info *&Records,
772 unsigned &NumRecords) const override {
Chris Lattner10a5b382007-01-29 05:24:35 +0000773 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000774 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000775 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000776
Craig Topper3164f332014-03-11 03:39:26 +0000777 bool isCLZForZeroUndef() const override { return false; }
Bob Wilson19a2f2b2012-01-28 18:02:29 +0000778
Craig Topper3164f332014-03-11 03:39:26 +0000779 void getTargetDefines(const LangOptions &Opts,
780 MacroBuilder &Builder) const override;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000781
Craig Topper3164f332014-03-11 03:39:26 +0000782 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
Bill Schmidt2fe4c672013-02-01 02:14:03 +0000783
Craig Topper3164f332014-03-11 03:39:26 +0000784 bool handleTargetFeatures(std::vector<std::string> &Features,
785 DiagnosticsEngine &Diags) override;
786 bool hasFeature(StringRef Feature) const override;
787
788 void getGCCRegNames(const char * const *&Names,
789 unsigned &NumNames) const override;
790 void getGCCRegAliases(const GCCRegAlias *&Aliases,
791 unsigned &NumAliases) const override;
792 bool validateAsmConstraint(const char *&Name,
793 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +0000794 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000795 default: return false;
796 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000797 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000798 case 'b': // Base register
799 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000800 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000801 break;
802 // FIXME: The following are added to allow parsing.
803 // I just took a guess at what the actions should be.
804 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000805 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000806 case 'v': // Altivec vector register
807 Info.setAllowsRegister();
808 break;
809 case 'w':
810 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000811 case 'd':// VSX vector register to hold vector double data
812 case 'f':// VSX vector register to hold vector float data
813 case 's':// VSX vector register to hold scalar float data
814 case 'a':// Any VSX register
Hal Finkelf7a07a52014-03-02 18:24:18 +0000815 case 'c':// An individual CR bit
John Thompson07a61a42010-06-24 22:44:13 +0000816 break;
817 default:
818 return false;
819 }
820 Info.setAllowsRegister();
821 Name++; // Skip over 'w'.
822 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000823 case 'h': // `MQ', `CTR', or `LINK' register
824 case 'q': // `MQ' register
825 case 'c': // `CTR' register
826 case 'l': // `LINK' register
827 case 'x': // `CR' register (condition register) number 0
828 case 'y': // `CR' register (condition register)
829 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000830 Info.setAllowsRegister();
831 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000832 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000833 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000834 // (use `L' instead for SImode constants)
835 case 'K': // Unsigned 16-bit constant
836 case 'L': // Signed 16-bit constant shifted left 16 bits
837 case 'M': // Constant larger than 31
838 case 'N': // Exact power of 2
839 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000840 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000841 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000842 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000843 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000844 break;
845 case 'm': // Memory operand. Note that on PowerPC targets, m can
846 // include addresses that update the base register. It
847 // is therefore only safe to use `m' in an asm statement
848 // if that asm statement accesses the operand exactly once.
849 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000850 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000851 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000852 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000853 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000854 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
855 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000856 // register to be updated.
857 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000858 if (Name[1] != 's')
859 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000860 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000861 // include any automodification of the base register. Unlike
862 // `m', this constraint can be used in asm statements that
863 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000864 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000865 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000866 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000867 break;
868 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000869 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000870 case 'Z': // Memory operand that is an indexed or indirect from a
871 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000872 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000873 Info.setAllowsMemory();
874 Info.setAllowsRegister();
875 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000876 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000877 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000878 // register (`p' is preferable for asm statements)
879 case 'S': // Constant suitable as a 64-bit mask operand
880 case 'T': // Constant suitable as a 32-bit mask operand
881 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000882 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000883 // instructions
884 case 'W': // Vector constant that does not require memory
885 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000886 break;
887 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000888 }
John Thompson07a61a42010-06-24 22:44:13 +0000889 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000890 }
Craig Topper3164f332014-03-11 03:39:26 +0000891 std::string convertConstraint(const char *&Constraint) const override {
Hal Finkelf7a07a52014-03-02 18:24:18 +0000892 std::string R;
893 switch (*Constraint) {
894 case 'e':
895 case 'w':
896 // Two-character constraint; add "^" hint for later parsing.
897 R = std::string("^") + std::string(Constraint, 2);
898 Constraint++;
899 break;
900 default:
901 return TargetInfo::convertConstraint(Constraint);
902 }
903 return R;
904 }
Craig Topper3164f332014-03-11 03:39:26 +0000905 const char *getClobbers() const override {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000906 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000907 }
Craig Topper3164f332014-03-11 03:39:26 +0000908 int getEHDataRegisterNumber(unsigned RegNo) const override {
Adhemerval Zanella5d874ae2013-01-22 20:02:45 +0000909 if (RegNo == 0) return 3;
910 if (RegNo == 1) return 4;
911 return -1;
912 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000913};
Anders Carlssonf511f642007-11-27 04:11:28 +0000914
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000915const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000916#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000917#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000918 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000919#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000920};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000921
Eric Christopher3ff21b32013-10-16 21:26:26 +0000922 /// handleTargetFeatures - Perform initialization based on the user
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000923/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +0000924bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000925 DiagnosticsEngine &Diags) {
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000926 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
927 // Ignore disabled features.
928 if (Features[i][0] == '-')
929 continue;
930
931 StringRef Feature = StringRef(Features[i]).substr(1);
932
933 if (Feature == "vsx") {
934 HasVSX = true;
935 continue;
936 }
937
Bill Schmidt59eb7672014-10-10 15:09:43 +0000938 if (Feature == "power8-vector") {
Bill Schmidt8c184e32014-10-10 17:21:23 +0000939 HasP8Vector = true;
Bill Schmidt59eb7672014-10-10 15:09:43 +0000940 continue;
941 }
942
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000943 // TODO: Finish this list and add an assert that we've handled them
944 // all.
945 }
946
947 return true;
948}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000949
Chris Lattnerecd49032009-03-02 22:27:17 +0000950/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
951/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +0000952void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000953 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +0000954 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000955 Builder.defineMacro("__ppc__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +0000956 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000957 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000958 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000959 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000960 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000961 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +0000962 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000963 Builder.defineMacro("__ppc64__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +0000964 Builder.defineMacro("__PPC64__");
Chris Lattnerecd49032009-03-02 22:27:17 +0000965 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000966
Chris Lattnerecd49032009-03-02 22:27:17 +0000967 // Target properties.
Bill Schmidt778d3872013-07-26 01:36:11 +0000968 if (getTriple().getArch() == llvm::Triple::ppc64le) {
969 Builder.defineMacro("_LITTLE_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +0000970 } else {
971 if (getTriple().getOS() != llvm::Triple::NetBSD &&
972 getTriple().getOS() != llvm::Triple::OpenBSD)
973 Builder.defineMacro("_BIG_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +0000974 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000975
Ulrich Weigand8afad612014-07-28 13:17:52 +0000976 // ABI options.
977 if (ABI == "elfv1")
978 Builder.defineMacro("_CALL_ELF", "1");
979 if (ABI == "elfv2")
980 Builder.defineMacro("_CALL_ELF", "2");
981
Chris Lattnerecd49032009-03-02 22:27:17 +0000982 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000983 Builder.defineMacro("__NATURAL_ALIGNMENT__");
984 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000985
Chris Lattnerecd49032009-03-02 22:27:17 +0000986 // FIXME: Should be controlled by command line option.
Roman Divacky13b586f2013-07-03 19:45:54 +0000987 if (LongDoubleWidth == 128)
988 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000989
John Thompsone467e192009-11-19 17:18:50 +0000990 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000991 Builder.defineMacro("__VEC__", "10206");
992 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +0000993 }
Hal Finkel8eb59282012-06-11 22:35:19 +0000994
995 // CPU identification.
Hal Finkel6b984f02012-07-03 16:51:04 +0000996 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
997 .Case("440", ArchDefineName)
998 .Case("450", ArchDefineName | ArchDefine440)
999 .Case("601", ArchDefineName)
1000 .Case("602", ArchDefineName | ArchDefinePpcgr)
1001 .Case("603", ArchDefineName | ArchDefinePpcgr)
1002 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1003 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1004 .Case("604", ArchDefineName | ArchDefinePpcgr)
1005 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1006 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt38378a02013-02-01 20:23:10 +00001007 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel6b984f02012-07-03 16:51:04 +00001008 .Case("7400", ArchDefineName | ArchDefinePpcgr)
1009 .Case("7450", ArchDefineName | ArchDefinePpcgr)
1010 .Case("750", ArchDefineName | ArchDefinePpcgr)
1011 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1012 | ArchDefinePpcsq)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001013 .Case("a2", ArchDefineA2)
1014 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt38378a02013-02-01 20:23:10 +00001015 .Case("pwr3", ArchDefinePpcgr)
1016 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1017 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1018 | ArchDefinePpcsq)
1019 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1020 | ArchDefinePpcgr | ArchDefinePpcsq)
1021 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1022 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1023 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1024 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1025 | ArchDefinePpcsq)
1026 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1027 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001028 | ArchDefinePpcgr | ArchDefinePpcsq)
1029 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1030 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1031 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Bill Schmidt38378a02013-02-01 20:23:10 +00001032 .Case("power3", ArchDefinePpcgr)
1033 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1034 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1035 | ArchDefinePpcsq)
1036 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1037 | ArchDefinePpcgr | ArchDefinePpcsq)
1038 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1039 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1040 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1041 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1042 | ArchDefinePpcsq)
1043 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1044 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001045 | ArchDefinePpcgr | ArchDefinePpcsq)
1046 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1047 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1048 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel6b984f02012-07-03 16:51:04 +00001049 .Default(ArchDefineNone);
1050
1051 if (defs & ArchDefineName)
1052 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1053 if (defs & ArchDefinePpcgr)
1054 Builder.defineMacro("_ARCH_PPCGR");
1055 if (defs & ArchDefinePpcsq)
1056 Builder.defineMacro("_ARCH_PPCSQ");
1057 if (defs & ArchDefine440)
Hal Finkel8eb59282012-06-11 22:35:19 +00001058 Builder.defineMacro("_ARCH_440");
Hal Finkel6b984f02012-07-03 16:51:04 +00001059 if (defs & ArchDefine603)
1060 Builder.defineMacro("_ARCH_603");
1061 if (defs & ArchDefine604)
1062 Builder.defineMacro("_ARCH_604");
Bill Schmidt38378a02013-02-01 20:23:10 +00001063 if (defs & ArchDefinePwr4)
Hal Finkel6b984f02012-07-03 16:51:04 +00001064 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt38378a02013-02-01 20:23:10 +00001065 if (defs & ArchDefinePwr5)
Hal Finkel6b984f02012-07-03 16:51:04 +00001066 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt38378a02013-02-01 20:23:10 +00001067 if (defs & ArchDefinePwr5x)
1068 Builder.defineMacro("_ARCH_PWR5X");
1069 if (defs & ArchDefinePwr6)
Hal Finkel8eb59282012-06-11 22:35:19 +00001070 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt38378a02013-02-01 20:23:10 +00001071 if (defs & ArchDefinePwr6x)
1072 Builder.defineMacro("_ARCH_PWR6X");
1073 if (defs & ArchDefinePwr7)
1074 Builder.defineMacro("_ARCH_PWR7");
Will Schmidtf0487512014-06-26 13:34:10 +00001075 if (defs & ArchDefinePwr8)
1076 Builder.defineMacro("_ARCH_PWR8");
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001077 if (defs & ArchDefineA2)
1078 Builder.defineMacro("_ARCH_A2");
1079 if (defs & ArchDefineA2q) {
1080 Builder.defineMacro("_ARCH_A2Q");
1081 Builder.defineMacro("_ARCH_QP");
1082 }
1083
1084 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1085 Builder.defineMacro("__bg__");
1086 Builder.defineMacro("__THW_BLUEGENE__");
1087 Builder.defineMacro("__bgq__");
1088 Builder.defineMacro("__TOS_BGQ__");
1089 }
Bill Schmidt38378a02013-02-01 20:23:10 +00001090
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001091 if (HasVSX)
1092 Builder.defineMacro("__VSX__");
Bill Schmidt8c184e32014-10-10 17:21:23 +00001093 if (HasP8Vector)
Bill Schmidt59eb7672014-10-10 15:09:43 +00001094 Builder.defineMacro("__POWER8_VECTOR__");
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001095
Bill Schmidt38378a02013-02-01 20:23:10 +00001096 // FIXME: The following are not yet generated here by Clang, but are
1097 // generated by GCC:
1098 //
1099 // _SOFT_FLOAT_
1100 // __RECIP_PRECISION__
1101 // __APPLE_ALTIVEC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001102 // __RECIP__
1103 // __RECIPF__
1104 // __RSQRTE__
1105 // __RSQRTEF__
1106 // _SOFT_DOUBLE_
1107 // __NO_LWSYNC__
1108 // __HAVE_BSWAP__
1109 // __LONGDOUBLE128
1110 // __CMODEL_MEDIUM__
1111 // __CMODEL_LARGE__
1112 // _CALL_SYSV
1113 // _CALL_DARWIN
1114 // __NO_FPRS__
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001115}
1116
1117void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1118 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1119 .Case("7400", true)
1120 .Case("g4", true)
1121 .Case("7450", true)
1122 .Case("g4+", true)
1123 .Case("970", true)
1124 .Case("g5", true)
1125 .Case("pwr6", true)
1126 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +00001127 .Case("pwr8", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001128 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +00001129 .Case("ppc64le", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001130 .Default(false);
Hal Finkelb58ce852013-02-01 18:44:19 +00001131
1132 Features["qpx"] = (CPU == "a2q");
Ulrich Weigand8afad612014-07-28 13:17:52 +00001133
1134 if (!ABI.empty())
1135 Features[ABI] = true;
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001136}
1137
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001138bool PPCTargetInfo::hasFeature(StringRef Feature) const {
1139 return Feature == "powerpc";
1140}
Chris Lattner17df24e2008-04-21 18:56:49 +00001141
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001142
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001143const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001144 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1145 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1146 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1147 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1148 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1149 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1150 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1151 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001152 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001153 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001154 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001155 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1156 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1157 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1158 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001159 "vrsave", "vscr",
1160 "spe_acc", "spefscr",
1161 "sfp"
1162};
Chris Lattner10a5b382007-01-29 05:24:35 +00001163
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001164void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001165 unsigned &NumNames) const {
1166 Names = GCCRegNames;
1167 NumNames = llvm::array_lengthof(GCCRegNames);
1168}
Chris Lattner5ba61f02006-10-14 07:39:34 +00001169
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001170const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1171 // While some of these aliases do map to different registers
1172 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001173 { { "0" }, "r0" },
1174 { { "1"}, "r1" },
1175 { { "2" }, "r2" },
1176 { { "3" }, "r3" },
1177 { { "4" }, "r4" },
1178 { { "5" }, "r5" },
1179 { { "6" }, "r6" },
1180 { { "7" }, "r7" },
1181 { { "8" }, "r8" },
1182 { { "9" }, "r9" },
1183 { { "10" }, "r10" },
1184 { { "11" }, "r11" },
1185 { { "12" }, "r12" },
1186 { { "13" }, "r13" },
1187 { { "14" }, "r14" },
1188 { { "15" }, "r15" },
1189 { { "16" }, "r16" },
1190 { { "17" }, "r17" },
1191 { { "18" }, "r18" },
1192 { { "19" }, "r19" },
1193 { { "20" }, "r20" },
1194 { { "21" }, "r21" },
1195 { { "22" }, "r22" },
1196 { { "23" }, "r23" },
1197 { { "24" }, "r24" },
1198 { { "25" }, "r25" },
1199 { { "26" }, "r26" },
1200 { { "27" }, "r27" },
1201 { { "28" }, "r28" },
1202 { { "29" }, "r29" },
1203 { { "30" }, "r30" },
1204 { { "31" }, "r31" },
1205 { { "fr0" }, "f0" },
1206 { { "fr1" }, "f1" },
1207 { { "fr2" }, "f2" },
1208 { { "fr3" }, "f3" },
1209 { { "fr4" }, "f4" },
1210 { { "fr5" }, "f5" },
1211 { { "fr6" }, "f6" },
1212 { { "fr7" }, "f7" },
1213 { { "fr8" }, "f8" },
1214 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +00001215 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001216 { { "fr11" }, "f11" },
1217 { { "fr12" }, "f12" },
1218 { { "fr13" }, "f13" },
1219 { { "fr14" }, "f14" },
1220 { { "fr15" }, "f15" },
1221 { { "fr16" }, "f16" },
1222 { { "fr17" }, "f17" },
1223 { { "fr18" }, "f18" },
1224 { { "fr19" }, "f19" },
1225 { { "fr20" }, "f20" },
1226 { { "fr21" }, "f21" },
1227 { { "fr22" }, "f22" },
1228 { { "fr23" }, "f23" },
1229 { { "fr24" }, "f24" },
1230 { { "fr25" }, "f25" },
1231 { { "fr26" }, "f26" },
1232 { { "fr27" }, "f27" },
1233 { { "fr28" }, "f28" },
1234 { { "fr29" }, "f29" },
1235 { { "fr30" }, "f30" },
1236 { { "fr31" }, "f31" },
1237 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001238};
1239
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001240void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001241 unsigned &NumAliases) const {
1242 Aliases = GCCRegAliases;
1243 NumAliases = llvm::array_lengthof(GCCRegAliases);
1244}
1245} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +00001246
Chris Lattner5ba61f02006-10-14 07:39:34 +00001247namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001248class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001249public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001250 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00001251 DescriptionString = "E-m:e-p:32:32-i64:64-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001252
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001253 switch (getTriple().getOS()) {
Nico Weber3435ede2012-01-31 02:07:33 +00001254 case llvm::Triple::Linux:
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001255 case llvm::Triple::FreeBSD:
1256 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001257 SizeType = UnsignedInt;
Hal Finkel26908382012-03-02 20:54:36 +00001258 PtrDiffType = SignedInt;
1259 IntPtrType = SignedInt;
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001260 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +00001261 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001262 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001263 }
Roman Divacky816dcd12012-03-13 16:53:54 +00001264
Roman Divacky3ffe7462012-03-13 19:20:17 +00001265 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1266 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001267 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divacky3ffe7462012-03-13 19:20:17 +00001268 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001269
1270 // PPC32 supports atomics up to 4 bytes.
1271 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divacky965b0b72011-01-06 08:27:10 +00001272 }
1273
Craig Topper3164f332014-03-11 03:39:26 +00001274 BuiltinVaListKind getBuiltinVaListKind() const override {
Roman Divacky965b0b72011-01-06 08:27:10 +00001275 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Inge5d3fb222012-06-16 03:34:49 +00001276 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedman873f65a2008-08-21 00:13:15 +00001277 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001278};
1279} // end anonymous namespace.
1280
Bill Schmidt778d3872013-07-26 01:36:11 +00001281// Note: ABI differences may eventually require us to have a separate
1282// TargetInfo for little endian.
Chris Lattner5ba61f02006-10-14 07:39:34 +00001283namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001284class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001285public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001286 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001287 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001288 IntMaxType = SignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001289 Int64Type = SignedLong;
Roman Divacky816dcd12012-03-13 16:53:54 +00001290
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001291 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1292 DescriptionString = "e-m:e-i64:64-n32:64";
1293 ABI = "elfv2";
1294 } else {
1295 DescriptionString = "E-m:e-i64:64-n32:64";
1296 ABI = "elfv1";
1297 }
1298
1299 switch (getTriple().getOS()) {
1300 case llvm::Triple::FreeBSD:
Roman Divacky3ffe7462012-03-13 19:20:17 +00001301 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001302 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001303 break;
Joerg Sonnenbergeraac82c42014-10-15 19:52:03 +00001304 case llvm::Triple::NetBSD:
1305 IntMaxType = SignedLongLong;
1306 Int64Type = SignedLongLong;
1307 break;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001308 default:
1309 break;
Ulrich Weigand8afad612014-07-28 13:17:52 +00001310 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001311
1312 // PPC64 supports atomics up to 8 bytes.
1313 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001314 }
Craig Topper3164f332014-03-11 03:39:26 +00001315 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001316 return TargetInfo::CharPtrBuiltinVaList;
Roman Divacky965b0b72011-01-06 08:27:10 +00001317 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001318 // PPC64 Linux-specifc ABI options.
1319 bool setABI(const std::string &Name) override {
1320 if (Name == "elfv1" || Name == "elfv2") {
1321 ABI = Name;
1322 return true;
1323 }
1324 return false;
1325 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001326};
1327} // end anonymous namespace.
1328
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001329
1330namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +00001331class DarwinPPC32TargetInfo :
1332 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001333public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001334 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1335 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001336 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +00001337 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopherc04fe092013-10-16 21:19:19 +00001338 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev68d773c2012-01-17 22:40:00 +00001339 LongLongAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001340 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001341 DescriptionString = "E-m:o-p:32:32-f64:32:64-n32";
Roman Divacky965b0b72011-01-06 08:27:10 +00001342 }
Craig Topper3164f332014-03-11 03:39:26 +00001343 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001344 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001345 }
1346};
1347
1348class DarwinPPC64TargetInfo :
1349 public DarwinTargetInfo<PPC64TargetInfo> {
1350public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001351 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1352 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001353 HasAlignMac68kSupport = true;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001354 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001355 DescriptionString = "E-m:o-i64:64-n32:64";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001356 }
1357};
1358} // end anonymous namespace.
1359
Chris Lattner5ba61f02006-10-14 07:39:34 +00001360namespace {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001361 static const unsigned NVPTXAddrSpaceMap[] = {
1362 1, // opencl_global
1363 3, // opencl_local
1364 4, // opencl_constant
1365 1, // cuda_device
1366 4, // cuda_constant
1367 3, // cuda_shared
1368 };
1369 class NVPTXTargetInfo : public TargetInfo {
1370 static const char * const GCCRegNames[];
Justin Holewinski83e96682012-05-24 17:43:12 +00001371 static const Builtin::Info BuiltinInfo[];
Peter Collingbournec947aae2012-05-20 23:28:41 +00001372 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001373 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001374 BigEndian = false;
1375 TLSSupported = false;
1376 LongWidth = LongAlign = 64;
1377 AddrSpaceMap = &NVPTXAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001378 UseAddrSpaceMapMangling = true;
Justin Holewinski83e96682012-05-24 17:43:12 +00001379 // Define available target features
1380 // These must be defined in sorted order!
Justin Holewinski5fafdd92012-07-11 15:34:55 +00001381 NoAsmVariants = true;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001382 }
Craig Topper3164f332014-03-11 03:39:26 +00001383 void getTargetDefines(const LangOptions &Opts,
1384 MacroBuilder &Builder) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001385 Builder.defineMacro("__PTX__");
Justin Holewinski83e96682012-05-24 17:43:12 +00001386 Builder.defineMacro("__NVPTX__");
Peter Collingbournec947aae2012-05-20 23:28:41 +00001387 }
Craig Topper3164f332014-03-11 03:39:26 +00001388 void getTargetBuiltins(const Builtin::Info *&Records,
1389 unsigned &NumRecords) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001390 Records = BuiltinInfo;
1391 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001392 }
Craig Topper3164f332014-03-11 03:39:26 +00001393 bool hasFeature(StringRef Feature) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001394 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbournec947aae2012-05-20 23:28:41 +00001395 }
Craig Topper3164f332014-03-11 03:39:26 +00001396
1397 void getGCCRegNames(const char * const *&Names,
1398 unsigned &NumNames) const override;
1399 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1400 unsigned &NumAliases) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001401 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00001402 Aliases = nullptr;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001403 NumAliases = 0;
1404 }
Craig Topper3164f332014-03-11 03:39:26 +00001405 bool validateAsmConstraint(const char *&Name,
1406 TargetInfo::ConstraintInfo &Info) const override {
Justin Holewinski7ceab3a892013-06-21 18:51:24 +00001407 switch (*Name) {
1408 default: return false;
1409 case 'c':
1410 case 'h':
1411 case 'r':
1412 case 'l':
1413 case 'f':
1414 case 'd':
1415 Info.setAllowsRegister();
1416 return true;
1417 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001418 }
Craig Topper3164f332014-03-11 03:39:26 +00001419 const char *getClobbers() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001420 // FIXME: Is this really right?
1421 return "";
1422 }
Craig Topper3164f332014-03-11 03:39:26 +00001423 BuiltinVaListKind getBuiltinVaListKind() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001424 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00001425 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001426 }
Craig Topper3164f332014-03-11 03:39:26 +00001427 bool setCPU(const std::string &Name) override {
Justin Holewinski91203e82013-03-30 14:38:26 +00001428 bool Valid = llvm::StringSwitch<bool>(Name)
1429 .Case("sm_20", true)
1430 .Case("sm_21", true)
1431 .Case("sm_30", true)
1432 .Case("sm_35", true)
1433 .Default(false);
1434
1435 return Valid;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001436 }
Justin Holewinski83e96682012-05-24 17:43:12 +00001437 };
1438
1439 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1440#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1441#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1442 ALL_LANGUAGES },
1443#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbournec947aae2012-05-20 23:28:41 +00001444 };
1445
1446 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1447 "r0"
1448 };
1449
1450 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1451 unsigned &NumNames) const {
1452 Names = GCCRegNames;
1453 NumNames = llvm::array_lengthof(GCCRegNames);
1454 }
1455
1456 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1457 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001458 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001459 PointerWidth = PointerAlign = 32;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001460 SizeType = PtrDiffType = TargetInfo::UnsignedInt;
1461 IntPtrType = TargetInfo::SignedInt;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001462 DescriptionString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001463 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001464 };
1465
1466 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1467 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001468 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001469 PointerWidth = PointerAlign = 64;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001470 SizeType = PtrDiffType = TargetInfo::UnsignedLongLong;
1471 IntPtrType = TargetInfo::SignedLongLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001472 DescriptionString = "e-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001473 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001474 };
1475}
1476
1477namespace {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001478
1479static const unsigned R600AddrSpaceMap[] = {
1480 1, // opencl_global
1481 3, // opencl_local
1482 2, // opencl_constant
1483 1, // cuda_device
1484 2, // cuda_constant
1485 3 // cuda_shared
1486};
1487
Tom Stellarda96344b2014-08-21 13:58:40 +00001488// If you edit the description strings, make sure you update
1489// getPointerWidthV().
1490
Tom Stellardc74b1e02013-03-04 17:40:53 +00001491static const char *DescriptionStringR600 =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001492 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1493 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001494
1495static const char *DescriptionStringR600DoubleOps =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001496 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1497 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001498
1499static const char *DescriptionStringSI =
Matt Arsenault23e7b082014-05-22 18:33:55 +00001500 "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32-p24:64:64"
Rafael Espindola29db13a2014-01-03 18:13:17 +00001501 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1502 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001503
Eli Friedmand13b41e2012-10-12 23:32:00 +00001504class R600TargetInfo : public TargetInfo {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001505 static const Builtin::Info BuiltinInfo[];
1506
Tom Stellardc74b1e02013-03-04 17:40:53 +00001507 /// \brief The GPU profiles supported by the R600 target.
1508 enum GPUKind {
1509 GK_NONE,
1510 GK_R600,
1511 GK_R600_DOUBLE_OPS,
1512 GK_R700,
1513 GK_R700_DOUBLE_OPS,
1514 GK_EVERGREEN,
1515 GK_EVERGREEN_DOUBLE_OPS,
1516 GK_NORTHERN_ISLANDS,
1517 GK_CAYMAN,
Tom Stellard08ded122013-10-29 16:38:29 +00001518 GK_SOUTHERN_ISLANDS,
1519 GK_SEA_ISLANDS
Tom Stellardc74b1e02013-03-04 17:40:53 +00001520 } GPU;
1521
Eli Friedmand13b41e2012-10-12 23:32:00 +00001522public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001523 R600TargetInfo(const llvm::Triple &Triple)
1524 : TargetInfo(Triple), GPU(GK_R600) {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001525 DescriptionString = DescriptionStringR600;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001526 AddrSpaceMap = &R600AddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001527 UseAddrSpaceMapMangling = true;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001528 }
1529
Tom Stellarda96344b2014-08-21 13:58:40 +00001530 uint64_t getPointerWidthV(unsigned AddrSpace) const override {
1531 if (GPU <= GK_CAYMAN)
1532 return 32;
1533
1534 switch(AddrSpace) {
1535 default:
1536 return 64;
1537 case 0:
1538 case 3:
1539 case 5:
1540 return 32;
1541 }
1542 }
1543
Craig Topper3164f332014-03-11 03:39:26 +00001544 const char * getClobbers() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001545 return "";
1546 }
1547
Craig Topper3164f332014-03-11 03:39:26 +00001548 void getGCCRegNames(const char * const *&Names,
1549 unsigned &numNames) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001550 Names = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001551 numNames = 0;
1552 }
1553
Craig Topper3164f332014-03-11 03:39:26 +00001554 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1555 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001556 Aliases = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001557 NumAliases = 0;
1558 }
1559
Craig Topper3164f332014-03-11 03:39:26 +00001560 bool validateAsmConstraint(const char *&Name,
1561 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001562 return true;
1563 }
1564
Craig Topper3164f332014-03-11 03:39:26 +00001565 void getTargetBuiltins(const Builtin::Info *&Records,
1566 unsigned &NumRecords) const override {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001567 Records = BuiltinInfo;
1568 NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001569 }
1570
Craig Topper3164f332014-03-11 03:39:26 +00001571 void getTargetDefines(const LangOptions &Opts,
1572 MacroBuilder &Builder) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001573 Builder.defineMacro("__R600__");
1574 }
1575
Craig Topper3164f332014-03-11 03:39:26 +00001576 BuiltinVaListKind getBuiltinVaListKind() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001577 return TargetInfo::CharPtrBuiltinVaList;
1578 }
1579
Craig Topper3164f332014-03-11 03:39:26 +00001580 bool setCPU(const std::string &Name) override {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001581 GPU = llvm::StringSwitch<GPUKind>(Name)
1582 .Case("r600" , GK_R600)
1583 .Case("rv610", GK_R600)
1584 .Case("rv620", GK_R600)
1585 .Case("rv630", GK_R600)
1586 .Case("rv635", GK_R600)
1587 .Case("rs780", GK_R600)
1588 .Case("rs880", GK_R600)
1589 .Case("rv670", GK_R600_DOUBLE_OPS)
1590 .Case("rv710", GK_R700)
1591 .Case("rv730", GK_R700)
1592 .Case("rv740", GK_R700_DOUBLE_OPS)
1593 .Case("rv770", GK_R700_DOUBLE_OPS)
1594 .Case("palm", GK_EVERGREEN)
1595 .Case("cedar", GK_EVERGREEN)
1596 .Case("sumo", GK_EVERGREEN)
1597 .Case("sumo2", GK_EVERGREEN)
1598 .Case("redwood", GK_EVERGREEN)
1599 .Case("juniper", GK_EVERGREEN)
1600 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1601 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1602 .Case("barts", GK_NORTHERN_ISLANDS)
1603 .Case("turks", GK_NORTHERN_ISLANDS)
1604 .Case("caicos", GK_NORTHERN_ISLANDS)
1605 .Case("cayman", GK_CAYMAN)
1606 .Case("aruba", GK_CAYMAN)
Tom Stellard785699322013-04-01 20:56:49 +00001607 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001608 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1609 .Case("verde", GK_SOUTHERN_ISLANDS)
1610 .Case("oland", GK_SOUTHERN_ISLANDS)
Tom Stellard9affba42014-08-21 13:58:38 +00001611 .Case("hainan", GK_SOUTHERN_ISLANDS)
Tom Stellard08ded122013-10-29 16:38:29 +00001612 .Case("bonaire", GK_SEA_ISLANDS)
1613 .Case("kabini", GK_SEA_ISLANDS)
1614 .Case("kaveri", GK_SEA_ISLANDS)
Tom Stellard55583042013-11-14 23:45:53 +00001615 .Case("hawaii", GK_SEA_ISLANDS)
Tom Stellard14e03962014-07-26 01:05:20 +00001616 .Case("mullins", GK_SEA_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001617 .Default(GK_NONE);
1618
1619 if (GPU == GK_NONE) {
1620 return false;
1621 }
1622
1623 // Set the correct data layout
1624 switch (GPU) {
1625 case GK_NONE:
1626 case GK_R600:
1627 case GK_R700:
1628 case GK_EVERGREEN:
1629 case GK_NORTHERN_ISLANDS:
1630 DescriptionString = DescriptionStringR600;
1631 break;
1632 case GK_R600_DOUBLE_OPS:
1633 case GK_R700_DOUBLE_OPS:
1634 case GK_EVERGREEN_DOUBLE_OPS:
1635 case GK_CAYMAN:
1636 DescriptionString = DescriptionStringR600DoubleOps;
1637 break;
1638 case GK_SOUTHERN_ISLANDS:
Tom Stellard08ded122013-10-29 16:38:29 +00001639 case GK_SEA_ISLANDS:
Tom Stellardc74b1e02013-03-04 17:40:53 +00001640 DescriptionString = DescriptionStringSI;
1641 break;
1642 }
1643
1644 return true;
1645 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001646};
1647
Matt Arsenault56f008d2014-06-24 20:45:01 +00001648const Builtin::Info R600TargetInfo::BuiltinInfo[] = {
1649#define BUILTIN(ID, TYPE, ATTRS) \
1650 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1651#include "clang/Basic/BuiltinsR600.def"
1652};
1653
Eli Friedmand13b41e2012-10-12 23:32:00 +00001654} // end anonymous namespace
1655
1656namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001657// Namespace for x86 abstract base class
1658const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001659#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001660#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001661 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001662#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001663};
Eli Friedmanb5366062008-05-20 14:21:01 +00001664
Nuno Lopescfca1f02009-12-23 17:49:57 +00001665static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001666 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1667 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001668 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001669 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1670 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1671 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001672 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00001673 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1674 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001675};
1676
Eric Christophercdd36352011-06-21 00:05:20 +00001677const TargetInfo::AddlRegName AddlRegNames[] = {
1678 { { "al", "ah", "eax", "rax" }, 0 },
1679 { { "bl", "bh", "ebx", "rbx" }, 3 },
1680 { { "cl", "ch", "ecx", "rcx" }, 2 },
1681 { { "dl", "dh", "edx", "rdx" }, 1 },
1682 { { "esi", "rsi" }, 4 },
1683 { { "edi", "rdi" }, 5 },
1684 { { "esp", "rsp" }, 7 },
1685 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001686};
1687
1688// X86 target abstract base class; x86-32 and x86-64 are very close, so
1689// most of the implementation can be shared.
1690class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001691 enum X86SSEEnum {
Craig Topper9c4d17f2013-08-21 03:59:22 +00001692 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Chris Lattner96e43572009-03-02 22:40:39 +00001693 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001694 enum MMX3DNowEnum {
1695 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1696 } MMX3DNowLevel;
Rafael Espindolae62e2792013-08-20 13:44:29 +00001697 enum XOPEnum {
1698 NoXOP,
1699 SSE4A,
1700 FMA4,
1701 XOP
1702 } XOPLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001703
Eric Christophere1ddaf92010-04-02 23:50:19 +00001704 bool HasAES;
Craig Topper3f122a72012-05-31 05:18:48 +00001705 bool HasPCLMUL;
Craig Topper22967d42011-12-25 05:06:45 +00001706 bool HasLZCNT;
Benjamin Kramer1e250392012-07-07 09:39:18 +00001707 bool HasRDRND;
Craig Topper22967d42011-12-25 05:06:45 +00001708 bool HasBMI;
1709 bool HasBMI2;
Craig Topper1de83482011-12-29 16:10:46 +00001710 bool HasPOPCNT;
Michael Liao625a8752012-11-10 05:17:46 +00001711 bool HasRTM;
Michael Liao74f4eaf2013-03-26 17:52:08 +00001712 bool HasPRFCHW;
Michael Liaoffaae352013-03-29 05:17:55 +00001713 bool HasRDSEED;
Robert Khasanov50e6f582014-09-19 09:53:48 +00001714 bool HasADX;
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00001715 bool HasTBM;
Craig Topperbba778b2012-06-03 21:46:30 +00001716 bool HasFMA;
Manman Rena45358c2012-10-11 00:59:55 +00001717 bool HasF16C;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001718 bool HasAVX512CD, HasAVX512ER, HasAVX512PF, HasAVX512DQ, HasAVX512BW, HasAVX512VL;
Ben Langmuir58078d02013-09-19 13:22:04 +00001719 bool HasSHA;
Nick Lewycky50e8f482013-10-05 20:14:27 +00001720 bool HasCX16;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001721
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001722 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1723 ///
1724 /// Each enumeration represents a particular CPU supported by Clang. These
1725 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1726 enum CPUKind {
1727 CK_Generic,
1728
1729 /// \name i386
1730 /// i386-generation processors.
1731 //@{
1732 CK_i386,
1733 //@}
1734
1735 /// \name i486
1736 /// i486-generation processors.
1737 //@{
1738 CK_i486,
1739 CK_WinChipC6,
1740 CK_WinChip2,
1741 CK_C3,
1742 //@}
1743
1744 /// \name i586
1745 /// i586-generation processors, P5 microarchitecture based.
1746 //@{
1747 CK_i586,
1748 CK_Pentium,
1749 CK_PentiumMMX,
1750 //@}
1751
1752 /// \name i686
1753 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1754 //@{
1755 CK_i686,
1756 CK_PentiumPro,
1757 CK_Pentium2,
1758 CK_Pentium3,
1759 CK_Pentium3M,
1760 CK_PentiumM,
1761 CK_C3_2,
1762
1763 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1764 /// Clang however has some logic to suport this.
1765 // FIXME: Warn, deprecate, and potentially remove this.
1766 CK_Yonah,
1767 //@}
1768
1769 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00001770 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001771 //@{
1772 CK_Pentium4,
1773 CK_Pentium4M,
1774 CK_Prescott,
1775 CK_Nocona,
1776 //@}
1777
1778 /// \name Core
1779 /// Core microarchitecture based processors.
1780 //@{
1781 CK_Core2,
1782
1783 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1784 /// codename which GCC no longer accepts as an option to -march, but Clang
1785 /// has some logic for recognizing it.
1786 // FIXME: Warn, deprecate, and potentially remove this.
1787 CK_Penryn,
1788 //@}
1789
1790 /// \name Atom
1791 /// Atom processors
1792 //@{
1793 CK_Atom,
Preston Gurda3c58c02013-09-13 19:27:17 +00001794 CK_Silvermont,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001795 //@}
1796
1797 /// \name Nehalem
1798 /// Nehalem microarchitecture based processors.
1799 //@{
1800 CK_Corei7,
1801 CK_Corei7AVX,
Chandler Carruth212334f2011-09-28 08:55:37 +00001802 CK_CoreAVXi,
Craig Topper865fff52011-12-17 19:55:21 +00001803 CK_CoreAVX2,
Robert Khasanov50e6f582014-09-19 09:53:48 +00001804 CK_Broadwell,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001805 //@}
1806
Craig Topper449314e2013-08-20 07:09:39 +00001807 /// \name Knights Landing
1808 /// Knights Landing processor.
1809 CK_KNL,
1810
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001811 /// \name Skylake Server
1812 /// Skylake server processor.
1813 CK_SKX,
1814
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001815 /// \name K6
1816 /// K6 architecture processors.
1817 //@{
1818 CK_K6,
1819 CK_K6_2,
1820 CK_K6_3,
1821 //@}
1822
1823 /// \name K7
1824 /// K7 architecture processors.
1825 //@{
1826 CK_Athlon,
1827 CK_AthlonThunderbird,
1828 CK_Athlon4,
1829 CK_AthlonXP,
1830 CK_AthlonMP,
1831 //@}
1832
1833 /// \name K8
1834 /// K8 architecture processors.
1835 //@{
1836 CK_Athlon64,
1837 CK_Athlon64SSE3,
1838 CK_AthlonFX,
1839 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00001840 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001841 CK_Opteron,
1842 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00001843 CK_AMDFAM10,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001844 //@}
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001845
Benjamin Kramer569f2152012-01-10 11:50:18 +00001846 /// \name Bobcat
1847 /// Bobcat architecture processors.
1848 //@{
1849 CK_BTVER1,
Benjamin Kramer914d7e02013-05-03 10:47:15 +00001850 CK_BTVER2,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001851 //@}
1852
1853 /// \name Bulldozer
1854 /// Bulldozer architecture processors.
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001855 //@{
1856 CK_BDVER1,
1857 CK_BDVER2,
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00001858 CK_BDVER3,
Benjamin Kramer56c58222014-05-02 15:47:51 +00001859 CK_BDVER4,
Benjamin Kramer569f2152012-01-10 11:50:18 +00001860 //@}
Benjamin Kramer6bd51592011-12-01 18:23:59 +00001861
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001862 /// This specification is deprecated and will be removed in the future.
1863 /// Users should prefer \see CK_K8.
1864 // FIXME: Warn on this when the CPU is set to it.
1865 CK_x86_64,
1866 //@}
1867
1868 /// \name Geode
1869 /// Geode processors.
1870 //@{
1871 CK_Geode
1872 //@}
Chandler Carruth212334f2011-09-28 08:55:37 +00001873 } CPU;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001874
Rafael Espindolaeb265472013-08-21 21:59:03 +00001875 enum FPMathKind {
1876 FP_Default,
1877 FP_SSE,
1878 FP_387
1879 } FPMath;
1880
Eli Friedman3fd920a2008-08-20 02:34:37 +00001881public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001882 X86TargetInfo(const llvm::Triple &Triple)
1883 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Rafael Espindolae62e2792013-08-20 13:44:29 +00001884 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
1885 HasRDRND(false), HasBMI(false), HasBMI2(false), HasPOPCNT(false),
Robert Khasanov50e6f582014-09-19 09:53:48 +00001886 HasRTM(false), HasPRFCHW(false), HasRDSEED(false), HasADX(false),
1887 HasTBM(false), HasFMA(false), HasF16C(false), HasAVX512CD(false),
1888 HasAVX512ER(false), HasAVX512PF(false), HasAVX512DQ(false),
1889 HasAVX512BW(false), HasAVX512VL(false), HasSHA(false), HasCX16(false),
1890 CPU(CK_Generic), FPMath(FP_Default) {
Eli Friedman803acb32011-12-22 03:51:45 +00001891 BigEndian = false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00001892 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00001893 }
Craig Topper3164f332014-03-11 03:39:26 +00001894 unsigned getFloatEvalMethod() const override {
Benjamin Kramercf501472011-12-28 15:47:06 +00001895 // X87 evaluates with 80 bits "long double" precision.
1896 return SSELevel == NoSSE ? 2 : 0;
1897 }
Craig Topper3164f332014-03-11 03:39:26 +00001898 void getTargetBuiltins(const Builtin::Info *&Records,
1899 unsigned &NumRecords) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001900 Records = BuiltinInfo;
1901 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00001902 }
Craig Topper3164f332014-03-11 03:39:26 +00001903 void getGCCRegNames(const char * const *&Names,
1904 unsigned &NumNames) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001905 Names = GCCRegNames;
1906 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00001907 }
Craig Topper3164f332014-03-11 03:39:26 +00001908 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1909 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001910 Aliases = nullptr;
Eric Christophercdd36352011-06-21 00:05:20 +00001911 NumAliases = 0;
1912 }
Craig Topper3164f332014-03-11 03:39:26 +00001913 void getGCCAddlRegNames(const AddlRegName *&Names,
1914 unsigned &NumNames) const override {
Eric Christophercdd36352011-06-21 00:05:20 +00001915 Names = AddlRegNames;
1916 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00001917 }
Craig Topper3164f332014-03-11 03:39:26 +00001918 bool validateAsmConstraint(const char *&Name,
1919 TargetInfo::ConstraintInfo &info) const override;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00001920
Akira Hatanaka974131e2014-09-18 18:17:18 +00001921 bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
1922
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00001923 bool validateInputSize(StringRef Constraint, unsigned Size) const override;
1924
Akira Hatanaka974131e2014-09-18 18:17:18 +00001925 virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
1926
Craig Topper3164f332014-03-11 03:39:26 +00001927 std::string convertConstraint(const char *&Constraint) const override;
1928 const char *getClobbers() const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001929 return "~{dirflag},~{fpsr},~{flags}";
1930 }
Craig Topper3164f332014-03-11 03:39:26 +00001931 void getTargetDefines(const LangOptions &Opts,
1932 MacroBuilder &Builder) const override;
Craig Topper13f61a62013-09-17 04:12:55 +00001933 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
1934 bool Enabled);
1935 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
1936 bool Enabled);
1937 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
1938 bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00001939 void setFeatureEnabled(llvm::StringMap<bool> &Features,
1940 StringRef Name, bool Enabled) const override {
Craig Topper86d79ef2013-09-17 04:51:29 +00001941 setFeatureEnabledImpl(Features, Name, Enabled);
1942 }
1943 // This exists purely to cut down on the number of virtual calls in
1944 // getDefaultFeatures which calls this repeatedly.
1945 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
1946 StringRef Name, bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00001947 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
1948 bool hasFeature(StringRef Feature) const override;
1949 bool handleTargetFeatures(std::vector<std::string> &Features,
1950 DiagnosticsEngine &Diags) override;
Alp Toker4925ba72014-06-07 23:30:42 +00001951 StringRef getABI() const override {
Derek Schuffc7dd7222012-10-11 15:52:22 +00001952 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00001953 return "avx";
Derek Schuffc7dd7222012-10-11 15:52:22 +00001954 else if (getTriple().getArch() == llvm::Triple::x86 &&
1955 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00001956 return "no-mmx";
1957 return "";
Eli Friedman33465822011-07-08 23:31:17 +00001958 }
Craig Topper3164f332014-03-11 03:39:26 +00001959 bool setCPU(const std::string &Name) override {
Chandler Carruth212334f2011-09-28 08:55:37 +00001960 CPU = llvm::StringSwitch<CPUKind>(Name)
1961 .Case("i386", CK_i386)
1962 .Case("i486", CK_i486)
1963 .Case("winchip-c6", CK_WinChipC6)
1964 .Case("winchip2", CK_WinChip2)
1965 .Case("c3", CK_C3)
1966 .Case("i586", CK_i586)
1967 .Case("pentium", CK_Pentium)
1968 .Case("pentium-mmx", CK_PentiumMMX)
1969 .Case("i686", CK_i686)
1970 .Case("pentiumpro", CK_PentiumPro)
1971 .Case("pentium2", CK_Pentium2)
1972 .Case("pentium3", CK_Pentium3)
1973 .Case("pentium3m", CK_Pentium3M)
1974 .Case("pentium-m", CK_PentiumM)
1975 .Case("c3-2", CK_C3_2)
1976 .Case("yonah", CK_Yonah)
1977 .Case("pentium4", CK_Pentium4)
1978 .Case("pentium4m", CK_Pentium4M)
1979 .Case("prescott", CK_Prescott)
1980 .Case("nocona", CK_Nocona)
1981 .Case("core2", CK_Core2)
1982 .Case("penryn", CK_Penryn)
1983 .Case("atom", CK_Atom)
Preston Gurda3c58c02013-09-13 19:27:17 +00001984 .Case("slm", CK_Silvermont)
Chandler Carruth212334f2011-09-28 08:55:37 +00001985 .Case("corei7", CK_Corei7)
1986 .Case("corei7-avx", CK_Corei7AVX)
1987 .Case("core-avx-i", CK_CoreAVXi)
Craig Topper865fff52011-12-17 19:55:21 +00001988 .Case("core-avx2", CK_CoreAVX2)
Robert Khasanov50e6f582014-09-19 09:53:48 +00001989 .Case("broadwell", CK_Broadwell)
Craig Topper449314e2013-08-20 07:09:39 +00001990 .Case("knl", CK_KNL)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00001991 .Case("skx", CK_SKX)
Chandler Carruth212334f2011-09-28 08:55:37 +00001992 .Case("k6", CK_K6)
1993 .Case("k6-2", CK_K6_2)
1994 .Case("k6-3", CK_K6_3)
1995 .Case("athlon", CK_Athlon)
1996 .Case("athlon-tbird", CK_AthlonThunderbird)
1997 .Case("athlon-4", CK_Athlon4)
1998 .Case("athlon-xp", CK_AthlonXP)
1999 .Case("athlon-mp", CK_AthlonMP)
2000 .Case("athlon64", CK_Athlon64)
2001 .Case("athlon64-sse3", CK_Athlon64SSE3)
2002 .Case("athlon-fx", CK_AthlonFX)
2003 .Case("k8", CK_K8)
2004 .Case("k8-sse3", CK_K8SSE3)
2005 .Case("opteron", CK_Opteron)
2006 .Case("opteron-sse3", CK_OpteronSSE3)
Roman Divacky43eb6f82011-10-30 07:48:46 +00002007 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer569f2152012-01-10 11:50:18 +00002008 .Case("btver1", CK_BTVER1)
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002009 .Case("btver2", CK_BTVER2)
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002010 .Case("bdver1", CK_BDVER1)
2011 .Case("bdver2", CK_BDVER2)
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002012 .Case("bdver3", CK_BDVER3)
Benjamin Kramer56c58222014-05-02 15:47:51 +00002013 .Case("bdver4", CK_BDVER4)
Chandler Carruth212334f2011-09-28 08:55:37 +00002014 .Case("x86-64", CK_x86_64)
2015 .Case("geode", CK_Geode)
2016 .Default(CK_Generic);
2017
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002018 // Perform any per-CPU checks necessary to determine if this CPU is
2019 // acceptable.
2020 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
2021 // invalid without explaining *why*.
2022 switch (CPU) {
2023 case CK_Generic:
2024 // No processor selected!
2025 return false;
2026
2027 case CK_i386:
2028 case CK_i486:
2029 case CK_WinChipC6:
2030 case CK_WinChip2:
2031 case CK_C3:
2032 case CK_i586:
2033 case CK_Pentium:
2034 case CK_PentiumMMX:
2035 case CK_i686:
2036 case CK_PentiumPro:
2037 case CK_Pentium2:
2038 case CK_Pentium3:
2039 case CK_Pentium3M:
2040 case CK_PentiumM:
2041 case CK_Yonah:
2042 case CK_C3_2:
2043 case CK_Pentium4:
2044 case CK_Pentium4M:
2045 case CK_Prescott:
2046 case CK_K6:
2047 case CK_K6_2:
2048 case CK_K6_3:
2049 case CK_Athlon:
2050 case CK_AthlonThunderbird:
2051 case CK_Athlon4:
2052 case CK_AthlonXP:
2053 case CK_AthlonMP:
2054 case CK_Geode:
2055 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002056 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002057 return false;
2058
2059 // Fallthrough
2060 case CK_Nocona:
2061 case CK_Core2:
2062 case CK_Penryn:
2063 case CK_Atom:
Preston Gurda3c58c02013-09-13 19:27:17 +00002064 case CK_Silvermont:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002065 case CK_Corei7:
2066 case CK_Corei7AVX:
2067 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00002068 case CK_CoreAVX2:
Robert Khasanov50e6f582014-09-19 09:53:48 +00002069 case CK_Broadwell:
Craig Topper449314e2013-08-20 07:09:39 +00002070 case CK_KNL:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002071 case CK_SKX:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002072 case CK_Athlon64:
2073 case CK_Athlon64SSE3:
2074 case CK_AthlonFX:
2075 case CK_K8:
2076 case CK_K8SSE3:
2077 case CK_Opteron:
2078 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00002079 case CK_AMDFAM10:
Benjamin Kramer569f2152012-01-10 11:50:18 +00002080 case CK_BTVER1:
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002081 case CK_BTVER2:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002082 case CK_BDVER1:
2083 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002084 case CK_BDVER3:
Benjamin Kramer56c58222014-05-02 15:47:51 +00002085 case CK_BDVER4:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002086 case CK_x86_64:
2087 return true;
2088 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00002089 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002090 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002091
Craig Topper3164f332014-03-11 03:39:26 +00002092 bool setFPMath(StringRef Name) override;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002093
Craig Topper3164f332014-03-11 03:39:26 +00002094 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002095 // We accept all non-ARM calling conventions
2096 return (CC == CC_X86ThisCall ||
2097 CC == CC_X86FastCall ||
Reid Klecknerd7857f02014-10-24 17:42:17 +00002098 CC == CC_X86StdCall ||
2099 CC == CC_X86VectorCall ||
2100 CC == CC_C ||
Guy Benyeif0a014b2012-12-25 08:53:55 +00002101 CC == CC_X86Pascal ||
2102 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002103 }
2104
Craig Topper3164f332014-03-11 03:39:26 +00002105 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00002106 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002107 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00002108};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002109
Rafael Espindolaeb265472013-08-21 21:59:03 +00002110bool X86TargetInfo::setFPMath(StringRef Name) {
2111 if (Name == "387") {
2112 FPMath = FP_387;
2113 return true;
2114 }
2115 if (Name == "sse") {
2116 FPMath = FP_SSE;
2117 return true;
2118 }
2119 return false;
2120}
2121
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00002122void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002123 // FIXME: This *really* should not be here.
2124
2125 // X86_64 always has SSE2.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002126 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper86d79ef2013-09-17 04:51:29 +00002127 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002128
Chandler Carruth212334f2011-09-28 08:55:37 +00002129 switch (CPU) {
2130 case CK_Generic:
2131 case CK_i386:
2132 case CK_i486:
2133 case CK_i586:
2134 case CK_Pentium:
2135 case CK_i686:
2136 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00002137 break;
2138 case CK_PentiumMMX:
2139 case CK_Pentium2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002140 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002141 break;
2142 case CK_Pentium3:
2143 case CK_Pentium3M:
Craig Topper86d79ef2013-09-17 04:51:29 +00002144 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002145 break;
2146 case CK_PentiumM:
2147 case CK_Pentium4:
2148 case CK_Pentium4M:
2149 case CK_x86_64:
Craig Topper86d79ef2013-09-17 04:51:29 +00002150 setFeatureEnabledImpl(Features, "sse2", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002151 break;
2152 case CK_Yonah:
2153 case CK_Prescott:
2154 case CK_Nocona:
Craig Topper86d79ef2013-09-17 04:51:29 +00002155 setFeatureEnabledImpl(Features, "sse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002156 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002157 break;
2158 case CK_Core2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002159 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002160 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002161 break;
2162 case CK_Penryn:
Craig Topper86d79ef2013-09-17 04:51:29 +00002163 setFeatureEnabledImpl(Features, "sse4.1", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002164 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002165 break;
2166 case CK_Atom:
Craig Topper86d79ef2013-09-17 04:51:29 +00002167 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002168 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002169 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00002170 case CK_Silvermont:
Craig Topper86d79ef2013-09-17 04:51:29 +00002171 setFeatureEnabledImpl(Features, "sse4.2", true);
2172 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002173 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002174 setFeatureEnabledImpl(Features, "pclmul", true);
Preston Gurda3c58c02013-09-13 19:27:17 +00002175 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002176 case CK_Corei7:
Craig Topper86d79ef2013-09-17 04:51:29 +00002177 setFeatureEnabledImpl(Features, "sse4.2", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002178 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002179 break;
2180 case CK_Corei7AVX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002181 setFeatureEnabledImpl(Features, "avx", true);
2182 setFeatureEnabledImpl(Features, "aes", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002183 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002184 setFeatureEnabledImpl(Features, "pclmul", true);
Benjamin Kramer1e250392012-07-07 09:39:18 +00002185 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002186 case CK_CoreAVXi:
Craig Topper86d79ef2013-09-17 04:51:29 +00002187 setFeatureEnabledImpl(Features, "avx", true);
2188 setFeatureEnabledImpl(Features, "aes", true);
2189 setFeatureEnabledImpl(Features, "pclmul", true);
2190 setFeatureEnabledImpl(Features, "rdrnd", true);
2191 setFeatureEnabledImpl(Features, "f16c", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002192 break;
Craig Topper865fff52011-12-17 19:55:21 +00002193 case CK_CoreAVX2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002194 setFeatureEnabledImpl(Features, "avx2", true);
2195 setFeatureEnabledImpl(Features, "aes", true);
2196 setFeatureEnabledImpl(Features, "pclmul", true);
2197 setFeatureEnabledImpl(Features, "lzcnt", true);
2198 setFeatureEnabledImpl(Features, "rdrnd", true);
2199 setFeatureEnabledImpl(Features, "f16c", true);
2200 setFeatureEnabledImpl(Features, "bmi", true);
2201 setFeatureEnabledImpl(Features, "bmi2", true);
2202 setFeatureEnabledImpl(Features, "rtm", true);
2203 setFeatureEnabledImpl(Features, "fma", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002204 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper865fff52011-12-17 19:55:21 +00002205 break;
Robert Khasanov50e6f582014-09-19 09:53:48 +00002206 case CK_Broadwell:
2207 setFeatureEnabledImpl(Features, "avx2", true);
2208 setFeatureEnabledImpl(Features, "aes", true);
2209 setFeatureEnabledImpl(Features, "pclmul", true);
2210 setFeatureEnabledImpl(Features, "lzcnt", true);
2211 setFeatureEnabledImpl(Features, "rdrnd", true);
2212 setFeatureEnabledImpl(Features, "f16c", true);
2213 setFeatureEnabledImpl(Features, "bmi", true);
2214 setFeatureEnabledImpl(Features, "bmi2", true);
2215 setFeatureEnabledImpl(Features, "rtm", true);
2216 setFeatureEnabledImpl(Features, "fma", true);
2217 setFeatureEnabledImpl(Features, "cx16", true);
2218 setFeatureEnabledImpl(Features, "rdseed", true);
2219 setFeatureEnabledImpl(Features, "adx", true);
2220 break;
Craig Topper449314e2013-08-20 07:09:39 +00002221 case CK_KNL:
Craig Topper86d79ef2013-09-17 04:51:29 +00002222 setFeatureEnabledImpl(Features, "avx512f", true);
2223 setFeatureEnabledImpl(Features, "avx512cd", true);
2224 setFeatureEnabledImpl(Features, "avx512er", true);
2225 setFeatureEnabledImpl(Features, "avx512pf", true);
2226 setFeatureEnabledImpl(Features, "aes", true);
2227 setFeatureEnabledImpl(Features, "pclmul", true);
2228 setFeatureEnabledImpl(Features, "lzcnt", true);
2229 setFeatureEnabledImpl(Features, "rdrnd", true);
2230 setFeatureEnabledImpl(Features, "f16c", true);
2231 setFeatureEnabledImpl(Features, "bmi", true);
2232 setFeatureEnabledImpl(Features, "bmi2", true);
2233 setFeatureEnabledImpl(Features, "rtm", true);
2234 setFeatureEnabledImpl(Features, "fma", true);
Robert Khasanov50e6f582014-09-19 09:53:48 +00002235 setFeatureEnabledImpl(Features, "rdseed", true);
2236 setFeatureEnabledImpl(Features, "adx", true);
Craig Topper449314e2013-08-20 07:09:39 +00002237 break;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002238 case CK_SKX:
2239 setFeatureEnabledImpl(Features, "avx512f", true);
2240 setFeatureEnabledImpl(Features, "avx512cd", true);
2241 setFeatureEnabledImpl(Features, "avx512dq", true);
2242 setFeatureEnabledImpl(Features, "avx512bw", true);
2243 setFeatureEnabledImpl(Features, "avx512vl", true);
2244 setFeatureEnabledImpl(Features, "aes", true);
2245 setFeatureEnabledImpl(Features, "pclmul", true);
2246 setFeatureEnabledImpl(Features, "lzcnt", true);
2247 setFeatureEnabledImpl(Features, "rdrnd", true);
2248 setFeatureEnabledImpl(Features, "f16c", true);
2249 setFeatureEnabledImpl(Features, "bmi", true);
2250 setFeatureEnabledImpl(Features, "bmi2", true);
2251 setFeatureEnabledImpl(Features, "rtm", true);
2252 setFeatureEnabledImpl(Features, "fma", true);
Robert Khasanov50e6f582014-09-19 09:53:48 +00002253 setFeatureEnabledImpl(Features, "rdseed", true);
2254 setFeatureEnabledImpl(Features, "adx", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002255 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002256 case CK_K6:
2257 case CK_WinChipC6:
Craig Topper86d79ef2013-09-17 04:51:29 +00002258 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002259 break;
2260 case CK_K6_2:
2261 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00002262 case CK_WinChip2:
2263 case CK_C3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002264 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002265 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002266 case CK_Athlon:
2267 case CK_AthlonThunderbird:
2268 case CK_Geode:
Craig Topper86d79ef2013-09-17 04:51:29 +00002269 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002270 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002271 case CK_Athlon4:
2272 case CK_AthlonXP:
2273 case CK_AthlonMP:
Craig Topper86d79ef2013-09-17 04:51:29 +00002274 setFeatureEnabledImpl(Features, "sse", true);
2275 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002276 break;
2277 case CK_K8:
2278 case CK_Opteron:
2279 case CK_Athlon64:
2280 case CK_AthlonFX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002281 setFeatureEnabledImpl(Features, "sse2", true);
2282 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002283 break;
2284 case CK_K8SSE3:
2285 case CK_OpteronSSE3:
2286 case CK_Athlon64SSE3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002287 setFeatureEnabledImpl(Features, "sse3", true);
2288 setFeatureEnabledImpl(Features, "3dnowa", true);
Roman Divackyce253d82011-10-30 13:47:56 +00002289 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00002290 case CK_AMDFAM10:
Craig Topper86d79ef2013-09-17 04:51:29 +00002291 setFeatureEnabledImpl(Features, "sse3", true);
2292 setFeatureEnabledImpl(Features, "sse4a", true);
2293 setFeatureEnabledImpl(Features, "3dnowa", true);
2294 setFeatureEnabledImpl(Features, "lzcnt", true);
2295 setFeatureEnabledImpl(Features, "popcnt", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002296 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00002297 case CK_BTVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002298 setFeatureEnabledImpl(Features, "ssse3", true);
2299 setFeatureEnabledImpl(Features, "sse4a", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002300 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002301 setFeatureEnabledImpl(Features, "lzcnt", true);
2302 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002303 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper9ee12502012-05-30 05:54:54 +00002304 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002305 case CK_BTVER2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002306 setFeatureEnabledImpl(Features, "avx", true);
2307 setFeatureEnabledImpl(Features, "sse4a", true);
2308 setFeatureEnabledImpl(Features, "lzcnt", true);
2309 setFeatureEnabledImpl(Features, "aes", true);
2310 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002311 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002312 setFeatureEnabledImpl(Features, "bmi", true);
2313 setFeatureEnabledImpl(Features, "f16c", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002314 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002315 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002316 case CK_BDVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002317 setFeatureEnabledImpl(Features, "xop", true);
2318 setFeatureEnabledImpl(Features, "lzcnt", true);
2319 setFeatureEnabledImpl(Features, "aes", true);
2320 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002321 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002322 setFeatureEnabledImpl(Features, "cx16", true);
Eli Friedman102dc4e2012-11-26 21:57:28 +00002323 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002324 case CK_BDVER4:
2325 setFeatureEnabledImpl(Features, "avx2", true);
2326 setFeatureEnabledImpl(Features, "bmi2", true);
2327 // FALLTHROUGH
Eli Friedman3e94f572012-11-17 01:43:10 +00002328 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002329 case CK_BDVER3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002330 setFeatureEnabledImpl(Features, "xop", true);
2331 setFeatureEnabledImpl(Features, "lzcnt", true);
2332 setFeatureEnabledImpl(Features, "aes", true);
2333 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002334 setFeatureEnabledImpl(Features, "prfchw", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00002335 setFeatureEnabledImpl(Features, "bmi", true);
2336 setFeatureEnabledImpl(Features, "fma", true);
2337 setFeatureEnabledImpl(Features, "f16c", true);
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002338 setFeatureEnabledImpl(Features, "tbm", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002339 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002340 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002341 case CK_C3_2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002342 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002343 break;
Eli Friedman33465822011-07-08 23:31:17 +00002344 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002345}
2346
Rafael Espindolae62e2792013-08-20 13:44:29 +00002347void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002348 X86SSEEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002349 if (Enabled) {
2350 switch (Level) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002351 case AVX512F:
2352 Features["avx512f"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002353 case AVX2:
2354 Features["avx2"] = true;
2355 case AVX:
2356 Features["avx"] = true;
2357 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002358 Features["sse4.2"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002359 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002360 Features["sse4.1"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002361 case SSSE3:
2362 Features["ssse3"] = true;
2363 case SSE3:
2364 Features["sse3"] = true;
2365 case SSE2:
2366 Features["sse2"] = true;
2367 case SSE1:
Rafael Espindolae62e2792013-08-20 13:44:29 +00002368 Features["sse"] = true;
2369 case NoSSE:
2370 break;
2371 }
2372 return;
2373 }
2374
2375 switch (Level) {
2376 case NoSSE:
2377 case SSE1:
2378 Features["sse"] = false;
2379 case SSE2:
Ben Langmuir58078d02013-09-19 13:22:04 +00002380 Features["sse2"] = Features["pclmul"] = Features["aes"] =
2381 Features["sha"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002382 case SSE3:
2383 Features["sse3"] = false;
2384 setXOPLevel(Features, NoXOP, false);
2385 case SSSE3:
2386 Features["ssse3"] = false;
2387 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002388 Features["sse4.1"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002389 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002390 Features["sse4.2"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002391 case AVX:
Craig Topper31db3a22013-09-16 04:54:13 +00002392 Features["fma"] = Features["avx"] = Features["f16c"] = false;
Rafael Espindola0221d862013-08-21 13:28:02 +00002393 setXOPLevel(Features, FMA4, false);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002394 case AVX2:
2395 Features["avx2"] = false;
Craig Topper9c4d17f2013-08-21 03:59:22 +00002396 case AVX512F:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002397 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] = Features["avx512pf"] =
2398 Features["avx512dq"] = Features["avx512bw"] = Features["avx512vl"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002399 }
2400}
2401
2402void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002403 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002404 if (Enabled) {
2405 switch (Level) {
2406 case AMD3DNowAthlon:
2407 Features["3dnowa"] = true;
2408 case AMD3DNow:
2409 Features["3dnow"] = true;
2410 case MMX:
2411 Features["mmx"] = true;
2412 case NoMMX3DNow:
2413 break;
2414 }
2415 return;
2416 }
2417
2418 switch (Level) {
2419 case NoMMX3DNow:
2420 case MMX:
2421 Features["mmx"] = false;
2422 case AMD3DNow:
2423 Features["3dnow"] = false;
2424 case AMD3DNowAthlon:
2425 Features["3dnowa"] = false;
2426 }
2427}
2428
2429void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper13f61a62013-09-17 04:12:55 +00002430 bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002431 if (Enabled) {
2432 switch (Level) {
2433 case XOP:
2434 Features["xop"] = true;
2435 case FMA4:
2436 Features["fma4"] = true;
2437 setSSELevel(Features, AVX, true);
2438 case SSE4A:
2439 Features["sse4a"] = true;
2440 setSSELevel(Features, SSE3, true);
2441 case NoXOP:
2442 break;
2443 }
2444 return;
2445 }
2446
2447 switch (Level) {
2448 case NoXOP:
2449 case SSE4A:
2450 Features["sse4a"] = false;
2451 case FMA4:
2452 Features["fma4"] = false;
2453 case XOP:
2454 Features["xop"] = false;
2455 }
2456}
2457
Craig Topper86d79ef2013-09-17 04:51:29 +00002458void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2459 StringRef Name, bool Enabled) {
Eric Christopher399ffa52010-03-04 02:26:37 +00002460 // FIXME: This *really* should not be here. We need some way of translating
2461 // options into llvm subtarget features.
Rafael Espindola89049822013-08-23 20:21:37 +00002462 if (Name == "sse4")
2463 Name = "sse4.2";
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002464
Rafael Espindolae62e2792013-08-20 13:44:29 +00002465 Features[Name] = Enabled;
Rafael Espindolaa6416a72011-11-27 20:00:43 +00002466
Craig Topper29561122013-09-19 01:13:07 +00002467 if (Name == "mmx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002468 setMMXLevel(Features, MMX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002469 } else if (Name == "sse") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002470 setSSELevel(Features, SSE1, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002471 } else if (Name == "sse2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002472 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002473 } else if (Name == "sse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002474 setSSELevel(Features, SSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002475 } else if (Name == "ssse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002476 setSSELevel(Features, SSSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002477 } else if (Name == "sse4.2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002478 setSSELevel(Features, SSE42, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002479 } else if (Name == "sse4.1") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002480 setSSELevel(Features, SSE41, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002481 } else if (Name == "3dnow") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002482 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002483 } else if (Name == "3dnowa") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002484 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002485 } else if (Name == "aes") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002486 if (Enabled)
2487 setSSELevel(Features, SSE2, Enabled);
2488 } else if (Name == "pclmul") {
2489 if (Enabled)
2490 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002491 } else if (Name == "avx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002492 setSSELevel(Features, AVX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002493 } else if (Name == "avx2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002494 setSSELevel(Features, AVX2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002495 } else if (Name == "avx512f") {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002496 setSSELevel(Features, AVX512F, Enabled);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002497 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf"
2498 || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") {
Craig Topper679b53a2013-08-21 05:29:10 +00002499 if (Enabled)
2500 setSSELevel(Features, AVX512F, Enabled);
2501 } else if (Name == "fma") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002502 if (Enabled)
2503 setSSELevel(Features, AVX, Enabled);
2504 } else if (Name == "fma4") {
2505 setXOPLevel(Features, FMA4, Enabled);
2506 } else if (Name == "xop") {
2507 setXOPLevel(Features, XOP, Enabled);
2508 } else if (Name == "sse4a") {
2509 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper31db3a22013-09-16 04:54:13 +00002510 } else if (Name == "f16c") {
2511 if (Enabled)
2512 setSSELevel(Features, AVX, Enabled);
Ben Langmuir58078d02013-09-19 13:22:04 +00002513 } else if (Name == "sha") {
2514 if (Enabled)
2515 setSSELevel(Features, SSE2, Enabled);
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002516 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002517}
2518
Eric Christopher3ff21b32013-10-16 21:26:26 +00002519/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002520/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00002521bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindolaeb265472013-08-21 21:59:03 +00002522 DiagnosticsEngine &Diags) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00002523 // Remember the maximum enabled sselevel.
2524 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2525 // Ignore disabled features.
2526 if (Features[i][0] == '-')
2527 continue;
2528
Benjamin Kramer27402c62012-03-05 15:10:44 +00002529 StringRef Feature = StringRef(Features[i]).substr(1);
2530
2531 if (Feature == "aes") {
Eric Christophere1ddaf92010-04-02 23:50:19 +00002532 HasAES = true;
2533 continue;
2534 }
2535
Craig Topper3f122a72012-05-31 05:18:48 +00002536 if (Feature == "pclmul") {
2537 HasPCLMUL = true;
2538 continue;
2539 }
2540
Benjamin Kramer27402c62012-03-05 15:10:44 +00002541 if (Feature == "lzcnt") {
Craig Topper22967d42011-12-25 05:06:45 +00002542 HasLZCNT = true;
2543 continue;
2544 }
2545
Rafael Espindola89049822013-08-23 20:21:37 +00002546 if (Feature == "rdrnd") {
Benjamin Kramer1e250392012-07-07 09:39:18 +00002547 HasRDRND = true;
2548 continue;
2549 }
2550
Benjamin Kramer27402c62012-03-05 15:10:44 +00002551 if (Feature == "bmi") {
Craig Topper22967d42011-12-25 05:06:45 +00002552 HasBMI = true;
2553 continue;
2554 }
2555
Benjamin Kramer27402c62012-03-05 15:10:44 +00002556 if (Feature == "bmi2") {
Craig Topper22967d42011-12-25 05:06:45 +00002557 HasBMI2 = true;
2558 continue;
2559 }
2560
Benjamin Kramer27402c62012-03-05 15:10:44 +00002561 if (Feature == "popcnt") {
Craig Topper1de83482011-12-29 16:10:46 +00002562 HasPOPCNT = true;
2563 continue;
2564 }
2565
Michael Liao625a8752012-11-10 05:17:46 +00002566 if (Feature == "rtm") {
2567 HasRTM = true;
2568 continue;
2569 }
2570
Michael Liao74f4eaf2013-03-26 17:52:08 +00002571 if (Feature == "prfchw") {
2572 HasPRFCHW = true;
2573 continue;
2574 }
2575
Michael Liaoffaae352013-03-29 05:17:55 +00002576 if (Feature == "rdseed") {
2577 HasRDSEED = true;
2578 continue;
2579 }
2580
Robert Khasanov50e6f582014-09-19 09:53:48 +00002581 if (Feature == "adx") {
2582 HasADX = true;
2583 continue;
2584 }
2585
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002586 if (Feature == "tbm") {
2587 HasTBM = true;
2588 continue;
2589 }
2590
Craig Topperbba778b2012-06-03 21:46:30 +00002591 if (Feature == "fma") {
2592 HasFMA = true;
2593 continue;
2594 }
2595
Manman Rena45358c2012-10-11 00:59:55 +00002596 if (Feature == "f16c") {
2597 HasF16C = true;
2598 continue;
2599 }
2600
Craig Topper679b53a2013-08-21 05:29:10 +00002601 if (Feature == "avx512cd") {
2602 HasAVX512CD = true;
2603 continue;
2604 }
2605
2606 if (Feature == "avx512er") {
2607 HasAVX512ER = true;
2608 continue;
2609 }
2610
2611 if (Feature == "avx512pf") {
2612 HasAVX512PF = true;
2613 continue;
2614 }
2615
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002616 if (Feature == "avx512dq") {
2617 HasAVX512DQ = true;
2618 continue;
2619 }
2620
2621 if (Feature == "avx512bw") {
2622 HasAVX512BW = true;
2623 continue;
2624 }
2625
2626 if (Feature == "avx512vl") {
2627 HasAVX512VL = true;
2628 continue;
2629 }
2630
Ben Langmuir58078d02013-09-19 13:22:04 +00002631 if (Feature == "sha") {
2632 HasSHA = true;
2633 continue;
2634 }
2635
Nick Lewycky50e8f482013-10-05 20:14:27 +00002636 if (Feature == "cx16") {
2637 HasCX16 = true;
2638 continue;
2639 }
2640
Daniel Dunbar979586e2009-11-11 09:38:56 +00002641 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer27402c62012-03-05 15:10:44 +00002642 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper679b53a2013-08-21 05:29:10 +00002643 .Case("avx512f", AVX512F)
Craig Topper23b92192012-01-09 09:19:09 +00002644 .Case("avx2", AVX2)
2645 .Case("avx", AVX)
Rafael Espindola89049822013-08-23 20:21:37 +00002646 .Case("sse4.2", SSE42)
2647 .Case("sse4.1", SSE41)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002648 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00002649 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002650 .Case("sse2", SSE2)
2651 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00002652 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002653 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002654
Eli Friedman33465822011-07-08 23:31:17 +00002655 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer27402c62012-03-05 15:10:44 +00002656 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlssone437c682010-01-27 03:47:49 +00002657 .Case("3dnowa", AMD3DNowAthlon)
2658 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00002659 .Case("mmx", MMX)
2660 .Default(NoMMX3DNow);
Eli Friedman33465822011-07-08 23:31:17 +00002661 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002662
2663 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2664 .Case("xop", XOP)
2665 .Case("fma4", FMA4)
2666 .Case("sse4a", SSE4A)
2667 .Default(NoXOP);
2668 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002669 }
Eli Friedman33465822011-07-08 23:31:17 +00002670
Craig Topper7481d8a2013-09-10 06:55:47 +00002671 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2672 // Can't do this earlier because we need to be able to explicitly enable
2673 // popcnt and still disable sse4.2.
2674 if (!HasPOPCNT && SSELevel >= SSE42 &&
2675 std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){
2676 HasPOPCNT = true;
2677 Features.push_back("+popcnt");
2678 }
2679
Yunzhong Gao61089362013-10-16 19:07:02 +00002680 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2681 if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow &&
2682 std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){
2683 HasPRFCHW = true;
2684 Features.push_back("+prfchw");
2685 }
2686
Rafael Espindolaeb265472013-08-21 21:59:03 +00002687 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2688 // matches the selected sse level.
2689 if (FPMath == FP_SSE && SSELevel < SSE1) {
2690 Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2691 return false;
2692 } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2693 Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2694 return false;
2695 }
2696
Eli Friedman33465822011-07-08 23:31:17 +00002697 // Don't tell the backend if we're turning off mmx; it will end up disabling
2698 // SSE, which we don't want.
Craig Topperc0070a42013-09-11 06:48:53 +00002699 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2700 // then enable MMX.
Eli Friedman33465822011-07-08 23:31:17 +00002701 std::vector<std::string>::iterator it;
2702 it = std::find(Features.begin(), Features.end(), "-mmx");
2703 if (it != Features.end())
2704 Features.erase(it);
Craig Topperc0070a42013-09-11 06:48:53 +00002705 else if (SSELevel > NoSSE)
2706 MMX3DNowLevel = std::max(MMX3DNowLevel, MMX);
Rafael Espindolaeb265472013-08-21 21:59:03 +00002707 return true;
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002708}
Chris Lattnerecd49032009-03-02 22:27:17 +00002709
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002710/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2711/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002712void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002713 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002714 // Target identification.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002715 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002716 Builder.defineMacro("__amd64__");
2717 Builder.defineMacro("__amd64");
2718 Builder.defineMacro("__x86_64");
2719 Builder.defineMacro("__x86_64__");
Bob Wilsona2acb1e2014-08-08 23:46:28 +00002720 if (getTriple().getArchName() == "x86_64h") {
2721 Builder.defineMacro("__x86_64h");
2722 Builder.defineMacro("__x86_64h__");
2723 }
Chris Lattnerecd49032009-03-02 22:27:17 +00002724 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002725 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00002726 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002727
Chris Lattnerecd49032009-03-02 22:27:17 +00002728 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002729 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2730 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00002731 switch (CPU) {
2732 case CK_Generic:
2733 break;
2734 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002735 // The rest are coming from the i386 define above.
2736 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002737 break;
2738 case CK_i486:
2739 case CK_WinChipC6:
2740 case CK_WinChip2:
2741 case CK_C3:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002742 defineCPUMacros(Builder, "i486");
Chandler Carruth212334f2011-09-28 08:55:37 +00002743 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002744 case CK_PentiumMMX:
2745 Builder.defineMacro("__pentium_mmx__");
2746 Builder.defineMacro("__tune_pentium_mmx__");
2747 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002748 case CK_i586:
2749 case CK_Pentium:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002750 defineCPUMacros(Builder, "i586");
2751 defineCPUMacros(Builder, "pentium");
Chandler Carruth212334f2011-09-28 08:55:37 +00002752 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002753 case CK_Pentium3:
2754 case CK_Pentium3M:
2755 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002756 Builder.defineMacro("__tune_pentium3__");
2757 // Fallthrough
2758 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00002759 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002760 Builder.defineMacro("__tune_pentium2__");
2761 // Fallthrough
2762 case CK_PentiumPro:
2763 Builder.defineMacro("__tune_i686__");
2764 Builder.defineMacro("__tune_pentiumpro__");
2765 // Fallthrough
2766 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002767 Builder.defineMacro("__i686");
2768 Builder.defineMacro("__i686__");
2769 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2770 Builder.defineMacro("__pentiumpro");
2771 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002772 break;
2773 case CK_Pentium4:
2774 case CK_Pentium4M:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002775 defineCPUMacros(Builder, "pentium4");
Chandler Carruth212334f2011-09-28 08:55:37 +00002776 break;
2777 case CK_Yonah:
2778 case CK_Prescott:
2779 case CK_Nocona:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002780 defineCPUMacros(Builder, "nocona");
Chandler Carruth212334f2011-09-28 08:55:37 +00002781 break;
2782 case CK_Core2:
2783 case CK_Penryn:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002784 defineCPUMacros(Builder, "core2");
Chandler Carruth212334f2011-09-28 08:55:37 +00002785 break;
2786 case CK_Atom:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002787 defineCPUMacros(Builder, "atom");
Chandler Carruth212334f2011-09-28 08:55:37 +00002788 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00002789 case CK_Silvermont:
Benjamin Kramerffecc842013-08-30 14:05:34 +00002790 defineCPUMacros(Builder, "slm");
2791 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002792 case CK_Corei7:
2793 case CK_Corei7AVX:
2794 case CK_CoreAVXi:
Craig Topper865fff52011-12-17 19:55:21 +00002795 case CK_CoreAVX2:
Robert Khasanov50e6f582014-09-19 09:53:48 +00002796 case CK_Broadwell:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002797 defineCPUMacros(Builder, "corei7");
Chandler Carruth212334f2011-09-28 08:55:37 +00002798 break;
Craig Topper449314e2013-08-20 07:09:39 +00002799 case CK_KNL:
2800 defineCPUMacros(Builder, "knl");
2801 break;
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002802 case CK_SKX:
2803 defineCPUMacros(Builder, "skx");
2804 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002805 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002806 Builder.defineMacro("__k6_2__");
2807 Builder.defineMacro("__tune_k6_2__");
2808 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002809 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002810 if (CPU != CK_K6_2) { // In case of fallthrough
2811 // FIXME: GCC may be enabling these in cases where some other k6
2812 // architecture is specified but -m3dnow is explicitly provided. The
2813 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002814 Builder.defineMacro("__k6_3__");
2815 Builder.defineMacro("__tune_k6_3__");
2816 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002817 // Fallthrough
2818 case CK_K6:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002819 defineCPUMacros(Builder, "k6");
Chandler Carruth212334f2011-09-28 08:55:37 +00002820 break;
2821 case CK_Athlon:
2822 case CK_AthlonThunderbird:
2823 case CK_Athlon4:
2824 case CK_AthlonXP:
2825 case CK_AthlonMP:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002826 defineCPUMacros(Builder, "athlon");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002827 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002828 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002829 Builder.defineMacro("__tune_athlon_sse__");
2830 }
Chandler Carruth212334f2011-09-28 08:55:37 +00002831 break;
2832 case CK_K8:
2833 case CK_K8SSE3:
2834 case CK_x86_64:
2835 case CK_Opteron:
2836 case CK_OpteronSSE3:
2837 case CK_Athlon64:
2838 case CK_Athlon64SSE3:
2839 case CK_AthlonFX:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002840 defineCPUMacros(Builder, "k8");
Chandler Carruth212334f2011-09-28 08:55:37 +00002841 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00002842 case CK_AMDFAM10:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002843 defineCPUMacros(Builder, "amdfam10");
Roman Divacky43eb6f82011-10-30 07:48:46 +00002844 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00002845 case CK_BTVER1:
2846 defineCPUMacros(Builder, "btver1");
2847 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002848 case CK_BTVER2:
2849 defineCPUMacros(Builder, "btver2");
2850 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002851 case CK_BDVER1:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002852 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002853 break;
2854 case CK_BDVER2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002855 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002856 break;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002857 case CK_BDVER3:
2858 defineCPUMacros(Builder, "bdver3");
2859 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002860 case CK_BDVER4:
2861 defineCPUMacros(Builder, "bdver4");
2862 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002863 case CK_Geode:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002864 defineCPUMacros(Builder, "geode");
Chandler Carruth212334f2011-09-28 08:55:37 +00002865 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002866 }
Chris Lattner96e43572009-03-02 22:40:39 +00002867
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002868 // Target properties.
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002869 Builder.defineMacro("__REGISTER_PREFIX__", "");
2870
Chris Lattner6df41af2009-04-19 17:32:33 +00002871 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
2872 // functions in glibc header files that use FP Stack inline asm which the
2873 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002874 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002875
Chandler Carruth3f7ed952011-09-28 09:54:07 +00002876 if (HasAES)
2877 Builder.defineMacro("__AES__");
2878
Craig Topper3f122a72012-05-31 05:18:48 +00002879 if (HasPCLMUL)
2880 Builder.defineMacro("__PCLMUL__");
2881
Craig Topper22967d42011-12-25 05:06:45 +00002882 if (HasLZCNT)
2883 Builder.defineMacro("__LZCNT__");
2884
Benjamin Kramer1e250392012-07-07 09:39:18 +00002885 if (HasRDRND)
2886 Builder.defineMacro("__RDRND__");
2887
Craig Topper22967d42011-12-25 05:06:45 +00002888 if (HasBMI)
2889 Builder.defineMacro("__BMI__");
2890
2891 if (HasBMI2)
2892 Builder.defineMacro("__BMI2__");
2893
Craig Topper1de83482011-12-29 16:10:46 +00002894 if (HasPOPCNT)
2895 Builder.defineMacro("__POPCNT__");
2896
Michael Liao625a8752012-11-10 05:17:46 +00002897 if (HasRTM)
2898 Builder.defineMacro("__RTM__");
2899
Michael Liao74f4eaf2013-03-26 17:52:08 +00002900 if (HasPRFCHW)
2901 Builder.defineMacro("__PRFCHW__");
2902
Michael Liaoffaae352013-03-29 05:17:55 +00002903 if (HasRDSEED)
2904 Builder.defineMacro("__RDSEED__");
2905
Robert Khasanov50e6f582014-09-19 09:53:48 +00002906 if (HasADX)
2907 Builder.defineMacro("__ADX__");
2908
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002909 if (HasTBM)
2910 Builder.defineMacro("__TBM__");
2911
Rafael Espindolae62e2792013-08-20 13:44:29 +00002912 switch (XOPLevel) {
2913 case XOP:
2914 Builder.defineMacro("__XOP__");
2915 case FMA4:
Craig Topperffdb46c2011-12-30 07:33:42 +00002916 Builder.defineMacro("__FMA4__");
Rafael Espindolae62e2792013-08-20 13:44:29 +00002917 case SSE4A:
2918 Builder.defineMacro("__SSE4A__");
2919 case NoXOP:
2920 break;
2921 }
Craig Topperffdb46c2011-12-30 07:33:42 +00002922
Craig Topperbba778b2012-06-03 21:46:30 +00002923 if (HasFMA)
2924 Builder.defineMacro("__FMA__");
2925
Manman Rena45358c2012-10-11 00:59:55 +00002926 if (HasF16C)
2927 Builder.defineMacro("__F16C__");
2928
Craig Topper679b53a2013-08-21 05:29:10 +00002929 if (HasAVX512CD)
2930 Builder.defineMacro("__AVX512CD__");
2931 if (HasAVX512ER)
2932 Builder.defineMacro("__AVX512ER__");
2933 if (HasAVX512PF)
2934 Builder.defineMacro("__AVX512PF__");
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002935 if (HasAVX512DQ)
2936 Builder.defineMacro("__AVX512DQ__");
2937 if (HasAVX512BW)
2938 Builder.defineMacro("__AVX512BW__");
2939 if (HasAVX512VL)
2940 Builder.defineMacro("__AVX512VL__");
Craig Topper679b53a2013-08-21 05:29:10 +00002941
Ben Langmuir58078d02013-09-19 13:22:04 +00002942 if (HasSHA)
2943 Builder.defineMacro("__SHA__");
2944
Nick Lewycky50e8f482013-10-05 20:14:27 +00002945 if (HasCX16)
2946 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
2947
Chris Lattner96e43572009-03-02 22:40:39 +00002948 // Each case falls through to the previous one here.
2949 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002950 case AVX512F:
Craig Topper007b0592013-08-20 07:39:54 +00002951 Builder.defineMacro("__AVX512F__");
Craig Topper23b92192012-01-09 09:19:09 +00002952 case AVX2:
2953 Builder.defineMacro("__AVX2__");
2954 case AVX:
2955 Builder.defineMacro("__AVX__");
Chris Lattner96e43572009-03-02 22:40:39 +00002956 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002957 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00002958 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002959 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00002960 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002961 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002962 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002963 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00002964 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002965 Builder.defineMacro("__SSE2__");
2966 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00002967 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002968 Builder.defineMacro("__SSE__");
2969 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00002970 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00002971 break;
2972 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00002973
Derek Schuffc7dd7222012-10-11 15:52:22 +00002974 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002975 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002976 case AVX512F:
Craig Topper23b92192012-01-09 09:19:09 +00002977 case AVX2:
2978 case AVX:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00002979 case SSE42:
2980 case SSE41:
2981 case SSSE3:
2982 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002983 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002984 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002985 break;
2986 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002987 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002988 break;
2989 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002990 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00002991 }
2992 }
2993
Anders Carlssone437c682010-01-27 03:47:49 +00002994 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00002995 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00002996 case AMD3DNowAthlon:
2997 Builder.defineMacro("__3dNOW_A__");
2998 case AMD3DNow:
2999 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00003000 case MMX:
3001 Builder.defineMacro("__MMX__");
3002 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00003003 break;
3004 }
Michael J. Spencera0d5eb3a2013-04-04 23:53:43 +00003005
3006 if (CPU >= CK_i486) {
3007 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3008 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3009 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3010 }
3011 if (CPU >= CK_i586)
3012 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerecd49032009-03-02 22:27:17 +00003013}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003014
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003015bool X86TargetInfo::hasFeature(StringRef Feature) const {
3016 return llvm::StringSwitch<bool>(Feature)
3017 .Case("aes", HasAES)
3018 .Case("avx", SSELevel >= AVX)
3019 .Case("avx2", SSELevel >= AVX2)
Craig Topper9c4d17f2013-08-21 03:59:22 +00003020 .Case("avx512f", SSELevel >= AVX512F)
Craig Topper679b53a2013-08-21 05:29:10 +00003021 .Case("avx512cd", HasAVX512CD)
3022 .Case("avx512er", HasAVX512ER)
3023 .Case("avx512pf", HasAVX512PF)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003024 .Case("avx512dq", HasAVX512DQ)
3025 .Case("avx512bw", HasAVX512BW)
3026 .Case("avx512vl", HasAVX512VL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003027 .Case("bmi", HasBMI)
3028 .Case("bmi2", HasBMI2)
Nick Lewycky50e8f482013-10-05 20:14:27 +00003029 .Case("cx16", HasCX16)
3030 .Case("f16c", HasF16C)
Craig Topperbba778b2012-06-03 21:46:30 +00003031 .Case("fma", HasFMA)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003032 .Case("fma4", XOPLevel >= FMA4)
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00003033 .Case("tbm", HasTBM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003034 .Case("lzcnt", HasLZCNT)
Benjamin Kramer1e250392012-07-07 09:39:18 +00003035 .Case("rdrnd", HasRDRND)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003036 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
3037 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3038 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3f122a72012-05-31 05:18:48 +00003039 .Case("pclmul", HasPCLMUL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003040 .Case("popcnt", HasPOPCNT)
Michael Liao625a8752012-11-10 05:17:46 +00003041 .Case("rtm", HasRTM)
Michael Liao74f4eaf2013-03-26 17:52:08 +00003042 .Case("prfchw", HasPRFCHW)
Michael Liaoffaae352013-03-29 05:17:55 +00003043 .Case("rdseed", HasRDSEED)
Ben Langmuir58078d02013-09-19 13:22:04 +00003044 .Case("sha", HasSHA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003045 .Case("sse", SSELevel >= SSE1)
3046 .Case("sse2", SSELevel >= SSE2)
3047 .Case("sse3", SSELevel >= SSE3)
3048 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola89049822013-08-23 20:21:37 +00003049 .Case("sse4.1", SSELevel >= SSE41)
3050 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003051 .Case("sse4a", XOPLevel >= SSE4A)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003052 .Case("x86", true)
Derek Schuffc7dd7222012-10-11 15:52:22 +00003053 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
3054 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003055 .Case("xop", XOPLevel >= XOP)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003056 .Default(false);
3057}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003058
Eli Friedman3fd920a2008-08-20 02:34:37 +00003059bool
Anders Carlsson58436352009-02-28 17:11:49 +00003060X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00003061 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00003062 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003063 default: return false;
Dale Johannesen46742a42010-08-24 22:33:12 +00003064 case 'Y': // first letter of a pair:
3065 switch (*(Name+1)) {
3066 default: return false;
3067 case '0': // First SSE register.
3068 case 't': // Any SSE register, when SSE2 is enabled.
3069 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
3070 case 'm': // any MMX register, when inter-unit moves enabled.
3071 break; // falls through to setAllowsRegister.
3072 }
Akira Hatanaka88ef7282014-07-18 23:30:30 +00003073 case 'f': // any x87 floating point stack register.
3074 // Constraint 'f' cannot be used for output operands.
3075 if (Info.ConstraintStr[0] == '=')
3076 return false;
3077
3078 Info.setAllowsRegister();
3079 return true;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003080 case 'a': // eax.
3081 case 'b': // ebx.
3082 case 'c': // ecx.
3083 case 'd': // edx.
3084 case 'S': // esi.
3085 case 'D': // edi.
3086 case 'A': // edx:eax.
3087 case 't': // top of floating point stack.
3088 case 'u': // second from top of floating point stack.
3089 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00003090 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00003091 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003092 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00003093 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
3094 case 'l': // "Index" registers: any general register that can be used as an
3095 // index in a base+index memory access.
3096 Info.setAllowsRegister();
3097 return true;
3098 case 'C': // SSE floating point constant.
3099 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003100 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003101 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003102 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003103 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003104 return true;
3105 }
3106}
3107
Akira Hatanaka974131e2014-09-18 18:17:18 +00003108bool X86TargetInfo::validateOutputSize(StringRef Constraint,
3109 unsigned Size) const {
3110 // Strip off constraint modifiers.
3111 while (Constraint[0] == '=' ||
3112 Constraint[0] == '+' ||
3113 Constraint[0] == '&')
3114 Constraint = Constraint.substr(1);
3115
3116 return validateOperandSize(Constraint, Size);
3117}
3118
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003119bool X86TargetInfo::validateInputSize(StringRef Constraint,
3120 unsigned Size) const {
Akira Hatanaka974131e2014-09-18 18:17:18 +00003121 return validateOperandSize(Constraint, Size);
3122}
3123
3124bool X86TargetInfo::validateOperandSize(StringRef Constraint,
3125 unsigned Size) const {
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003126 switch (Constraint[0]) {
3127 default: break;
3128 case 'y':
3129 return Size <= 64;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003130 case 'f':
3131 case 't':
3132 case 'u':
3133 return Size <= 128;
Hans Wennborg3c619a42014-09-18 20:24:04 +00003134 case 'x':
Akira Hatanakae867e422014-09-18 21:58:54 +00003135 // 256-bit ymm registers can be used if target supports AVX.
Aaron Ballmanc1953dc2014-09-19 12:21:56 +00003136 return Size <= (SSELevel >= AVX ? 256U : 128U);
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003137 }
3138
3139 return true;
3140}
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00003141
Eli Friedman3fd920a2008-08-20 02:34:37 +00003142std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003143X86TargetInfo::convertConstraint(const char *&Constraint) const {
3144 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003145 case 'a': return std::string("{ax}");
3146 case 'b': return std::string("{bx}");
3147 case 'c': return std::string("{cx}");
3148 case 'd': return std::string("{dx}");
3149 case 'S': return std::string("{si}");
3150 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00003151 case 'p': // address
3152 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00003153 case 't': // top of floating point stack.
3154 return std::string("{st}");
3155 case 'u': // second from top of floating point stack.
3156 return std::string("{st(1)}"); // second from top of floating point stack.
3157 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003158 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00003159 }
3160}
Eli Friedman3fd920a2008-08-20 02:34:37 +00003161} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00003162
3163namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003164// X86-32 generic target
3165class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00003166public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003167 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003168 DoubleAlign = LongLongAlign = 32;
3169 LongDoubleWidth = 96;
3170 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00003171 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003172 DescriptionString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
Eli Friedman32ca82a2009-03-29 20:31:09 +00003173 SizeType = UnsignedInt;
3174 PtrDiffType = SignedInt;
3175 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003176 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003177
3178 // Use fpret for all types.
3179 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
3180 (1 << TargetInfo::Double) |
3181 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003182
3183 // x86-32 has atomics up to 8 bytes
3184 // FIXME: Check that we actually have cmpxchg8b before setting
3185 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
3186 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003187 }
Craig Topper3164f332014-03-11 03:39:26 +00003188 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003189 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003190 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003191
Craig Topper3164f332014-03-11 03:39:26 +00003192 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003193 if (RegNo == 0) return 0;
3194 if (RegNo == 1) return 2;
3195 return -1;
3196 }
Akira Hatanaka974131e2014-09-18 18:17:18 +00003197 bool validateOperandSize(StringRef Constraint,
3198 unsigned Size) const override {
Bill Wendling887b4852012-11-12 06:42:51 +00003199 switch (Constraint[0]) {
3200 default: break;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003201 case 'R':
3202 case 'q':
3203 case 'Q':
Bill Wendling887b4852012-11-12 06:42:51 +00003204 case 'a':
3205 case 'b':
3206 case 'c':
3207 case 'd':
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003208 case 'S':
3209 case 'D':
Bill Wendling3c7fed82012-11-12 18:52:32 +00003210 return Size <= 32;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003211 case 'A':
3212 return Size <= 64;
Bill Wendling887b4852012-11-12 06:42:51 +00003213 }
3214
Akira Hatanaka974131e2014-09-18 18:17:18 +00003215 return X86TargetInfo::validateOperandSize(Constraint, Size);
Bill Wendling887b4852012-11-12 06:42:51 +00003216 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003217};
3218} // end anonymous namespace
3219
3220namespace {
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003221class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
3222public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003223 NetBSDI386TargetInfo(const llvm::Triple &Triple)
3224 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003225
Craig Topper3164f332014-03-11 03:39:26 +00003226 unsigned getFloatEvalMethod() const override {
Joerg Sonnenberger0e921f22013-11-11 14:00:37 +00003227 unsigned Major, Minor, Micro;
3228 getTriple().getOSVersion(Major, Minor, Micro);
3229 // New NetBSD uses the default rounding mode.
3230 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3231 return X86_32TargetInfo::getFloatEvalMethod();
3232 // NetBSD before 6.99.26 defaults to "double" rounding.
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003233 return 1;
3234 }
3235};
3236} // end anonymous namespace
3237
3238namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003239class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
3240public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003241 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
3242 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003243 SizeType = UnsignedLong;
3244 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003245 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00003246 }
3247};
3248} // end anonymous namespace
3249
3250namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003251class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3252public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003253 BitrigI386TargetInfo(const llvm::Triple &Triple)
3254 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman9fa28852012-08-08 23:57:20 +00003255 SizeType = UnsignedLong;
3256 IntPtrType = SignedLong;
3257 PtrDiffType = SignedLong;
3258 }
3259};
3260} // end anonymous namespace
3261
3262namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00003263class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003264public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003265 DarwinI386TargetInfo(const llvm::Triple &Triple)
3266 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003267 LongDoubleWidth = 128;
3268 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003269 SuitableAlign = 128;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003270 MaxVectorAlign = 256;
Eli Friedman32ca82a2009-03-29 20:31:09 +00003271 SizeType = UnsignedLong;
3272 IntPtrType = SignedLong;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003273 DescriptionString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
Daniel Dunbarbd606522010-05-27 00:35:16 +00003274 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00003275 }
3276
Eli Friedman3fd920a2008-08-20 02:34:37 +00003277};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00003278} // end anonymous namespace
3279
3280namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003281// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003282class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003283public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003284 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3285 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Chris Lattner46be2e12009-06-24 17:12:15 +00003286 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00003287 DoubleAlign = LongLongAlign = 64;
Rafael Espindola26d0f7c2014-01-10 13:42:17 +00003288 DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003289 }
Craig Topper3164f332014-03-11 03:39:26 +00003290 void getTargetDefines(const LangOptions &Opts,
3291 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003292 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3293 }
3294};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003295
3296// x86-32 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003297class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003298public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003299 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003300 : WindowsX86_32TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003301 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003302 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3303 }
Craig Topper3164f332014-03-11 03:39:26 +00003304 void getTargetDefines(const LangOptions &Opts,
3305 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003306 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3307 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3308 // The value of the following reflects processor type.
3309 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3310 // We lost the original triple, so we use the default.
3311 Builder.defineMacro("_M_IX86", "600");
3312 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003313};
3314} // end anonymous namespace
3315
Reid Kleckner47606832014-04-21 20:58:00 +00003316static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
3317 Builder.defineMacro("__MSVCRT__");
3318 Builder.defineMacro("__MINGW32__");
3319
3320 // Mingw defines __declspec(a) to __attribute__((a)). Clang supports
3321 // __declspec natively under -fms-extensions, but we define a no-op __declspec
3322 // macro anyway for pre-processor compatibility.
3323 if (Opts.MicrosoftExt)
3324 Builder.defineMacro("__declspec", "__declspec");
3325 else
3326 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
3327
3328 if (!Opts.MicrosoftExt) {
3329 // Provide macros for all the calling convention keywords. Provide both
3330 // single and double underscore prefixed variants. These are available on
3331 // x64 as well as x86, even though they have no effect.
3332 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
3333 for (const char *CC : CCs) {
Reid Kleckner70cfa662014-04-21 22:29:45 +00003334 std::string GCCSpelling = "__attribute__((__";
3335 GCCSpelling += CC;
3336 GCCSpelling += "__))";
Reid Kleckner47606832014-04-21 20:58:00 +00003337 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
3338 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
3339 }
3340 }
3341}
3342
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003343namespace {
3344// x86-32 MinGW target
3345class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3346public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003347 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
3348 : WindowsX86_32TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003349 void getTargetDefines(const LangOptions &Opts,
3350 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003351 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003352 DefineStd(Builder, "WIN32", Opts);
3353 DefineStd(Builder, "WINNT", Opts);
3354 Builder.defineMacro("_X86_");
Reid Kleckner47606832014-04-21 20:58:00 +00003355 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003356 }
3357};
3358} // end anonymous namespace
3359
3360namespace {
3361// x86-32 Cygwin target
3362class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3363public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003364 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3365 : X86_32TargetInfo(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003366 TLSSupported = false;
3367 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003368 DoubleAlign = LongLongAlign = 64;
Rafael Espindola26d0f7c2014-01-10 13:42:17 +00003369 DescriptionString = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003370 }
Craig Topper3164f332014-03-11 03:39:26 +00003371 void getTargetDefines(const LangOptions &Opts,
3372 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003373 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumi02f43952012-12-14 10:17:26 +00003374 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003375 Builder.defineMacro("__CYGWIN__");
3376 Builder.defineMacro("__CYGWIN32__");
3377 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00003378 if (Opts.CPlusPlus)
3379 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00003380 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003381};
3382} // end anonymous namespace
3383
3384namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003385// x86-32 Haiku target
3386class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3387public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003388 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003389 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00003390 IntPtrType = SignedLong;
3391 PtrDiffType = SignedLong;
Eli Friedman4e91899e2012-11-27 02:58:24 +00003392 ProcessIDType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00003393 this->UserLabelPrefix = "";
Benjamin Kramerd0b9f092012-11-08 12:59:15 +00003394 this->TLSSupported = false;
Eli Friedman04831922010-08-22 01:00:03 +00003395 }
Craig Topper3164f332014-03-11 03:39:26 +00003396 void getTargetDefines(const LangOptions &Opts,
3397 MacroBuilder &Builder) const override {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003398 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3399 Builder.defineMacro("__INTEL__");
3400 Builder.defineMacro("__HAIKU__");
3401 }
3402};
3403} // end anonymous namespace
3404
Douglas Gregor9fabd852011-07-01 22:41:14 +00003405// RTEMS Target
3406template<typename Target>
3407class RTEMSTargetInfo : public OSTargetInfo<Target> {
3408protected:
Craig Topper3164f332014-03-11 03:39:26 +00003409 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3410 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003411 // RTEMS defines; list based off of gcc output
3412
Douglas Gregor9fabd852011-07-01 22:41:14 +00003413 Builder.defineMacro("__rtems__");
3414 Builder.defineMacro("__ELF__");
3415 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003416
Douglas Gregor9fabd852011-07-01 22:41:14 +00003417public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003418 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3419 this->UserLabelPrefix = "";
Douglas Gregor9fabd852011-07-01 22:41:14 +00003420
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003421 switch (Triple.getArch()) {
3422 default:
3423 case llvm::Triple::x86:
3424 // this->MCountName = ".mcount";
3425 break;
3426 case llvm::Triple::mips:
3427 case llvm::Triple::mipsel:
3428 case llvm::Triple::ppc:
3429 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +00003430 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003431 // this->MCountName = "_mcount";
3432 break;
3433 case llvm::Triple::arm:
3434 // this->MCountName = "__mcount";
3435 break;
Douglas Gregor9fabd852011-07-01 22:41:14 +00003436 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003437 }
Douglas Gregor9fabd852011-07-01 22:41:14 +00003438};
3439
3440namespace {
3441// x86-32 RTEMS target
3442class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3443public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003444 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003445 SizeType = UnsignedLong;
3446 IntPtrType = SignedLong;
3447 PtrDiffType = SignedLong;
3448 this->UserLabelPrefix = "";
3449 }
Craig Topper3164f332014-03-11 03:39:26 +00003450 void getTargetDefines(const LangOptions &Opts,
3451 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003452 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3453 Builder.defineMacro("__INTEL__");
3454 Builder.defineMacro("__rtems__");
3455 }
3456};
3457} // end anonymous namespace
3458
Chris Lattnerb986aba2010-04-11 19:29:39 +00003459namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003460// x86-64 generic target
3461class X86_64TargetInfo : public X86TargetInfo {
3462public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003463 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
David Blaikie40f842d2014-07-10 18:46:15 +00003464 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
Zinovy Nis1db95732014-07-10 15:27:19 +00003465 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00003466 LongDoubleWidth = 128;
3467 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00003468 LargeArrayMinWidth = 128;
3469 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003470 SuitableAlign = 128;
Zinovy Nis1db95732014-07-10 15:27:19 +00003471 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
3472 PtrDiffType = IsX32 ? SignedInt : SignedLong;
3473 IntPtrType = IsX32 ? SignedInt : SignedLong;
3474 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Zinovy Nis1db95732014-07-10 15:27:19 +00003475 Int64Type = IsX32 ? SignedLongLong : SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003476 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00003477
Zinovy Nis1db95732014-07-10 15:27:19 +00003478 DescriptionString = (IsX32)
3479 ? "e-m:e-" "p:32:32-" "i64:64-f80:128-n8:16:32:64-S128"
3480 : "e-m:e-" "i64:64-f80:128-n8:16:32:64-S128";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003481
3482 // Use fpret only for long double.
3483 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003484
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00003485 // Use fp2ret for _Complex long double.
3486 ComplexLongDoubleUsesFP2Ret = true;
3487
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003488 // x86-64 has atomics up to 16 bytes.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003489 MaxAtomicPromoteWidth = 128;
Tim Northover1471cb12014-07-02 10:25:45 +00003490 MaxAtomicInlineWidth = 128;
Chris Lattner10a5b382007-01-29 05:24:35 +00003491 }
Craig Topper3164f332014-03-11 03:39:26 +00003492 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003493 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson5fa3f342007-11-24 23:38:12 +00003494 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003495
Craig Topper3164f332014-03-11 03:39:26 +00003496 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003497 if (RegNo == 0) return 0;
3498 if (RegNo == 1) return 1;
3499 return -1;
3500 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003501
Craig Topper3164f332014-03-11 03:39:26 +00003502 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00003503 return (CC == CC_C ||
3504 CC == CC_IntelOclBicc ||
3505 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003506 }
3507
Craig Topper3164f332014-03-11 03:39:26 +00003508 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00003509 return CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003510 }
3511
Pavel Chupinfd223e12014-08-04 12:39:43 +00003512 // for x32 we need it here explicitly
3513 bool hasInt128Type() const override { return true; }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003514};
3515} // end anonymous namespace
3516
3517namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003518// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003519class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003520public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003521 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3522 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003523 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00003524 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003525 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003526 IntMaxType = SignedLongLong;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003527 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00003528 SizeType = UnsignedLongLong;
3529 PtrDiffType = SignedLongLong;
3530 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00003531 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003532 }
Craig Topper3164f332014-03-11 03:39:26 +00003533 void getTargetDefines(const LangOptions &Opts,
3534 MacroBuilder &Builder) const override {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003535 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003536 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003537 }
Craig Topper3164f332014-03-11 03:39:26 +00003538 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003539 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00003540 }
Craig Topper3164f332014-03-11 03:39:26 +00003541 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00003542 return (CC == CC_C ||
3543 CC == CC_IntelOclBicc ||
3544 CC == CC_X86_64SysV) ? CCCR_OK : CCCR_Warning;
3545 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003546};
3547} // end anonymous namespace
3548
3549namespace {
3550// x86-64 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003551class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003552public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003553 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003554 : WindowsX86_64TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003555 LongDoubleWidth = LongDoubleAlign = 64;
3556 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003557 }
Craig Topper3164f332014-03-11 03:39:26 +00003558 void getTargetDefines(const LangOptions &Opts,
3559 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003560 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3561 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003562 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003563 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003564 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003565};
3566} // end anonymous namespace
3567
3568namespace {
3569// x86-64 MinGW target
3570class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3571public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003572 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3573 : WindowsX86_64TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003574 void getTargetDefines(const LangOptions &Opts,
3575 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003576 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003577 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003578 Builder.defineMacro("__MINGW64__");
Reid Kleckner47606832014-04-21 20:58:00 +00003579 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003580 }
3581};
3582} // end anonymous namespace
3583
3584namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003585class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3586public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003587 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3588 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003589 Int64Type = SignedLongLong;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003590 MaxVectorAlign = 256;
Tim Northovera2ee4332014-03-29 15:09:45 +00003591 // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
3592 llvm::Triple T = llvm::Triple(Triple);
Bob Wilson946c04c2014-10-19 02:19:27 +00003593 if (T.isiOS())
Tim Northovera2ee4332014-03-29 15:09:45 +00003594 UseSignedCharForObjCBool = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003595 DescriptionString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128";
Eli Friedman2857ccb2009-07-01 03:36:11 +00003596 }
3597};
3598} // end anonymous namespace
3599
3600namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00003601class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3602public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003603 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3604 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman245f2292009-07-05 22:31:18 +00003605 IntMaxType = SignedLongLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003606 Int64Type = SignedLongLong;
3607 }
3608};
3609} // end anonymous namespace
3610
3611namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003612class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3613public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003614 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3615 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3616 IntMaxType = SignedLongLong;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003617 Int64Type = SignedLongLong;
Eli Friedman9fa28852012-08-08 23:57:20 +00003618 }
3619};
Tim Northover9bb857a2013-01-31 12:13:10 +00003620}
3621
Eli Friedman9fa28852012-08-08 23:57:20 +00003622
3623namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00003624class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003625 // Possible FPU choices.
3626 enum FPUMode {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003627 VFP2FPU = (1 << 0),
3628 VFP3FPU = (1 << 1),
3629 VFP4FPU = (1 << 2),
Bernard Ogdenda13af32013-10-24 18:32:51 +00003630 NeonFPU = (1 << 3),
3631 FPARMV8 = (1 << 4)
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003632 };
3633
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003634 // Possible HWDiv features.
3635 enum HWDivMode {
3636 HWDivThumb = (1 << 0),
3637 HWDivARM = (1 << 1)
3638 };
3639
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003640 static bool FPUModeIsVFP(FPUMode Mode) {
Bernard Ogdenda13af32013-10-24 18:32:51 +00003641 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003642 }
3643
3644 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3645 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00003646
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003647 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003648
Rafael Espindolaeb265472013-08-21 21:59:03 +00003649 enum {
3650 FP_Default,
3651 FP_VFP,
3652 FP_Neon
3653 } FPMath;
3654
Bernard Ogdenda13af32013-10-24 18:32:51 +00003655 unsigned FPU : 5;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003656
Logan Chien57086ce2012-10-10 06:56:20 +00003657 unsigned IsAAPCS : 1;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003658 unsigned IsThumb : 1;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003659 unsigned HWDiv : 2;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003660
3661 // Initialized via features.
3662 unsigned SoftFloat : 1;
3663 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00003664
Bernard Ogden18b57012013-10-29 09:47:51 +00003665 unsigned CRC : 1;
Tim Northover02e38602014-02-03 17:28:04 +00003666 unsigned Crypto : 1;
Bernard Ogden18b57012013-10-29 09:47:51 +00003667
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003668 // ACLE 6.5.1 Hardware floating point
3669 enum {
3670 HW_FP_HP = (1 << 1), /// half (16-bit)
3671 HW_FP_SP = (1 << 2), /// single (32-bit)
3672 HW_FP_DP = (1 << 3), /// double (64-bit)
3673 };
3674 uint32_t HW_FP;
3675
Chris Lattner5cc15e02010-03-03 19:03:45 +00003676 static const Builtin::Info BuiltinInfo[];
3677
Rafael Espindola101d5b92013-05-13 20:09:47 +00003678 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
Rafael Espindola101d5b92013-05-13 20:09:47 +00003679 StringRef ArchName = T.getArchName();
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003680 if (T.getArch() == llvm::Triple::arm ||
3681 T.getArch() == llvm::Triple::armeb) {
3682 StringRef VersionStr;
3683 if (ArchName.startswith("armv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003684 VersionStr = ArchName.substr(4, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003685 else if (ArchName.startswith("armebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003686 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003687 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003688 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003689 unsigned Version;
3690 if (VersionStr.getAsInteger(10, Version))
3691 return false;
3692 return Version >= 6;
3693 }
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003694 assert(T.getArch() == llvm::Triple::thumb ||
3695 T.getArch() == llvm::Triple::thumbeb);
3696 StringRef VersionStr;
3697 if (ArchName.startswith("thumbv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003698 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003699 else if (ArchName.startswith("thumbebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003700 VersionStr = ArchName.substr(8, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003701 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003702 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003703 unsigned Version;
3704 if (VersionStr.getAsInteger(10, Version))
3705 return false;
3706 return Version >= 7;
Rafael Espindola101d5b92013-05-13 20:09:47 +00003707 }
3708
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003709 void setABIAAPCS() {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003710 IsAAPCS = true;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003711
3712 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003713 const llvm::Triple &T = getTriple();
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003714
Tim Northover00853e52014-08-05 11:07:26 +00003715 // size_t is unsigned long on MachO-derived environments and NetBSD.
3716 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003717 SizeType = UnsignedLong;
3718 else
3719 SizeType = UnsignedInt;
3720
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003721 switch (T.getOS()) {
3722 case llvm::Triple::NetBSD:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003723 WCharType = SignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003724 break;
3725 case llvm::Triple::Win32:
3726 WCharType = UnsignedShort;
3727 break;
3728 case llvm::Triple::Linux:
3729 default:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003730 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3731 WCharType = UnsignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003732 break;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003733 }
3734
3735 UseBitFieldTypeAlignment = true;
3736
3737 ZeroLengthBitfieldBoundary = 0;
3738
Tim Northover147cd2f2014-10-14 22:12:21 +00003739 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3740 // so set preferred for small types to 32.
3741 if (T.isOSBinFormatMachO()) {
3742 DescriptionString =
3743 BigEndian ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3744 : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
3745 } else if (T.isOSWindows()) {
3746 // FIXME: this is invalid for WindowsCE
3747 assert(!BigEndian && "Windows on ARM does not support big endian");
3748 DescriptionString = "e"
3749 "-m:e"
3750 "-p:32:32"
3751 "-i64:64"
3752 "-v128:64:128"
3753 "-a:0:32"
3754 "-n32"
3755 "-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003756 } else {
Tim Northover147cd2f2014-10-14 22:12:21 +00003757 DescriptionString =
3758 BigEndian ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3759 : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003760 }
3761
3762 // FIXME: Enumerated types are variable width in straight AAPCS.
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003763 }
3764
3765 void setABIAPCS() {
Rafael Espindolac418ae92014-01-03 19:22:05 +00003766 const llvm::Triple &T = getTriple();
3767
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003768 IsAAPCS = false;
3769
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003770 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003771
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003772 // size_t is unsigned int on FreeBSD.
Rafael Espindolac418ae92014-01-03 19:22:05 +00003773 if (T.getOS() == llvm::Triple::FreeBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003774 SizeType = UnsignedInt;
3775 else
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003776 SizeType = UnsignedLong;
3777
3778 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3779 WCharType = SignedInt;
3780
3781 // Do not respect the alignment of bit-field types when laying out
3782 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3783 UseBitFieldTypeAlignment = false;
3784
3785 /// gcc forces the alignment to 4 bytes, regardless of the type of the
3786 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3787 /// gcc.
3788 ZeroLengthBitfieldBoundary = 32;
3789
Tim Northover147cd2f2014-10-14 22:12:21 +00003790 if (T.isOSBinFormatMachO())
3791 DescriptionString =
3792 BigEndian
3793 ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3794 : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
3795 else
3796 DescriptionString =
3797 BigEndian
3798 ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3799 : "e-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003800
3801 // FIXME: Override "preferred align" for double and long long.
3802 }
3803
Chris Lattner17df24e2008-04-21 18:56:49 +00003804public:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003805 ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003806 : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default),
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003807 IsAAPCS(true), HW_FP(0) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003808 BigEndian = IsBigEndian;
3809
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003810 switch (getTriple().getOS()) {
3811 case llvm::Triple::NetBSD:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00003812 PtrDiffType = SignedLong;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003813 break;
3814 default:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00003815 PtrDiffType = SignedInt;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003816 break;
3817 }
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00003818
Chris Lattner1a8f3942010-04-23 16:29:58 +00003819 // {} in inline assembly are neon specifiers, not assembly variant
3820 // specifiers.
3821 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003822
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003823 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00003824 IsThumb = getTriple().getArchName().startswith("thumb");
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003825
3826 setABI("aapcs-linux");
John McCall86353412010-08-21 22:46:04 +00003827
3828 // ARM targets default to using the ARM C++ ABI.
John McCall359b8852013-01-25 22:30:49 +00003829 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003830
3831 // ARM has atomics up to 8 bytes
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003832 MaxAtomicPromoteWidth = 64;
Rafael Espindola101d5b92013-05-13 20:09:47 +00003833 if (shouldUseInlineAtomic(getTriple()))
3834 MaxAtomicInlineWidth = 64;
James Molloya7139222012-03-12 09:14:10 +00003835
3836 // Do force alignment of members that follow zero length bitfields. If
3837 // the alignment of the zero-length bitfield is greater than the member
3838 // that follows it, `bar', `bar' will be aligned as the type of the
3839 // zero length bitfield.
3840 UseZeroLengthBitfieldAlignment = true;
Eli Friedmanb5366062008-05-20 14:21:01 +00003841 }
Alp Toker4925ba72014-06-07 23:30:42 +00003842 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00003843 bool setABI(const std::string &Name) override {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00003844 ABI = Name;
3845
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00003846 // The defaults (above) are for AAPCS, check if we need to change them.
3847 //
3848 // FIXME: We need support for -meabi... we could just mangle it into the
3849 // name.
3850 if (Name == "apcs-gnu") {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003851 setABIAPCS();
3852 return true;
3853 }
3854 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
3855 setABIAAPCS();
3856 return true;
3857 }
3858 return false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00003859 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00003860
Craig Topper3164f332014-03-11 03:39:26 +00003861 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Rafael Espindolad8da90b2014-01-02 13:57:18 +00003862 if (IsAAPCS)
3863 Features["aapcs"] = true;
3864 else
3865 Features["apcs"] = true;
3866
Silviu Barangae5690462013-10-21 10:59:33 +00003867 StringRef ArchName = getTriple().getArchName();
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003868 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
3869 Features["vfp2"] = true;
Renato Golineefb5772013-09-13 17:02:45 +00003870 else if (CPU == "cortex-a8" || CPU == "cortex-a9" ||
3871 CPU == "cortex-a9-mp") {
3872 Features["vfp3"] = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003873 Features["neon"] = true;
Silviu Barangae5690462013-10-21 10:59:33 +00003874 }
3875 else if (CPU == "cortex-a5") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003876 Features["vfp4"] = true;
3877 Features["neon"] = true;
Ana Pazosdd6068d2013-12-06 22:43:17 +00003878 } else if (CPU == "swift" || CPU == "cortex-a7" ||
3879 CPU == "cortex-a12" || CPU == "cortex-a15" ||
Renato Golin5886bc32014-10-13 10:22:48 +00003880 CPU == "cortex-a17" || CPU == "krait") {
Silviu Barangae5690462013-10-21 10:59:33 +00003881 Features["vfp4"] = true;
3882 Features["neon"] = true;
3883 Features["hwdiv"] = true;
3884 Features["hwdiv-arm"] = true;
Tim Northovera2ee4332014-03-29 15:09:45 +00003885 } else if (CPU == "cyclone") {
3886 Features["v8fp"] = true;
3887 Features["neon"] = true;
3888 Features["hwdiv"] = true;
3889 Features["hwdiv-arm"] = true;
Bernard Ogdenda13af32013-10-24 18:32:51 +00003890 } else if (CPU == "cortex-a53" || CPU == "cortex-a57") {
3891 Features["fp-armv8"] = true;
3892 Features["neon"] = true;
3893 Features["hwdiv"] = true;
3894 Features["hwdiv-arm"] = true;
Bernard Ogden18b57012013-10-29 09:47:51 +00003895 Features["crc"] = true;
Tim Northover02e38602014-02-03 17:28:04 +00003896 Features["crypto"] = true;
Artyom Skrobove72a6f72014-01-29 09:43:07 +00003897 } else if (CPU == "cortex-r5" ||
Silviu Barangae5690462013-10-21 10:59:33 +00003898 // Enable the hwdiv extension for all v8a AArch32 cores by
3899 // default.
3900 ArchName == "armv8a" || ArchName == "armv8" ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003901 ArchName == "armebv8a" || ArchName == "armebv8" ||
3902 ArchName == "thumbv8a" || ArchName == "thumbv8" ||
3903 ArchName == "thumbebv8a" || ArchName == "thumbebv8") {
Silviu Barangae5690462013-10-21 10:59:33 +00003904 Features["hwdiv"] = true;
3905 Features["hwdiv-arm"] = true;
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00003906 } else if (CPU == "cortex-m3" || CPU == "cortex-m4" || CPU == "cortex-m7") {
Artyom Skrobove72a6f72014-01-29 09:43:07 +00003907 Features["hwdiv"] = true;
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003908 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003909 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003910
Craig Topper3164f332014-03-11 03:39:26 +00003911 bool handleTargetFeatures(std::vector<std::string> &Features,
3912 DiagnosticsEngine &Diags) override {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003913 FPU = 0;
Bernard Ogden18b57012013-10-29 09:47:51 +00003914 CRC = 0;
Tim Northover02e38602014-02-03 17:28:04 +00003915 Crypto = 0;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003916 SoftFloat = SoftFloatABI = false;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003917 HWDiv = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00003918
3919 for (const auto &Feature : Features) {
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003920 if (Feature == "+soft-float") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00003921 SoftFloat = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003922 } else if (Feature == "+soft-float-abi") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00003923 SoftFloatABI = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003924 } else if (Feature == "+vfp2") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003925 FPU |= VFP2FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003926 HW_FP = HW_FP_SP | HW_FP_DP;
3927 } else if (Feature == "+vfp3") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003928 FPU |= VFP3FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003929 HW_FP = HW_FP_SP | HW_FP_DP;
3930 } else if (Feature == "+vfp4") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003931 FPU |= VFP4FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003932 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3933 } else if (Feature == "+fp-armv8") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00003934 FPU |= FPARMV8;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003935 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
3936 } else if (Feature == "+neon") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003937 FPU |= NeonFPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003938 HW_FP = HW_FP_SP | HW_FP_DP;
3939 } else if (Feature == "+hwdiv") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003940 HWDiv |= HWDivThumb;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003941 } else if (Feature == "+hwdiv-arm") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003942 HWDiv |= HWDivARM;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003943 } else if (Feature == "+crc") {
Bernard Ogden18b57012013-10-29 09:47:51 +00003944 CRC = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003945 } else if (Feature == "+crypto") {
Tim Northover02e38602014-02-03 17:28:04 +00003946 Crypto = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003947 } else if (Feature == "+fp-only-sp") {
3948 HW_FP &= ~HW_FP_DP;
3949 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00003950 }
3951
Rafael Espindolaeb265472013-08-21 21:59:03 +00003952 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
3953 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
3954 return false;
3955 }
3956
3957 if (FPMath == FP_Neon)
3958 Features.push_back("+neonfp");
3959 else if (FPMath == FP_VFP)
3960 Features.push_back("-neonfp");
3961
Daniel Dunbar893d4752009-12-19 04:15:38 +00003962 // Remove front-end specific options which the backend handles differently.
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00003963 const StringRef FrontEndFeatures[] = { "+soft-float", "+soft-float-abi" };
3964 for (const auto &FEFeature : FrontEndFeatures) {
3965 auto Feature = std::find(Features.begin(), Features.end(), FEFeature);
3966 if (Feature != Features.end())
3967 Features.erase(Feature);
3968 }
3969
Rafael Espindolaeb265472013-08-21 21:59:03 +00003970 return true;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003971 }
3972
Craig Topper3164f332014-03-11 03:39:26 +00003973 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003974 return llvm::StringSwitch<bool>(Feature)
3975 .Case("arm", true)
3976 .Case("softfloat", SoftFloat)
3977 .Case("thumb", IsThumb)
Amara Emerson8c3de542013-09-16 18:07:35 +00003978 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003979 .Case("hwdiv", HWDiv & HWDivThumb)
3980 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003981 .Default(false);
3982 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00003983 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003984 static const char *getCPUDefineSuffix(StringRef Name) {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003985 return llvm::StringSwitch<const char*>(Name)
3986 .Cases("arm8", "arm810", "4")
3987 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110", "4")
3988 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
3989 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
3990 .Case("ep9312", "4T")
3991 .Cases("arm10tdmi", "arm1020t", "5T")
3992 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
3993 .Case("arm926ej-s", "5TEJ")
3994 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
3995 .Cases("xscale", "iwmmxt", "5TE")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003996 .Case("arm1136j-s", "6J")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003997 .Cases("arm1176jz-s", "arm1176jzf-s", "6ZK")
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003998 .Cases("arm1136jf-s", "mpcorenovfp", "mpcore", "6K")
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003999 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
Bob Wilsonb767d152014-01-15 21:43:40 +00004000 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "cortex-a9-mp", "7A")
Renato Golin5886bc32014-10-13 10:22:48 +00004001 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "7A")
Renato Golin1a04f222013-09-13 17:02:54 +00004002 .Cases("cortex-r4", "cortex-r5", "7R")
Bob Wilsond7cf1042012-09-29 23:52:50 +00004003 .Case("swift", "7S")
Tim Northovera2ee4332014-03-29 15:09:45 +00004004 .Case("cyclone", "8A")
Jim Grosbachbe83cb82014-06-26 17:24:16 +00004005 .Case("cortex-m3", "7M")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00004006 .Cases("cortex-m4", "cortex-m7", "7EM")
Bob Wilson87ba1d32011-03-21 21:55:25 +00004007 .Case("cortex-m0", "6M")
Bernard Ogden021d7da2013-10-24 18:32:36 +00004008 .Cases("cortex-a53", "cortex-a57", "8A")
Craig Topperf1186c52014-05-08 06:41:40 +00004009 .Default(nullptr);
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004010 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004011 static const char *getCPUProfile(StringRef Name) {
4012 return llvm::StringSwitch<const char*>(Name)
Renato Golin1a04f222013-09-13 17:02:54 +00004013 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "A")
Renato Golin5886bc32014-10-13 10:22:48 +00004014 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait", "A")
Bernard Ogden021d7da2013-10-24 18:32:36 +00004015 .Cases("cortex-a53", "cortex-a57", "A")
Oliver Stannardbfd3ea32014-10-01 09:03:02 +00004016 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "cortex-m7", "M")
Renato Golin1a04f222013-09-13 17:02:54 +00004017 .Cases("cortex-r4", "cortex-r5", "R")
Anton Korobeynikov26b13882012-09-08 08:22:13 +00004018 .Default("");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004019 }
Craig Topper3164f332014-03-11 03:39:26 +00004020 bool setCPU(const std::string &Name) override {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004021 if (!getCPUDefineSuffix(Name))
4022 return false;
4023
Tim Northovere8c37212014-07-09 09:24:43 +00004024 // Cortex M does not support 8 byte atomics, while general Thumb2 does.
4025 StringRef Profile = getCPUProfile(Name);
4026 if (Profile == "M" && MaxAtomicInlineWidth) {
4027 MaxAtomicPromoteWidth = 32;
4028 MaxAtomicInlineWidth = 32;
4029 }
4030
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004031 CPU = Name;
4032 return true;
4033 }
Craig Topper3164f332014-03-11 03:39:26 +00004034 bool setFPMath(StringRef Name) override;
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004035 bool supportsThumb(StringRef ArchName, StringRef CPUArch,
4036 unsigned CPUArchVer) const {
4037 return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) ||
4038 (CPUArch.find('M') != StringRef::npos);
4039 }
4040 bool supportsThumb2(StringRef ArchName, StringRef CPUArch,
4041 unsigned CPUArchVer) const {
4042 // We check both CPUArchVer and ArchName because when only triple is
4043 // specified, the default CPU is arm1136j-s.
4044 return ArchName.endswith("v6t2") || ArchName.endswith("v7") ||
4045 ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7;
4046 }
Craig Topper3164f332014-03-11 03:39:26 +00004047 void getTargetDefines(const LangOptions &Opts,
4048 MacroBuilder &Builder) const override {
Chris Lattnerecd49032009-03-02 22:27:17 +00004049 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004050 Builder.defineMacro("__arm");
4051 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00004052
Chris Lattnerecd49032009-03-02 22:27:17 +00004053 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004054 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004055
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004056 StringRef CPUArch = getCPUDefineSuffix(CPU);
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004057 unsigned int CPUArchVer;
Saleem Abdulrasool820e9272014-09-17 14:50:19 +00004058 if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer))
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004059 llvm_unreachable("Invalid char for architecture version number");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004060 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004061
4062 // ACLE 6.4.1 ARM/Thumb instruction set architecture
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004063 StringRef CPUProfile = getCPUProfile(CPU);
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004064 StringRef ArchName = getTriple().getArchName();
4065
4066 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
4067 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
James Molloy0ffb0932014-09-15 11:25:38 +00004068 if (CPUArch[0] >= '8') {
4069 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4070 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
4071 }
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004072
4073 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It
4074 // is not defined for the M-profile.
4075 // NOTE that the deffault profile is assumed to be 'A'
4076 if (CPUProfile.empty() || CPUProfile != "M")
4077 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
4078
4079 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original
4080 // Thumb ISA (including v6-M). It is set to 2 if the core supports the
4081 // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture.
4082 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
4083 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
4084 else if (supportsThumb(ArchName, CPUArch, CPUArchVer))
4085 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
4086
4087 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
4088 // instruction set such as ARM or Thumb.
4089 Builder.defineMacro("__ARM_32BIT_STATE", "1");
4090
4091 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
4092
4093 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004094 if (!CPUProfile.empty())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004095 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004096
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004097 // ACLE 6.5.1 Hardware Floating Point
4098 if (HW_FP)
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +00004099 Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004100
Yi Konga44c4d72014-06-27 21:25:42 +00004101 // ACLE predefines.
4102 Builder.defineMacro("__ARM_ACLE", "200");
4103
Mike Stump9d54bd72009-04-08 02:07:04 +00004104 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004105
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004106 // FIXME: It's more complicated than this and we don't really support
4107 // interworking.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004108 // Windows on ARM does not "support" interworking
4109 if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004110 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004111
David Tweed8f676532012-10-25 13:33:01 +00004112 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Tim Northovere77f78c2013-11-11 19:11:22 +00004113 // Embedded targets on Darwin follow AAPCS, but not EABI.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004114 // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
4115 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
Daniel Dunbarf7124da2012-10-22 18:51:13 +00004116 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004117 Builder.defineMacro("__ARM_PCS", "1");
4118
David Tweed8f676532012-10-25 13:33:01 +00004119 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004120 Builder.defineMacro("__ARM_PCS_VFP", "1");
4121 }
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004122
Daniel Dunbar893d4752009-12-19 04:15:38 +00004123 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004124 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004125
4126 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004127 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004128
4129 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004130 Builder.defineMacro("__THUMBEL__");
4131 Builder.defineMacro("__thumb__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004132 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004133 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004134 }
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004135 if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb))
4136 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004137
4138 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004139 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004140
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004141 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004142 Builder.defineMacro("__VFP_FP__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004143 if (FPU & VFP2FPU)
4144 Builder.defineMacro("__ARM_VFPV2__");
4145 if (FPU & VFP3FPU)
4146 Builder.defineMacro("__ARM_VFPV3__");
4147 if (FPU & VFP4FPU)
4148 Builder.defineMacro("__ARM_VFPV4__");
4149 }
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004150
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004151 // This only gets set when Neon instructions are actually available, unlike
4152 // the VFP define, hence the soft float and arch check. This is subtly
4153 // different from gcc, we follow the intent which was that it should be set
4154 // when Neon instructions are actually available.
Tim Northover5bb34ca2013-11-21 12:36:34 +00004155 if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) {
4156 Builder.defineMacro("__ARM_NEON");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004157 Builder.defineMacro("__ARM_NEON__");
Tim Northover5bb34ca2013-11-21 12:36:34 +00004158 }
Joey Gouly1e8637b2013-09-18 10:07:09 +00004159
Bradley Smith0f28f0c2014-01-20 10:52:00 +00004160 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
4161 Opts.ShortWChar ? "2" : "4");
4162
4163 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4164 Opts.ShortEnums ? "1" : "4");
4165
Bernard Ogden18b57012013-10-29 09:47:51 +00004166 if (CRC)
Joey Gouly1e8637b2013-09-18 10:07:09 +00004167 Builder.defineMacro("__ARM_FEATURE_CRC32");
Weiming Zhao53a797c2013-09-30 22:51:32 +00004168
Tim Northover02e38602014-02-03 17:28:04 +00004169 if (Crypto)
4170 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
4171
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004172 if (CPUArchVer >= 6 && CPUArch != "6M") {
Weiming Zhao53a797c2013-09-30 22:51:32 +00004173 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4174 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4175 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4176 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4177 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004178 }
Craig Topper3164f332014-03-11 03:39:26 +00004179 void getTargetBuiltins(const Builtin::Info *&Records,
4180 unsigned &NumRecords) const override {
Chris Lattner5cc15e02010-03-03 19:03:45 +00004181 Records = BuiltinInfo;
4182 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00004183 }
Craig Topper3164f332014-03-11 03:39:26 +00004184 bool isCLZForZeroUndef() const override { return false; }
4185 BuiltinVaListKind getBuiltinVaListKind() const override {
Logan Chien57086ce2012-10-10 06:56:20 +00004186 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner17df24e2008-04-21 18:56:49 +00004187 }
Craig Topper3164f332014-03-11 03:39:26 +00004188 void getGCCRegNames(const char * const *&Names,
4189 unsigned &NumNames) const override;
4190 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4191 unsigned &NumAliases) const override;
4192 bool validateAsmConstraint(const char *&Name,
4193 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00004194 switch (*Name) {
Eric Christopher9e491882012-08-16 23:50:41 +00004195 default: break;
Nate Begeman2908fa02008-04-22 05:03:19 +00004196 case 'l': // r0-r7
4197 case 'h': // r8-r15
4198 case 'w': // VFP Floating point register single precision
4199 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00004200 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00004201 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00004202 case 'Q': // A memory address that is a single base register.
4203 Info.setAllowsMemory();
4204 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004205 case 'U': // a memory reference...
4206 switch (Name[1]) {
4207 case 'q': // ...ARMV4 ldrsb
4208 case 'v': // ...VFP load/store (reg+constant offset)
4209 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00004210 case 't': // address valid for load/store opaque types wider
Eric Christopherfd081ca2012-11-14 22:08:59 +00004211 // than 128-bits
Eric Christopherd1048542011-06-17 01:40:49 +00004212 case 'n': // valid address for Neon doubleword vector load/store
4213 case 'm': // valid address for Neon element and structure load/store
4214 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopherfd081ca2012-11-14 22:08:59 +00004215 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004216 Info.setAllowsMemory();
4217 Name++;
4218 return true;
4219 }
Nate Begeman2908fa02008-04-22 05:03:19 +00004220 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004221 return false;
4222 }
Craig Topper3164f332014-03-11 03:39:26 +00004223 std::string convertConstraint(const char *&Constraint) const override {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004224 std::string R;
4225 switch (*Constraint) {
4226 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00004227 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004228 Constraint++;
4229 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00004230 case 'p': // 'p' should be translated to 'r' by default.
4231 R = std::string("r");
4232 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004233 default:
4234 return std::string(1, *Constraint);
4235 }
4236 return R;
4237 }
Akira Hatanaka987f1862014-08-22 06:05:21 +00004238 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004239 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004240 std::string &SuggestedModifier) const override {
Bill Wendling3c6591d2012-11-30 23:18:12 +00004241 bool isOutput = (Constraint[0] == '=');
Bill Wendling05175082012-11-30 23:46:56 +00004242 bool isInOut = (Constraint[0] == '+');
Bill Wendling3c6591d2012-11-30 23:18:12 +00004243
Bill Wendling9d1ee112012-10-25 23:28:48 +00004244 // Strip off constraint modifiers.
4245 while (Constraint[0] == '=' ||
4246 Constraint[0] == '+' ||
4247 Constraint[0] == '&')
4248 Constraint = Constraint.substr(1);
4249
4250 switch (Constraint[0]) {
4251 default: break;
4252 case 'r': {
4253 switch (Modifier) {
4254 default:
Tim Northover8f24b172013-12-08 15:24:55 +00004255 return (isInOut || isOutput || Size <= 64);
Bill Wendling9d1ee112012-10-25 23:28:48 +00004256 case 'q':
4257 // A register of size 32 cannot fit a vector type.
4258 return false;
4259 }
4260 }
4261 }
4262
4263 return true;
4264 }
Craig Topper3164f332014-03-11 03:39:26 +00004265 const char *getClobbers() const override {
Eli Friedmanf05b7722008-08-20 07:44:10 +00004266 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00004267 return "";
4268 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004269
Craig Topper3164f332014-03-11 03:39:26 +00004270 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004271 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4272 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00004273
Craig Topper3164f332014-03-11 03:39:26 +00004274 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00004275 if (RegNo == 0) return 0;
4276 if (RegNo == 1) return 1;
4277 return -1;
4278 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004279};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004280
Rafael Espindolaeb265472013-08-21 21:59:03 +00004281bool ARMTargetInfo::setFPMath(StringRef Name) {
4282 if (Name == "neon") {
4283 FPMath = FP_Neon;
4284 return true;
4285 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
4286 Name == "vfp4") {
4287 FPMath = FP_VFP;
4288 return true;
4289 }
4290 return false;
4291}
4292
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004293const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004294 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004295 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004296 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
4297
4298 // Float registers
4299 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
4300 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
4301 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004302 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004303
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004304 // Double registers
4305 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
4306 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004307 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
4308 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004309
4310 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004311 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
4312 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004313};
4314
4315void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004316 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004317 Names = GCCRegNames;
4318 NumNames = llvm::array_lengthof(GCCRegNames);
4319}
4320
4321const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004322 { { "a1" }, "r0" },
4323 { { "a2" }, "r1" },
4324 { { "a3" }, "r2" },
4325 { { "a4" }, "r3" },
4326 { { "v1" }, "r4" },
4327 { { "v2" }, "r5" },
4328 { { "v3" }, "r6" },
4329 { { "v4" }, "r7" },
4330 { { "v5" }, "r8" },
4331 { { "v6", "rfp" }, "r9" },
4332 { { "sl" }, "r10" },
4333 { { "fp" }, "r11" },
4334 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004335 { { "r13" }, "sp" },
4336 { { "r14" }, "lr" },
4337 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004338 // The S, D and Q registers overlap, but aren't really aliases; we
4339 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004340};
4341
4342void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4343 unsigned &NumAliases) const {
4344 Aliases = GCCRegAliases;
4345 NumAliases = llvm::array_lengthof(GCCRegAliases);
4346}
Chris Lattner5cc15e02010-03-03 19:03:45 +00004347
4348const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004349#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00004350#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004351 ALL_LANGUAGES },
Tim Northovera2ee4332014-03-29 15:09:45 +00004352#include "clang/Basic/BuiltinsNEON.def"
Tim Northoverc322f832014-01-30 14:47:51 +00004353
4354#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Saleem Abdulrasool4bddd9d2014-07-02 17:41:27 +00004355#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) { #ID, TYPE, ATTRS, 0, LANG },
Tim Northoverc322f832014-01-30 14:47:51 +00004356#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4357 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00004358#include "clang/Basic/BuiltinsARM.def"
4359};
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004360
4361class ARMleTargetInfo : public ARMTargetInfo {
4362public:
4363 ARMleTargetInfo(const llvm::Triple &Triple)
4364 : ARMTargetInfo(Triple, false) { }
4365 virtual void getTargetDefines(const LangOptions &Opts,
4366 MacroBuilder &Builder) const {
4367 Builder.defineMacro("__ARMEL__");
4368 ARMTargetInfo::getTargetDefines(Opts, Builder);
4369 }
4370};
4371
4372class ARMbeTargetInfo : public ARMTargetInfo {
4373public:
4374 ARMbeTargetInfo(const llvm::Triple &Triple)
4375 : ARMTargetInfo(Triple, true) { }
4376 virtual void getTargetDefines(const LangOptions &Opts,
4377 MacroBuilder &Builder) const {
4378 Builder.defineMacro("__ARMEB__");
4379 Builder.defineMacro("__ARM_BIG_ENDIAN");
4380 ARMTargetInfo::getTargetDefines(Opts, Builder);
4381 }
4382};
Chris Lattner17df24e2008-04-21 18:56:49 +00004383} // end anonymous namespace.
4384
Eli Friedmanf05b7722008-08-20 07:44:10 +00004385namespace {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004386class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
4387 const llvm::Triple Triple;
4388public:
4389 WindowsARMTargetInfo(const llvm::Triple &Triple)
4390 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
4391 TLSSupported = false;
4392 WCharType = UnsignedShort;
4393 SizeType = UnsignedInt;
4394 UserLabelPrefix = "";
4395 }
4396 void getVisualStudioDefines(const LangOptions &Opts,
4397 MacroBuilder &Builder) const {
4398 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
4399
4400 // FIXME: this is invalid for WindowsCE
4401 Builder.defineMacro("_M_ARM_NT", "1");
4402 Builder.defineMacro("_M_ARMT", "_M_ARM");
4403 Builder.defineMacro("_M_THUMB", "_M_ARM");
4404
4405 assert((Triple.getArch() == llvm::Triple::arm ||
4406 Triple.getArch() == llvm::Triple::thumb) &&
4407 "invalid architecture for Windows ARM target info");
4408 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4409 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
4410
4411 // TODO map the complete set of values
4412 // 31: VFPv3 40: VFPv4
4413 Builder.defineMacro("_M_ARM_FP", "31");
4414 }
Saleem Abdulrasool521cec82014-06-29 23:05:41 +00004415 BuiltinVaListKind getBuiltinVaListKind() const override {
4416 return TargetInfo::CharPtrBuiltinVaList;
4417 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004418};
4419
4420// Windows ARM + Itanium C++ ABI Target
4421class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
4422public:
4423 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple)
4424 : WindowsARMTargetInfo(Triple) {
4425 TheCXXABI.set(TargetCXXABI::GenericARM);
4426 }
4427
4428 void getTargetDefines(const LangOptions &Opts,
4429 MacroBuilder &Builder) const override {
4430 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4431
4432 if (Opts.MSVCCompat)
4433 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4434 }
4435};
4436
4437// Windows ARM, MS (C++) ABI
4438class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
4439public:
4440 MicrosoftARMleTargetInfo(const llvm::Triple &Triple)
4441 : WindowsARMTargetInfo(Triple) {
4442 TheCXXABI.set(TargetCXXABI::Microsoft);
4443 }
4444
4445 void getTargetDefines(const LangOptions &Opts,
4446 MacroBuilder &Builder) const override {
4447 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4448 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4449 }
4450};
4451}
4452
4453
4454namespace {
Mike Stump11289f42009-09-09 15:08:12 +00004455class DarwinARMTargetInfo :
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004456 public DarwinTargetInfo<ARMleTargetInfo> {
Torok Edwinb2b37c62009-06-30 17:10:35 +00004457protected:
Craig Topper3164f332014-03-11 03:39:26 +00004458 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4459 MacroBuilder &Builder) const override {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00004460 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00004461 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004462
Torok Edwinb2b37c62009-06-30 17:10:35 +00004463public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004464 DarwinARMTargetInfo(const llvm::Triple &Triple)
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004465 : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004466 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004467 // iOS always has 64-bit atomic instructions.
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004468 // FIXME: This should be based off of the target features in ARMleTargetInfo.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004469 MaxAtomicInlineWidth = 64;
John McCall359b8852013-01-25 22:30:49 +00004470
4471 // Darwin on iOS uses a variant of the ARM C++ ABI.
4472 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004473 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004474};
4475} // end anonymous namespace.
4476
Tony Linthicum76329bf2011-12-12 21:14:55 +00004477
4478namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00004479class AArch64TargetInfo : public TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004480 virtual void setDescriptionString() = 0;
Tim Northovera2ee4332014-03-29 15:09:45 +00004481 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4482 static const char *const GCCRegNames[];
4483
James Molloy75f5f9e2014-04-16 15:33:48 +00004484 enum FPUModeEnum {
4485 FPUMode,
4486 NeonMode
4487 };
4488
4489 unsigned FPU;
Bradley Smith418c5932014-05-02 15:17:51 +00004490 unsigned CRC;
James Molloy75f5f9e2014-04-16 15:33:48 +00004491 unsigned Crypto;
4492
Tim Northovera2ee4332014-03-29 15:09:45 +00004493 static const Builtin::Info BuiltinInfo[];
4494
4495 std::string ABI;
4496
4497public:
Tim Northover573cbee2014-05-24 12:52:07 +00004498 AArch64TargetInfo(const llvm::Triple &Triple)
Tim Northovera2ee4332014-03-29 15:09:45 +00004499 : TargetInfo(Triple), ABI("aapcs") {
Tim Northover25e8a672014-05-24 12:51:25 +00004500
4501 if (getTriple().getOS() == llvm::Triple::NetBSD) {
4502 WCharType = SignedInt;
4503
4504 // NetBSD apparently prefers consistency across ARM targets to consistency
4505 // across 64-bit targets.
4506 Int64Type = SignedLongLong;
4507 IntMaxType = SignedLongLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004508 } else {
4509 WCharType = UnsignedInt;
4510 Int64Type = SignedLong;
4511 IntMaxType = SignedLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004512 }
4513
Tim Northovera2ee4332014-03-29 15:09:45 +00004514 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00004515 MaxVectorAlign = 128;
4516 RegParmMax = 8;
4517 MaxAtomicInlineWidth = 128;
4518 MaxAtomicPromoteWidth = 128;
4519
4520 LongDoubleWidth = LongDoubleAlign = 128;
4521 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4522
Tim Northovera2ee4332014-03-29 15:09:45 +00004523 // {} in inline assembly are neon specifiers, not assembly variant
4524 // specifiers.
4525 NoAsmVariants = true;
4526
Tim Northover573cbee2014-05-24 12:52:07 +00004527 // AArch64 targets default to using the ARM C++ ABI.
Tim Northovera2ee4332014-03-29 15:09:45 +00004528 TheCXXABI.set(TargetCXXABI::GenericAArch64);
4529 }
4530
Alp Toker4925ba72014-06-07 23:30:42 +00004531 StringRef getABI() const override { return ABI; }
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004532 virtual bool setABI(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004533 if (Name != "aapcs" && Name != "darwinpcs")
4534 return false;
4535
4536 ABI = Name;
4537 return true;
4538 }
4539
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004540 virtual bool setCPU(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004541 bool CPUKnown = llvm::StringSwitch<bool>(Name)
James Molloy5e73df52014-04-16 15:06:20 +00004542 .Case("generic", true)
James Molloyec78aa42014-04-17 12:51:28 +00004543 .Cases("cortex-a53", "cortex-a57", true)
Tim Northovera2ee4332014-03-29 15:09:45 +00004544 .Case("cyclone", true)
4545 .Default(false);
4546 return CPUKnown;
4547 }
4548
4549 virtual void getTargetDefines(const LangOptions &Opts,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004550 MacroBuilder &Builder) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004551 // Target identification.
Tim Northovera2ee4332014-03-29 15:09:45 +00004552 Builder.defineMacro("__aarch64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004553
4554 // Target properties.
4555 Builder.defineMacro("_LP64");
4556 Builder.defineMacro("__LP64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004557
4558 // ACLE predefines. Many can only have one possible value on v8 AArch64.
4559 Builder.defineMacro("__ARM_ACLE", "200");
4560 Builder.defineMacro("__ARM_ARCH", "8");
4561 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
4562
4563 Builder.defineMacro("__ARM_64BIT_STATE");
4564 Builder.defineMacro("__ARM_PCS_AAPCS64");
4565 Builder.defineMacro("__ARM_ARCH_ISA_A64");
4566
4567 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
4568 Builder.defineMacro("__ARM_FEATURE_CLZ");
4569 Builder.defineMacro("__ARM_FEATURE_FMA");
4570 Builder.defineMacro("__ARM_FEATURE_DIV");
James Molloy0ffb0932014-09-15 11:25:38 +00004571 Builder.defineMacro("__ARM_FEATURE_IDIV"); // As specified in ACLE
4572 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility
4573 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4574 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
Tim Northovera2ee4332014-03-29 15:09:45 +00004575
4576 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
4577
4578 // 0xe implies support for half, single and double precision operations.
4579 Builder.defineMacro("__ARM_FP", "0xe");
4580
4581 // PCS specifies this for SysV variants, which is all we support. Other ABIs
4582 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
4583 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
4584
4585 if (Opts.FastMath || Opts.FiniteMathOnly)
4586 Builder.defineMacro("__ARM_FP_FAST");
4587
Richard Smithab506ad2014-10-20 23:26:58 +00004588 if (Opts.C99 && !Opts.Freestanding)
Tim Northovera2ee4332014-03-29 15:09:45 +00004589 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
4590
4591 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
4592
4593 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4594 Opts.ShortEnums ? "1" : "4");
4595
James Molloy75f5f9e2014-04-16 15:33:48 +00004596 if (FPU == NeonMode) {
4597 Builder.defineMacro("__ARM_NEON");
4598 // 64-bit NEON supports half, single and double precision operations.
Bradley Smith9a6b2952014-05-02 15:18:38 +00004599 Builder.defineMacro("__ARM_NEON_FP", "0xe");
James Molloy75f5f9e2014-04-16 15:33:48 +00004600 }
Tim Northovera2ee4332014-03-29 15:09:45 +00004601
Bradley Smith418c5932014-05-02 15:17:51 +00004602 if (CRC)
4603 Builder.defineMacro("__ARM_FEATURE_CRC32");
4604
James Molloy75f5f9e2014-04-16 15:33:48 +00004605 if (Crypto)
4606 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
Tim Northovera2ee4332014-03-29 15:09:45 +00004607 }
4608
4609 virtual void getTargetBuiltins(const Builtin::Info *&Records,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004610 unsigned &NumRecords) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004611 Records = BuiltinInfo;
Tim Northover573cbee2014-05-24 12:52:07 +00004612 NumRecords = clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
Tim Northovera2ee4332014-03-29 15:09:45 +00004613 }
4614
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004615 virtual bool hasFeature(StringRef Feature) const override {
James Molloy75f5f9e2014-04-16 15:33:48 +00004616 return Feature == "aarch64" ||
4617 Feature == "arm64" ||
4618 (Feature == "neon" && FPU == NeonMode);
Tim Northovera2ee4332014-03-29 15:09:45 +00004619 }
4620
James Molloy5e73df52014-04-16 15:06:20 +00004621 bool handleTargetFeatures(std::vector<std::string> &Features,
4622 DiagnosticsEngine &Diags) override {
James Molloy75f5f9e2014-04-16 15:33:48 +00004623 FPU = FPUMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004624 CRC = 0;
James Molloy75f5f9e2014-04-16 15:33:48 +00004625 Crypto = 0;
4626 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
4627 if (Features[i] == "+neon")
4628 FPU = NeonMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004629 if (Features[i] == "+crc")
4630 CRC = 1;
James Molloy75f5f9e2014-04-16 15:33:48 +00004631 if (Features[i] == "+crypto")
4632 Crypto = 1;
4633 }
4634
James Molloy5e73df52014-04-16 15:06:20 +00004635 setDescriptionString();
4636
4637 return true;
4638 }
4639
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004640 virtual bool isCLZForZeroUndef() const override { return false; }
Tim Northovera2ee4332014-03-29 15:09:45 +00004641
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004642 virtual BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004643 return TargetInfo::AArch64ABIBuiltinVaList;
4644 }
4645
4646 virtual void getGCCRegNames(const char *const *&Names,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004647 unsigned &NumNames) const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00004648 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004649 unsigned &NumAliases) const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00004650
4651 virtual bool validateAsmConstraint(const char *&Name,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004652 TargetInfo::ConstraintInfo &Info) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004653 switch (*Name) {
4654 default:
4655 return false;
4656 case 'w': // Floating point and SIMD registers (V0-V31)
4657 Info.setAllowsRegister();
4658 return true;
James Molloy8bdd24b2014-04-23 10:26:19 +00004659 case 'I': // Constant that can be used with an ADD instruction
4660 case 'J': // Constant that can be used with a SUB instruction
4661 case 'K': // Constant that can be used with a 32-bit logical instruction
4662 case 'L': // Constant that can be used with a 64-bit logical instruction
4663 case 'M': // Constant that can be used as a 32-bit MOV immediate
4664 case 'N': // Constant that can be used as a 64-bit MOV immediate
4665 case 'Y': // Floating point constant zero
4666 case 'Z': // Integer constant zero
4667 return true;
4668 case 'Q': // A memory reference with base register and no offset
4669 Info.setAllowsMemory();
4670 return true;
4671 case 'S': // A symbolic address
4672 Info.setAllowsRegister();
4673 return true;
4674 case 'U':
4675 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes, whatever they may be
4676 // Utf: A memory address suitable for ldp/stp in TF mode, whatever it may be
4677 // Usa: An absolute symbolic address
4678 // Ush: The high part (bits 32:12) of a pc-relative symbolic address
4679 llvm_unreachable("FIXME: Unimplemented support for bizarre constraints");
Tim Northovera2ee4332014-03-29 15:09:45 +00004680 case 'z': // Zero register, wzr or xzr
4681 Info.setAllowsRegister();
4682 return true;
4683 case 'x': // Floating point and SIMD registers (V0-V15)
4684 Info.setAllowsRegister();
4685 return true;
Tim Northovera2ee4332014-03-29 15:09:45 +00004686 }
4687 return false;
4688 }
4689
Akira Hatanaka987f1862014-08-22 06:05:21 +00004690 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004691 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004692 std::string &SuggestedModifier) const override {
James Molloy8a157bf2014-07-25 10:19:47 +00004693 // Strip off constraint modifiers.
4694 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
4695 Constraint = Constraint.substr(1);
4696
4697 switch (Constraint[0]) {
4698 default:
4699 return true;
4700 case 'z':
4701 case 'r': {
4702 switch (Modifier) {
4703 case 'x':
4704 case 'w':
4705 // For now assume that the person knows what they're
4706 // doing with the modifier.
4707 return true;
4708 default:
4709 // By default an 'r' constraint will be in the 'x'
4710 // registers.
Akira Hatanaka987f1862014-08-22 06:05:21 +00004711 if (Size == 64)
4712 return true;
4713
4714 SuggestedModifier = "w";
4715 return false;
James Molloy8a157bf2014-07-25 10:19:47 +00004716 }
4717 }
4718 }
4719 }
4720
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004721 virtual const char *getClobbers() const override { return ""; }
Tim Northovera2ee4332014-03-29 15:09:45 +00004722
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004723 int getEHDataRegisterNumber(unsigned RegNo) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004724 if (RegNo == 0)
4725 return 0;
4726 if (RegNo == 1)
4727 return 1;
4728 return -1;
4729 }
4730};
4731
Tim Northover573cbee2014-05-24 12:52:07 +00004732const char *const AArch64TargetInfo::GCCRegNames[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004733 // 32-bit Integer registers
4734 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
4735 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
4736 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
4737
4738 // 64-bit Integer registers
4739 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
4740 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
4741 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
4742
4743 // 32-bit floating point regsisters
4744 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10",
4745 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
4746 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
4747
4748 // 64-bit floating point regsisters
4749 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
4750 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
4751 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
4752
4753 // Vector registers
4754 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10",
4755 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
4756 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
4757};
4758
Tim Northover573cbee2014-05-24 12:52:07 +00004759void AArch64TargetInfo::getGCCRegNames(const char *const *&Names,
Tim Northovera2ee4332014-03-29 15:09:45 +00004760 unsigned &NumNames) const {
4761 Names = GCCRegNames;
4762 NumNames = llvm::array_lengthof(GCCRegNames);
4763}
4764
Tim Northover573cbee2014-05-24 12:52:07 +00004765const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004766 { { "w31" }, "wsp" },
4767 { { "x29" }, "fp" },
4768 { { "x30" }, "lr" },
4769 { { "x31" }, "sp" },
4770 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
4771 // don't want to substitute one of these for a different-sized one.
4772};
4773
Tim Northover573cbee2014-05-24 12:52:07 +00004774void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Tim Northovera2ee4332014-03-29 15:09:45 +00004775 unsigned &NumAliases) const {
4776 Aliases = GCCRegAliases;
4777 NumAliases = llvm::array_lengthof(GCCRegAliases);
4778}
4779
Tim Northover573cbee2014-05-24 12:52:07 +00004780const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004781#define BUILTIN(ID, TYPE, ATTRS) \
4782 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
4783#include "clang/Basic/BuiltinsNEON.def"
4784
4785#define BUILTIN(ID, TYPE, ATTRS) \
4786 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Tim Northover573cbee2014-05-24 12:52:07 +00004787#include "clang/Basic/BuiltinsAArch64.def"
Tim Northovera2ee4332014-03-29 15:09:45 +00004788};
James Molloy5e73df52014-04-16 15:06:20 +00004789
Tim Northover573cbee2014-05-24 12:52:07 +00004790class AArch64leTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004791 void setDescriptionString() override {
4792 if (getTriple().isOSBinFormatMachO())
4793 DescriptionString = "e-m:o-i64:64-i128:128-n32:64-S128";
4794 else
4795 DescriptionString = "e-m:e-i64:64-i128:128-n32:64-S128";
4796 }
4797
4798public:
Tim Northover573cbee2014-05-24 12:52:07 +00004799 AArch64leTargetInfo(const llvm::Triple &Triple)
4800 : AArch64TargetInfo(Triple) {
James Molloy5e73df52014-04-16 15:06:20 +00004801 BigEndian = false;
4802 }
4803 void getTargetDefines(const LangOptions &Opts,
4804 MacroBuilder &Builder) const override {
4805 Builder.defineMacro("__AARCH64EL__");
Tim Northover573cbee2014-05-24 12:52:07 +00004806 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00004807 }
4808};
4809
Tim Northover573cbee2014-05-24 12:52:07 +00004810class AArch64beTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004811 void setDescriptionString() override {
4812 assert(!getTriple().isOSBinFormatMachO());
4813 DescriptionString = "E-m:e-i64:64-i128:128-n32:64-S128";
4814 }
4815
4816public:
Tim Northover573cbee2014-05-24 12:52:07 +00004817 AArch64beTargetInfo(const llvm::Triple &Triple)
4818 : AArch64TargetInfo(Triple) { }
James Molloy5e73df52014-04-16 15:06:20 +00004819 void getTargetDefines(const LangOptions &Opts,
4820 MacroBuilder &Builder) const override {
4821 Builder.defineMacro("__AARCH64EB__");
4822 Builder.defineMacro("__AARCH_BIG_ENDIAN");
4823 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northover573cbee2014-05-24 12:52:07 +00004824 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00004825 }
4826};
Tim Northovera2ee4332014-03-29 15:09:45 +00004827} // end anonymous namespace.
4828
4829namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00004830class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
James Molloy5e73df52014-04-16 15:06:20 +00004831protected:
4832 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4833 MacroBuilder &Builder) const override {
4834 Builder.defineMacro("__AARCH64_SIMD__");
4835 Builder.defineMacro("__ARM64_ARCH_8__");
4836 Builder.defineMacro("__ARM_NEON__");
4837 Builder.defineMacro("__LITTLE_ENDIAN__");
4838 Builder.defineMacro("__REGISTER_PREFIX__", "");
4839 Builder.defineMacro("__arm64", "1");
4840 Builder.defineMacro("__arm64__", "1");
4841
4842 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
4843 }
4844
Tim Northovera2ee4332014-03-29 15:09:45 +00004845public:
Tim Northover573cbee2014-05-24 12:52:07 +00004846 DarwinAArch64TargetInfo(const llvm::Triple &Triple)
4847 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
Tim Northovera2ee4332014-03-29 15:09:45 +00004848 Int64Type = SignedLongLong;
4849 WCharType = SignedInt;
4850 UseSignedCharForObjCBool = false;
4851
4852 LongDoubleWidth = LongDoubleAlign = 64;
4853 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
4854
4855 TheCXXABI.set(TargetCXXABI::iOS64);
4856 }
4857
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004858 virtual BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004859 return TargetInfo::CharPtrBuiltinVaList;
4860 }
4861};
4862} // end anonymous namespace
4863
4864namespace {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004865// Hexagon abstract base class
4866class HexagonTargetInfo : public TargetInfo {
4867 static const Builtin::Info BuiltinInfo[];
4868 static const char * const GCCRegNames[];
4869 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4870 std::string CPU;
4871public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004872 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00004873 BigEndian = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00004874 DescriptionString = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32";
Tony Linthicum76329bf2011-12-12 21:14:55 +00004875
4876 // {} in inline assembly are packet specifiers, not assembly variant
4877 // specifiers.
4878 NoAsmVariants = true;
4879 }
4880
Craig Topper3164f332014-03-11 03:39:26 +00004881 void getTargetBuiltins(const Builtin::Info *&Records,
4882 unsigned &NumRecords) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004883 Records = BuiltinInfo;
4884 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
4885 }
4886
Craig Topper3164f332014-03-11 03:39:26 +00004887 bool validateAsmConstraint(const char *&Name,
4888 TargetInfo::ConstraintInfo &Info) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004889 return true;
4890 }
4891
Craig Topper3164f332014-03-11 03:39:26 +00004892 void getTargetDefines(const LangOptions &Opts,
4893 MacroBuilder &Builder) const override;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004894
Craig Topper3164f332014-03-11 03:39:26 +00004895 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004896 return Feature == "hexagon";
4897 }
Craig Topper3164f332014-03-11 03:39:26 +00004898
4899 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004900 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum76329bf2011-12-12 21:14:55 +00004901 }
Craig Topper3164f332014-03-11 03:39:26 +00004902 void getGCCRegNames(const char * const *&Names,
4903 unsigned &NumNames) const override;
4904 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4905 unsigned &NumAliases) const override;
4906 const char *getClobbers() const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00004907 return "";
4908 }
Sebastian Pop86500282012-01-13 20:37:10 +00004909
4910 static const char *getHexagonCPUSuffix(StringRef Name) {
4911 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop86500282012-01-13 20:37:10 +00004912 .Case("hexagonv4", "4")
Sirish Pande11ebc4e2012-05-10 20:19:54 +00004913 .Case("hexagonv5", "5")
Craig Topperf1186c52014-05-08 06:41:40 +00004914 .Default(nullptr);
Sebastian Pop86500282012-01-13 20:37:10 +00004915 }
4916
Craig Topper3164f332014-03-11 03:39:26 +00004917 bool setCPU(const std::string &Name) override {
Sebastian Pop86500282012-01-13 20:37:10 +00004918 if (!getHexagonCPUSuffix(Name))
4919 return false;
4920
Tony Linthicum76329bf2011-12-12 21:14:55 +00004921 CPU = Name;
4922 return true;
4923 }
4924};
4925
4926void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
4927 MacroBuilder &Builder) const {
4928 Builder.defineMacro("qdsp6");
4929 Builder.defineMacro("__qdsp6", "1");
4930 Builder.defineMacro("__qdsp6__", "1");
4931
4932 Builder.defineMacro("hexagon");
4933 Builder.defineMacro("__hexagon", "1");
4934 Builder.defineMacro("__hexagon__", "1");
4935
4936 if(CPU == "hexagonv1") {
4937 Builder.defineMacro("__HEXAGON_V1__");
4938 Builder.defineMacro("__HEXAGON_ARCH__", "1");
4939 if(Opts.HexagonQdsp6Compat) {
4940 Builder.defineMacro("__QDSP6_V1__");
4941 Builder.defineMacro("__QDSP6_ARCH__", "1");
4942 }
4943 }
4944 else if(CPU == "hexagonv2") {
4945 Builder.defineMacro("__HEXAGON_V2__");
4946 Builder.defineMacro("__HEXAGON_ARCH__", "2");
4947 if(Opts.HexagonQdsp6Compat) {
4948 Builder.defineMacro("__QDSP6_V2__");
4949 Builder.defineMacro("__QDSP6_ARCH__", "2");
4950 }
4951 }
4952 else if(CPU == "hexagonv3") {
4953 Builder.defineMacro("__HEXAGON_V3__");
4954 Builder.defineMacro("__HEXAGON_ARCH__", "3");
4955 if(Opts.HexagonQdsp6Compat) {
4956 Builder.defineMacro("__QDSP6_V3__");
4957 Builder.defineMacro("__QDSP6_ARCH__", "3");
4958 }
4959 }
4960 else if(CPU == "hexagonv4") {
4961 Builder.defineMacro("__HEXAGON_V4__");
4962 Builder.defineMacro("__HEXAGON_ARCH__", "4");
4963 if(Opts.HexagonQdsp6Compat) {
4964 Builder.defineMacro("__QDSP6_V4__");
4965 Builder.defineMacro("__QDSP6_ARCH__", "4");
4966 }
4967 }
Sirish Pande11ebc4e2012-05-10 20:19:54 +00004968 else if(CPU == "hexagonv5") {
4969 Builder.defineMacro("__HEXAGON_V5__");
4970 Builder.defineMacro("__HEXAGON_ARCH__", "5");
4971 if(Opts.HexagonQdsp6Compat) {
4972 Builder.defineMacro("__QDSP6_V5__");
4973 Builder.defineMacro("__QDSP6_ARCH__", "5");
4974 }
4975 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00004976}
4977
4978const char * const HexagonTargetInfo::GCCRegNames[] = {
4979 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
4980 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
4981 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
4982 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
4983 "p0", "p1", "p2", "p3",
4984 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
4985};
4986
4987void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
4988 unsigned &NumNames) const {
4989 Names = GCCRegNames;
4990 NumNames = llvm::array_lengthof(GCCRegNames);
4991}
4992
4993
4994const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
4995 { { "sp" }, "r29" },
4996 { { "fp" }, "r30" },
4997 { { "lr" }, "r31" },
4998 };
4999
5000void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5001 unsigned &NumAliases) const {
5002 Aliases = GCCRegAliases;
5003 NumAliases = llvm::array_lengthof(GCCRegAliases);
5004}
5005
5006
5007const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
5008#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5009#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5010 ALL_LANGUAGES },
5011#include "clang/Basic/BuiltinsHexagon.def"
5012};
5013}
5014
5015
Chris Lattner5ba61f02006-10-14 07:39:34 +00005016namespace {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005017// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
5018class SparcTargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00005019 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5020 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005021 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00005022public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005023 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005024
Craig Topper3164f332014-03-11 03:39:26 +00005025 bool handleTargetFeatures(std::vector<std::string> &Features,
5026 DiagnosticsEngine &Diags) override {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005027 SoftFloat = false;
5028 for (unsigned i = 0, e = Features.size(); i != e; ++i)
5029 if (Features[i] == "+soft-float")
5030 SoftFloat = true;
Rafael Espindolaeb265472013-08-21 21:59:03 +00005031 return true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005032 }
Craig Topper3164f332014-03-11 03:39:26 +00005033 void getTargetDefines(const LangOptions &Opts,
5034 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005035 DefineStd(Builder, "sparc", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005036 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005037
5038 if (SoftFloat)
5039 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00005040 }
Craig Topper3164f332014-03-11 03:39:26 +00005041
5042 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005043 return llvm::StringSwitch<bool>(Feature)
5044 .Case("softfloat", SoftFloat)
5045 .Case("sparc", true)
5046 .Default(false);
5047 }
Craig Topper3164f332014-03-11 03:39:26 +00005048
5049 void getTargetBuiltins(const Builtin::Info *&Records,
5050 unsigned &NumRecords) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005051 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00005052 }
Craig Topper3164f332014-03-11 03:39:26 +00005053 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005054 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif49991682008-02-21 16:29:08 +00005055 }
Craig Topper3164f332014-03-11 03:39:26 +00005056 void getGCCRegNames(const char * const *&Names,
5057 unsigned &NumNames) const override;
5058 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5059 unsigned &NumAliases) const override;
5060 bool validateAsmConstraint(const char *&Name,
5061 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005062 // FIXME: Implement!
5063 return false;
Gabor Greif49991682008-02-21 16:29:08 +00005064 }
Craig Topper3164f332014-03-11 03:39:26 +00005065 const char *getClobbers() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005066 // FIXME: Implement!
5067 return "";
Gabor Greif49991682008-02-21 16:29:08 +00005068 }
5069};
5070
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005071const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattner9b415d62009-01-27 01:58:38 +00005072 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5073 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5074 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5075 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
5076};
5077
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005078void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
5079 unsigned &NumNames) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005080 Names = GCCRegNames;
5081 NumNames = llvm::array_lengthof(GCCRegNames);
5082}
5083
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005084const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00005085 { { "g0" }, "r0" },
5086 { { "g1" }, "r1" },
5087 { { "g2" }, "r2" },
5088 { { "g3" }, "r3" },
5089 { { "g4" }, "r4" },
5090 { { "g5" }, "r5" },
5091 { { "g6" }, "r6" },
5092 { { "g7" }, "r7" },
5093 { { "o0" }, "r8" },
5094 { { "o1" }, "r9" },
5095 { { "o2" }, "r10" },
5096 { { "o3" }, "r11" },
5097 { { "o4" }, "r12" },
5098 { { "o5" }, "r13" },
5099 { { "o6", "sp" }, "r14" },
5100 { { "o7" }, "r15" },
5101 { { "l0" }, "r16" },
5102 { { "l1" }, "r17" },
5103 { { "l2" }, "r18" },
5104 { { "l3" }, "r19" },
5105 { { "l4" }, "r20" },
5106 { { "l5" }, "r21" },
5107 { { "l6" }, "r22" },
5108 { { "l7" }, "r23" },
5109 { { "i0" }, "r24" },
5110 { { "i1" }, "r25" },
5111 { { "i2" }, "r26" },
5112 { { "i3" }, "r27" },
5113 { { "i4" }, "r28" },
5114 { { "i5" }, "r29" },
5115 { { "i6", "fp" }, "r30" },
5116 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00005117};
5118
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005119void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5120 unsigned &NumAliases) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005121 Aliases = GCCRegAliases;
5122 NumAliases = llvm::array_lengthof(GCCRegAliases);
5123}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005124
5125// SPARC v8 is the 32-bit mode selected by Triple::sparc.
5126class SparcV8TargetInfo : public SparcTargetInfo {
5127public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005128 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005129 DescriptionString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64";
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005130 }
5131
Craig Topper3164f332014-03-11 03:39:26 +00005132 void getTargetDefines(const LangOptions &Opts,
5133 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005134 SparcTargetInfo::getTargetDefines(Opts, Builder);
5135 Builder.defineMacro("__sparcv8");
5136 }
5137};
5138
5139// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
5140class SparcV9TargetInfo : public SparcTargetInfo {
5141public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005142 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005143 // FIXME: Support Sparc quad-precision long double?
Rafael Espindolac418ae92014-01-03 19:22:05 +00005144 DescriptionString = "E-m:e-i64:64-n32:64-S128";
Jakob Stoklund Olesen248520b2013-05-15 03:22:33 +00005145 // This is an LP64 platform.
5146 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005147
5148 // OpenBSD uses long long for int64_t and intmax_t.
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005149 if (getTriple().getOS() == llvm::Triple::OpenBSD)
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005150 IntMaxType = SignedLongLong;
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005151 else
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005152 IntMaxType = SignedLong;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005153 Int64Type = IntMaxType;
Jakob Stoklund Olesen497332c2014-01-16 16:43:19 +00005154
5155 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
5156 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
5157 LongDoubleWidth = 128;
5158 LongDoubleAlign = 128;
5159 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Jakob Stoklund Olesen5b630b42014-01-30 04:48:04 +00005160 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005161 }
5162
Craig Topper3164f332014-03-11 03:39:26 +00005163 void getTargetDefines(const LangOptions &Opts,
5164 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005165 SparcTargetInfo::getTargetDefines(Opts, Builder);
5166 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005167 Builder.defineMacro("__arch64__");
Rafael Espindola76483742014-08-14 15:14:51 +00005168 // Solaris doesn't need these variants, but the BSDs do.
5169 if (getTriple().getOS() != llvm::Triple::Solaris) {
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005170 Builder.defineMacro("__sparc64__");
5171 Builder.defineMacro("__sparc_v9__");
5172 Builder.defineMacro("__sparcv9__");
5173 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005174 }
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005175
Craig Topper3164f332014-03-11 03:39:26 +00005176 bool setCPU(const std::string &Name) override {
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005177 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5178 .Case("v9", true)
5179 .Case("ultrasparc", true)
5180 .Case("ultrasparc3", true)
5181 .Case("niagara", true)
5182 .Case("niagara2", true)
5183 .Case("niagara3", true)
5184 .Case("niagara4", true)
5185 .Default(false);
5186
5187 // No need to store the CPU yet. There aren't any CPU-specific
5188 // macros to define.
5189 return CPUKnown;
5190 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005191};
5192
Gabor Greif49991682008-02-21 16:29:08 +00005193} // end anonymous namespace.
5194
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005195namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00005196class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005197public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005198 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
5199 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00005200 SizeType = UnsignedInt;
5201 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005202 }
5203};
5204} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00005205
Chris Lattnerb781dc792008-05-08 05:58:21 +00005206namespace {
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005207class SystemZTargetInfo : public TargetInfo {
5208 static const char *const GCCRegNames[];
Ulrich Weigand47445072013-05-06 16:26:41 +00005209
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005210public:
5211 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5212 TLSSupported = true;
5213 IntWidth = IntAlign = 32;
5214 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
5215 PointerWidth = PointerAlign = 64;
5216 LongDoubleWidth = 128;
5217 LongDoubleAlign = 64;
5218 LongDoubleFormat = &llvm::APFloat::IEEEquad;
5219 MinGlobalAlign = 16;
5220 DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
5221 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5222 }
5223 void getTargetDefines(const LangOptions &Opts,
5224 MacroBuilder &Builder) const override {
5225 Builder.defineMacro("__s390__");
5226 Builder.defineMacro("__s390x__");
5227 Builder.defineMacro("__zarch__");
5228 Builder.defineMacro("__LONG_DOUBLE_128__");
5229 }
5230 void getTargetBuiltins(const Builtin::Info *&Records,
5231 unsigned &NumRecords) const override {
5232 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005233 Records = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005234 NumRecords = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005235 }
5236
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005237 void getGCCRegNames(const char *const *&Names,
5238 unsigned &NumNames) const override;
5239 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5240 unsigned &NumAliases) const override {
5241 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005242 Aliases = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005243 NumAliases = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005244 }
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005245 bool validateAsmConstraint(const char *&Name,
5246 TargetInfo::ConstraintInfo &info) const override;
5247 const char *getClobbers() const override {
5248 // FIXME: Is this really right?
5249 return "";
5250 }
5251 BuiltinVaListKind getBuiltinVaListKind() const override {
5252 return TargetInfo::SystemZBuiltinVaList;
5253 }
5254 bool setCPU(const std::string &Name) override {
5255 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5256 .Case("z10", true)
5257 .Case("z196", true)
5258 .Case("zEC12", true)
5259 .Default(false);
5260
5261 // No need to store the CPU yet. There aren't any CPU-specific
5262 // macros to define.
5263 return CPUKnown;
5264 }
5265};
5266
5267const char *const SystemZTargetInfo::GCCRegNames[] = {
5268 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5269 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5270 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
5271 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
5272};
5273
5274void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
5275 unsigned &NumNames) const {
5276 Names = GCCRegNames;
5277 NumNames = llvm::array_lengthof(GCCRegNames);
5278}
5279
5280bool SystemZTargetInfo::
5281validateAsmConstraint(const char *&Name,
5282 TargetInfo::ConstraintInfo &Info) const {
5283 switch (*Name) {
5284 default:
5285 return false;
5286
5287 case 'a': // Address register
5288 case 'd': // Data register (equivalent to 'r')
5289 case 'f': // Floating-point register
5290 Info.setAllowsRegister();
5291 return true;
5292
5293 case 'I': // Unsigned 8-bit constant
5294 case 'J': // Unsigned 12-bit constant
5295 case 'K': // Signed 16-bit constant
5296 case 'L': // Signed 20-bit displacement (on all targets we support)
5297 case 'M': // 0x7fffffff
5298 return true;
5299
5300 case 'Q': // Memory with base and unsigned 12-bit displacement
5301 case 'R': // Likewise, plus an index
5302 case 'S': // Memory with base and signed 20-bit displacement
5303 case 'T': // Likewise, plus an index
5304 Info.setAllowsMemory();
5305 return true;
5306 }
5307}
Ulrich Weigand47445072013-05-06 16:26:41 +00005308}
5309
5310namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005311 class MSP430TargetInfo : public TargetInfo {
5312 static const char * const GCCRegNames[];
5313 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005314 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005315 BigEndian = false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005316 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00005317 IntWidth = 16; IntAlign = 16;
5318 LongWidth = 32; LongLongWidth = 64;
5319 LongAlign = LongLongAlign = 16;
5320 PointerWidth = 16; PointerAlign = 16;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005321 SuitableAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005322 SizeType = UnsignedInt;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005323 IntMaxType = SignedLongLong;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005324 IntPtrType = SignedInt;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005325 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00005326 SigAtomicType = SignedLong;
Job Noormanac95cd52014-09-30 11:19:13 +00005327 DescriptionString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16";
Craig Topper3164f332014-03-11 03:39:26 +00005328 }
5329 void getTargetDefines(const LangOptions &Opts,
5330 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005331 Builder.defineMacro("MSP430");
5332 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005333 // FIXME: defines for different 'flavours' of MCU
5334 }
Craig Topper3164f332014-03-11 03:39:26 +00005335 void getTargetBuiltins(const Builtin::Info *&Records,
5336 unsigned &NumRecords) const override {
5337 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005338 Records = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005339 NumRecords = 0;
5340 }
Craig Topper3164f332014-03-11 03:39:26 +00005341 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005342 return Feature == "msp430";
5343 }
Craig Topper3164f332014-03-11 03:39:26 +00005344 void getGCCRegNames(const char * const *&Names,
5345 unsigned &NumNames) const override;
5346 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5347 unsigned &NumAliases) const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005348 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005349 Aliases = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005350 NumAliases = 0;
5351 }
Craig Topper3164f332014-03-11 03:39:26 +00005352 bool validateAsmConstraint(const char *&Name,
5353 TargetInfo::ConstraintInfo &info) const override {
Anton Korobeynikov051913b2009-10-15 23:17:13 +00005354 // No target constraints for now.
5355 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005356 }
Craig Topper3164f332014-03-11 03:39:26 +00005357 const char *getClobbers() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005358 // FIXME: Is this really right?
5359 return "";
5360 }
Craig Topper3164f332014-03-11 03:39:26 +00005361 BuiltinVaListKind getBuiltinVaListKind() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005362 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00005363 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005364 }
5365 };
5366
5367 const char * const MSP430TargetInfo::GCCRegNames[] = {
5368 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5369 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
5370 };
5371
5372 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
5373 unsigned &NumNames) const {
5374 Names = GCCRegNames;
5375 NumNames = llvm::array_lengthof(GCCRegNames);
5376 }
5377}
5378
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00005379namespace {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005380
Mike Stump11289f42009-09-09 15:08:12 +00005381 // LLVM and Clang cannot be used directly to output native binaries for
5382 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00005383 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00005384 //
5385 // TCE uses the llvm bitcode as input and uses it for generating customized
5386 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00005387 // publicly available in http://tce.cs.tut.fi
5388
Eli Friedman1f191002011-10-07 19:51:42 +00005389 static const unsigned TCEOpenCLAddrSpaceMap[] = {
5390 3, // opencl_global
5391 4, // opencl_local
Peter Collingbournef44bdf92012-05-20 21:08:35 +00005392 5, // opencl_constant
5393 0, // cuda_device
5394 0, // cuda_constant
5395 0 // cuda_shared
Eli Friedman1f191002011-10-07 19:51:42 +00005396 };
5397
Eli Friedmana9c3d712009-08-19 20:47:07 +00005398 class TCETargetInfo : public TargetInfo{
5399 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005400 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005401 TLSSupported = false;
5402 IntWidth = 32;
5403 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005404 PointerWidth = 32;
5405 IntAlign = 32;
5406 LongAlign = LongLongAlign = 32;
5407 PointerAlign = 32;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005408 SuitableAlign = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005409 SizeType = UnsignedInt;
5410 IntMaxType = SignedLong;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005411 IntPtrType = SignedInt;
5412 PtrDiffType = SignedInt;
5413 FloatWidth = 32;
5414 FloatAlign = 32;
5415 DoubleWidth = 32;
5416 DoubleAlign = 32;
5417 LongDoubleWidth = 32;
5418 LongDoubleAlign = 32;
5419 FloatFormat = &llvm::APFloat::IEEEsingle;
5420 DoubleFormat = &llvm::APFloat::IEEEsingle;
5421 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Rafael Espindola29db13a2014-01-03 18:13:17 +00005422 DescriptionString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
5423 "-f64:32-v64:32-v128:32-a:0:32-n32";
Eli Friedman1f191002011-10-07 19:51:42 +00005424 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00005425 UseAddrSpaceMapMangling = true;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005426 }
5427
Craig Topper3164f332014-03-11 03:39:26 +00005428 void getTargetDefines(const LangOptions &Opts,
5429 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005430 DefineStd(Builder, "tce", Opts);
5431 Builder.defineMacro("__TCE__");
5432 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00005433 }
Craig Topper3164f332014-03-11 03:39:26 +00005434 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005435 return Feature == "tce";
5436 }
Craig Topper3164f332014-03-11 03:39:26 +00005437
5438 void getTargetBuiltins(const Builtin::Info *&Records,
5439 unsigned &NumRecords) const override {}
5440 const char *getClobbers() const override {
Daniel Dunbar576d90d2009-08-24 09:54:37 +00005441 return "";
5442 }
Craig Topper3164f332014-03-11 03:39:26 +00005443 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005444 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005445 }
Craig Topper3164f332014-03-11 03:39:26 +00005446 void getGCCRegNames(const char * const *&Names,
5447 unsigned &NumNames) const override {}
5448 bool validateAsmConstraint(const char *&Name,
5449 TargetInfo::ConstraintInfo &info) const override{
Eli Friedmana9c3d712009-08-19 20:47:07 +00005450 return true;
5451 }
Craig Topper3164f332014-03-11 03:39:26 +00005452 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5453 unsigned &NumAliases) const override {}
Eli Friedmana9c3d712009-08-19 20:47:07 +00005454 };
5455}
5456
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005457namespace {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005458class MipsTargetInfoBase : public TargetInfo {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005459 virtual void setDescriptionString() = 0;
5460
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005461 static const Builtin::Info BuiltinInfo[];
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005462 std::string CPU;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005463 bool IsMips16;
Simon Atanasyan60777612013-04-14 14:07:51 +00005464 bool IsMicromips;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005465 bool IsNan2008;
Simon Atanasyan16071912013-04-14 14:07:30 +00005466 bool IsSingleFloat;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005467 enum MipsFloatABI {
Simon Atanasyan16071912013-04-14 14:07:30 +00005468 HardFloat, SoftFloat
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005469 } FloatABI;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005470 enum DspRevEnum {
5471 NoDSP, DSP1, DSP2
5472 } DspRev;
Jack Carter44ff1e52013-08-12 17:20:29 +00005473 bool HasMSA;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005474
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005475protected:
Akira Hatanaka618b2982013-10-29 19:00:35 +00005476 bool HasFP64;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005477 std::string ABI;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005478
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005479public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005480 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
5481 const std::string &CPUStr)
5482 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005483 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005484 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {}
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005485
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005486 bool isNaN2008Default() const {
5487 return CPU == "mips32r6" || CPU == "mips64r6";
5488 }
5489
5490 bool isFP64Default() const {
5491 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
5492 }
5493
Alp Toker4925ba72014-06-07 23:30:42 +00005494 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00005495 bool setCPU(const std::string &Name) override {
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005496 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
5497 getTriple().getArch() == llvm::Triple::mipsel;
Eric Christopher0b26a612010-03-02 02:41:08 +00005498 CPU = Name;
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005499 return llvm::StringSwitch<bool>(Name)
Simon Atanasyan26610c52014-07-04 12:36:56 +00005500 .Case("mips1", IsMips32)
5501 .Case("mips2", IsMips32)
5502 .Case("mips3", true)
5503 .Case("mips4", true)
5504 .Case("mips5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005505 .Case("mips32", IsMips32)
5506 .Case("mips32r2", IsMips32)
5507 .Case("mips32r6", IsMips32)
5508 .Case("mips64", true)
5509 .Case("mips64r2", true)
5510 .Case("mips64r6", true)
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005511 .Case("octeon", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005512 .Default(false);
Eric Christopher0b26a612010-03-02 02:41:08 +00005513 }
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005514 const std::string& getCPU() const { return CPU; }
Craig Topper3164f332014-03-11 03:39:26 +00005515 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Daniel Sanders5a1449d2014-02-20 14:58:19 +00005516 // The backend enables certain ABI's by default according to the
5517 // architecture.
5518 // Disable both possible defaults so that we don't end up with multiple
5519 // ABI's selected and trigger an assertion.
5520 Features["o32"] = false;
5521 Features["n64"] = false;
5522
Eric Christopher0b26a612010-03-02 02:41:08 +00005523 Features[ABI] = true;
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005524 if (CPU == "octeon")
5525 Features["mips64r2"] = Features["cnmips"] = true;
5526 else
5527 Features[CPU] = true;
Eric Christopher0b26a612010-03-02 02:41:08 +00005528 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005529
Craig Topper3164f332014-03-11 03:39:26 +00005530 void getTargetDefines(const LangOptions &Opts,
5531 MacroBuilder &Builder) const override {
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005532 Builder.defineMacro("__mips__");
Simon Atanasyan683535b2012-08-29 19:14:58 +00005533 Builder.defineMacro("_mips");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005534 if (Opts.GNUMode)
5535 Builder.defineMacro("mips");
5536
Simon Atanasyan683535b2012-08-29 19:14:58 +00005537 Builder.defineMacro("__REGISTER_PREFIX__", "");
5538
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005539 switch (FloatABI) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005540 case HardFloat:
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005541 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005542 break;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005543 case SoftFloat:
5544 Builder.defineMacro("__mips_soft_float", Twine(1));
5545 break;
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005546 }
Simon Atanasyan26f19672012-04-05 19:28:31 +00005547
Simon Atanasyan16071912013-04-14 14:07:30 +00005548 if (IsSingleFloat)
5549 Builder.defineMacro("__mips_single_float", Twine(1));
5550
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005551 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
5552 Builder.defineMacro("_MIPS_FPSET",
5553 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
5554
Simon Atanasyan72244b62012-07-05 16:06:06 +00005555 if (IsMips16)
5556 Builder.defineMacro("__mips16", Twine(1));
5557
Simon Atanasyan60777612013-04-14 14:07:51 +00005558 if (IsMicromips)
5559 Builder.defineMacro("__mips_micromips", Twine(1));
5560
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005561 if (IsNan2008)
5562 Builder.defineMacro("__mips_nan2008", Twine(1));
5563
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005564 switch (DspRev) {
5565 default:
5566 break;
5567 case DSP1:
5568 Builder.defineMacro("__mips_dsp_rev", Twine(1));
5569 Builder.defineMacro("__mips_dsp", Twine(1));
5570 break;
5571 case DSP2:
5572 Builder.defineMacro("__mips_dsp_rev", Twine(2));
5573 Builder.defineMacro("__mips_dspr2", Twine(1));
5574 Builder.defineMacro("__mips_dsp", Twine(1));
5575 break;
5576 }
5577
Jack Carter44ff1e52013-08-12 17:20:29 +00005578 if (HasMSA)
5579 Builder.defineMacro("__mips_msa", Twine(1));
5580
Simon Atanasyan26f19672012-04-05 19:28:31 +00005581 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
5582 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
5583 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan5a0642f2012-08-29 15:17:29 +00005584
5585 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
5586 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005587 }
5588
Craig Topper3164f332014-03-11 03:39:26 +00005589 void getTargetBuiltins(const Builtin::Info *&Records,
5590 unsigned &NumRecords) const override {
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005591 Records = BuiltinInfo;
5592 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005593 }
Craig Topper3164f332014-03-11 03:39:26 +00005594 bool hasFeature(StringRef Feature) const override {
Akira Hatanaka618b2982013-10-29 19:00:35 +00005595 return llvm::StringSwitch<bool>(Feature)
5596 .Case("mips", true)
5597 .Case("fp64", HasFP64)
5598 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005599 }
Craig Topper3164f332014-03-11 03:39:26 +00005600 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005601 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005602 }
Craig Topper3164f332014-03-11 03:39:26 +00005603 void getGCCRegNames(const char * const *&Names,
5604 unsigned &NumNames) const override {
Daniel Sanders8b59af12013-11-12 12:56:01 +00005605 static const char *const GCCRegNames[] = {
Eric Christopher8b6d0512012-03-27 19:56:11 +00005606 // CPU register names
5607 // Must match second column of GCCRegAliases
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005608 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
5609 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
5610 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005611 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
5612 // Floating point register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005613 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
5614 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
5615 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
5616 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005617 // Hi/lo and condition register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005618 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
Daniel Sanders8b59af12013-11-12 12:56:01 +00005619 "$fcc5","$fcc6","$fcc7",
5620 // MSA register names
5621 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7",
5622 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
5623 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
5624 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
5625 // MSA control register names
5626 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
5627 "$msarequest", "$msamap", "$msaunmap"
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005628 };
5629 Names = GCCRegNames;
5630 NumNames = llvm::array_lengthof(GCCRegNames);
5631 }
Craig Topper3164f332014-03-11 03:39:26 +00005632 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5633 unsigned &NumAliases) const override = 0;
5634 bool validateAsmConstraint(const char *&Name,
5635 TargetInfo::ConstraintInfo &Info) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005636 switch (*Name) {
5637 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00005638 return false;
5639
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005640 case 'r': // CPU registers.
5641 case 'd': // Equivalent to "r" unless generating MIPS16 code.
Alp Toker958027b2014-07-14 19:42:55 +00005642 case 'y': // Equivalent to "r", backward compatibility only.
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005643 case 'f': // floating-point registers.
Eric Christopherb7e28cc2012-04-03 01:16:32 +00005644 case 'c': // $25 for indirect jumps
5645 case 'l': // lo register
5646 case 'x': // hilo register pair
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005647 Info.setAllowsRegister();
5648 return true;
Jack Carterbeaccdd2013-03-05 19:10:54 +00005649 case 'R': // An address that can be used in a non-macro load or store
Jack Carter427b4042013-03-04 21:36:11 +00005650 Info.setAllowsMemory();
5651 return true;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005652 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005653 }
5654
Craig Topper3164f332014-03-11 03:39:26 +00005655 const char *getClobbers() const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005656 // FIXME: Implement!
5657 return "";
5658 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005659
Craig Topper3164f332014-03-11 03:39:26 +00005660 bool handleTargetFeatures(std::vector<std::string> &Features,
5661 DiagnosticsEngine &Diags) override {
Simon Atanasyan72244b62012-07-05 16:06:06 +00005662 IsMips16 = false;
Simon Atanasyan60777612013-04-14 14:07:51 +00005663 IsMicromips = false;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005664 IsNan2008 = isNaN2008Default();
Simon Atanasyan16071912013-04-14 14:07:30 +00005665 IsSingleFloat = false;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005666 FloatABI = HardFloat;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005667 DspRev = NoDSP;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005668 HasFP64 = isFP64Default();
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005669
5670 for (std::vector<std::string>::iterator it = Features.begin(),
5671 ie = Features.end(); it != ie; ++it) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005672 if (*it == "+single-float")
Simon Atanasyan16071912013-04-14 14:07:30 +00005673 IsSingleFloat = true;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005674 else if (*it == "+soft-float")
5675 FloatABI = SoftFloat;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005676 else if (*it == "+mips16")
5677 IsMips16 = true;
Simon Atanasyan60777612013-04-14 14:07:51 +00005678 else if (*it == "+micromips")
5679 IsMicromips = true;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005680 else if (*it == "+dsp")
5681 DspRev = std::max(DspRev, DSP1);
5682 else if (*it == "+dspr2")
5683 DspRev = std::max(DspRev, DSP2);
Jack Carter44ff1e52013-08-12 17:20:29 +00005684 else if (*it == "+msa")
5685 HasMSA = true;
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005686 else if (*it == "+fp64")
5687 HasFP64 = true;
5688 else if (*it == "-fp64")
5689 HasFP64 = false;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005690 else if (*it == "+nan2008")
5691 IsNan2008 = true;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005692 else if (*it == "-nan2008")
5693 IsNan2008 = false;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005694 }
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005695
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005696 // Remove front-end specific options.
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005697 std::vector<std::string>::iterator it =
5698 std::find(Features.begin(), Features.end(), "+soft-float");
5699 if (it != Features.end())
5700 Features.erase(it);
Rafael Espindolaeb265472013-08-21 21:59:03 +00005701
Akira Hatanaka9064e362013-10-29 18:30:33 +00005702 setDescriptionString();
5703
Rafael Espindolaeb265472013-08-21 21:59:03 +00005704 return true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005705 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00005706
Craig Topper3164f332014-03-11 03:39:26 +00005707 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00005708 if (RegNo == 0) return 4;
5709 if (RegNo == 1) return 5;
5710 return -1;
5711 }
Daniel Sanderscfbb71d2014-07-09 13:43:19 +00005712
5713 bool isCLZForZeroUndef() const override { return false; }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005714};
5715
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005716const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
5717#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5718#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5719 ALL_LANGUAGES },
5720#include "clang/Basic/BuiltinsMips.def"
5721};
5722
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005723class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005724public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005725 Mips32TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00005726 : MipsTargetInfoBase(Triple, "o32", "mips32r2") {
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00005727 SizeType = UnsignedInt;
5728 PtrDiffType = SignedInt;
Akira Hatanakab2206e72013-01-18 21:58:11 +00005729 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00005730 }
Craig Topper3164f332014-03-11 03:39:26 +00005731 bool setABI(const std::string &Name) override {
Simon Atanasyan755d7f92014-06-28 15:56:03 +00005732 if (Name == "o32" || Name == "eabi") {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005733 ABI = Name;
5734 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005735 }
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005736 return false;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005737 }
Craig Topper3164f332014-03-11 03:39:26 +00005738 void getTargetDefines(const LangOptions &Opts,
5739 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005740 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005741
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005742 Builder.defineMacro("__mips", "32");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005743 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
5744
5745 const std::string& CPUStr = getCPU();
5746 if (CPUStr == "mips32")
5747 Builder.defineMacro("__mips_isa_rev", "1");
5748 else if (CPUStr == "mips32r2")
5749 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005750
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005751 if (ABI == "o32") {
5752 Builder.defineMacro("__mips_o32");
5753 Builder.defineMacro("_ABIO32", "1");
5754 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
5755 }
5756 else if (ABI == "eabi")
5757 Builder.defineMacro("__mips_eabi");
5758 else
David Blaikie83d382b2011-09-23 05:06:16 +00005759 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005760 }
Craig Topper3164f332014-03-11 03:39:26 +00005761 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5762 unsigned &NumAliases) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005763 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5764 { { "at" }, "$1" },
5765 { { "v0" }, "$2" },
5766 { { "v1" }, "$3" },
5767 { { "a0" }, "$4" },
5768 { { "a1" }, "$5" },
5769 { { "a2" }, "$6" },
5770 { { "a3" }, "$7" },
5771 { { "t0" }, "$8" },
5772 { { "t1" }, "$9" },
5773 { { "t2" }, "$10" },
5774 { { "t3" }, "$11" },
5775 { { "t4" }, "$12" },
5776 { { "t5" }, "$13" },
5777 { { "t6" }, "$14" },
5778 { { "t7" }, "$15" },
5779 { { "s0" }, "$16" },
5780 { { "s1" }, "$17" },
5781 { { "s2" }, "$18" },
5782 { { "s3" }, "$19" },
5783 { { "s4" }, "$20" },
5784 { { "s5" }, "$21" },
5785 { { "s6" }, "$22" },
5786 { { "s7" }, "$23" },
5787 { { "t8" }, "$24" },
5788 { { "t9" }, "$25" },
5789 { { "k0" }, "$26" },
5790 { { "k1" }, "$27" },
5791 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00005792 { { "sp","$sp" }, "$29" },
5793 { { "fp","$fp" }, "$30" },
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005794 { { "ra" }, "$31" }
5795 };
5796 Aliases = GCCRegAliases;
5797 NumAliases = llvm::array_lengthof(GCCRegAliases);
5798 }
5799};
5800
5801class Mips32EBTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005802 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005803 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005804 }
5805
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005806public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005807 Mips32EBTargetInfo(const llvm::Triple &Triple)
5808 : Mips32TargetInfoBase(Triple) {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005809 }
Craig Topper3164f332014-03-11 03:39:26 +00005810 void getTargetDefines(const LangOptions &Opts,
5811 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005812 DefineStd(Builder, "MIPSEB", Opts);
5813 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005814 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005815 }
5816};
5817
5818class Mips32ELTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005819 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005820 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005821 }
5822
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005823public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005824 Mips32ELTargetInfo(const llvm::Triple &Triple)
5825 : Mips32TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005826 BigEndian = false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005827 }
Craig Topper3164f332014-03-11 03:39:26 +00005828 void getTargetDefines(const LangOptions &Opts,
5829 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005830 DefineStd(Builder, "MIPSEL", Opts);
5831 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005832 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005833 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005834};
Akira Hatanakabef17452011-09-20 19:21:49 +00005835
5836class Mips64TargetInfoBase : public MipsTargetInfoBase {
Akira Hatanakabef17452011-09-20 19:21:49 +00005837public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005838 Mips64TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00005839 : MipsTargetInfoBase(Triple, "n64", "mips64r2") {
Akira Hatanakac12a2712011-10-22 00:07:27 +00005840 LongDoubleWidth = LongDoubleAlign = 128;
5841 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnalla87d8592012-12-08 09:06:08 +00005842 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
5843 LongDoubleWidth = LongDoubleAlign = 64;
5844 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5845 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005846 setN64ABITypes();
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005847 SuitableAlign = 128;
Akira Hatanakab2206e72013-01-18 21:58:11 +00005848 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac12a2712011-10-22 00:07:27 +00005849 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005850
5851 void setN64ABITypes() {
5852 LongWidth = LongAlign = 64;
5853 PointerWidth = PointerAlign = 64;
5854 SizeType = UnsignedLong;
5855 PtrDiffType = SignedLong;
5856 }
5857
5858 void setN32ABITypes() {
5859 LongWidth = LongAlign = 32;
5860 PointerWidth = PointerAlign = 32;
5861 SizeType = UnsignedInt;
5862 PtrDiffType = SignedInt;
5863 }
5864
Craig Topper3164f332014-03-11 03:39:26 +00005865 bool setABI(const std::string &Name) override {
Akira Hatanakac12a2712011-10-22 00:07:27 +00005866 if (Name == "n32") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00005867 setN32ABITypes();
Simon Atanasyan0da400c2013-02-27 14:55:49 +00005868 ABI = Name;
5869 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00005870 }
Simon Atanasyanad805952014-07-01 10:59:09 +00005871 if (Name == "n64") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00005872 setN64ABITypes();
Simon Atanasyanad805952014-07-01 10:59:09 +00005873 ABI = Name;
Simon Atanasyan0da400c2013-02-27 14:55:49 +00005874 return true;
Daniel Sandersff1c0442014-04-24 09:58:52 +00005875 }
5876 return false;
Akira Hatanakabef17452011-09-20 19:21:49 +00005877 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00005878
Craig Topper3164f332014-03-11 03:39:26 +00005879 void getTargetDefines(const LangOptions &Opts,
5880 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005881 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005882
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005883 Builder.defineMacro("__mips", "64");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00005884 Builder.defineMacro("__mips64");
5885 Builder.defineMacro("__mips64__");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005886 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
5887
5888 const std::string& CPUStr = getCPU();
5889 if (CPUStr == "mips64")
5890 Builder.defineMacro("__mips_isa_rev", "1");
5891 else if (CPUStr == "mips64r2")
5892 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00005893
Akira Hatanakabef17452011-09-20 19:21:49 +00005894 if (ABI == "n32") {
5895 Builder.defineMacro("__mips_n32");
5896 Builder.defineMacro("_ABIN32", "2");
5897 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
5898 }
5899 else if (ABI == "n64") {
5900 Builder.defineMacro("__mips_n64");
5901 Builder.defineMacro("_ABI64", "3");
5902 Builder.defineMacro("_MIPS_SIM", "_ABI64");
5903 }
5904 else
David Blaikie83d382b2011-09-23 05:06:16 +00005905 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabef17452011-09-20 19:21:49 +00005906 }
Craig Topper3164f332014-03-11 03:39:26 +00005907 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5908 unsigned &NumAliases) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005909 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
5910 { { "at" }, "$1" },
5911 { { "v0" }, "$2" },
5912 { { "v1" }, "$3" },
5913 { { "a0" }, "$4" },
5914 { { "a1" }, "$5" },
5915 { { "a2" }, "$6" },
5916 { { "a3" }, "$7" },
5917 { { "a4" }, "$8" },
5918 { { "a5" }, "$9" },
5919 { { "a6" }, "$10" },
5920 { { "a7" }, "$11" },
5921 { { "t0" }, "$12" },
5922 { { "t1" }, "$13" },
5923 { { "t2" }, "$14" },
5924 { { "t3" }, "$15" },
5925 { { "s0" }, "$16" },
5926 { { "s1" }, "$17" },
5927 { { "s2" }, "$18" },
5928 { { "s3" }, "$19" },
5929 { { "s4" }, "$20" },
5930 { { "s5" }, "$21" },
5931 { { "s6" }, "$22" },
5932 { { "s7" }, "$23" },
5933 { { "t8" }, "$24" },
5934 { { "t9" }, "$25" },
5935 { { "k0" }, "$26" },
5936 { { "k1" }, "$27" },
5937 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00005938 { { "sp","$sp" }, "$29" },
5939 { { "fp","$fp" }, "$30" },
Akira Hatanakabef17452011-09-20 19:21:49 +00005940 { { "ra" }, "$31" }
5941 };
5942 Aliases = GCCRegAliases;
5943 NumAliases = llvm::array_lengthof(GCCRegAliases);
5944 }
Daniel Sanders81ea6012014-04-24 16:05:26 +00005945
5946 bool hasInt128Type() const override { return true; }
Akira Hatanakabef17452011-09-20 19:21:49 +00005947};
5948
5949class Mips64EBTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005950 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005951 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00005952 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005953 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00005954 DescriptionString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005955
Akira Hatanakabef17452011-09-20 19:21:49 +00005956 }
Akira Hatanaka9064e362013-10-29 18:30:33 +00005957
Akira Hatanakabef17452011-09-20 19:21:49 +00005958public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005959 Mips64EBTargetInfo(const llvm::Triple &Triple)
Akira Hatanaka9064e362013-10-29 18:30:33 +00005960 : Mips64TargetInfoBase(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00005961 void getTargetDefines(const LangOptions &Opts,
5962 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005963 DefineStd(Builder, "MIPSEB", Opts);
5964 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005965 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00005966 }
5967};
5968
5969class Mips64ELTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00005970 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005971 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00005972 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00005973 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00005974 DescriptionString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanakabef17452011-09-20 19:21:49 +00005975 }
5976public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005977 Mips64ELTargetInfo(const llvm::Triple &Triple)
5978 : Mips64TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005979 // Default ABI is n64.
5980 BigEndian = false;
Akira Hatanakabef17452011-09-20 19:21:49 +00005981 }
Craig Topper3164f332014-03-11 03:39:26 +00005982 void getTargetDefines(const LangOptions &Opts,
5983 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00005984 DefineStd(Builder, "MIPSEL", Opts);
5985 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00005986 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00005987 }
5988};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005989} // end anonymous namespace.
5990
Ivan Krasindd7403e2011-08-24 20:22:22 +00005991namespace {
5992class PNaClTargetInfo : public TargetInfo {
5993public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005994 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005995 BigEndian = false;
Ivan Krasindd7403e2011-08-24 20:22:22 +00005996 this->UserLabelPrefix = "";
5997 this->LongAlign = 32;
5998 this->LongWidth = 32;
5999 this->PointerAlign = 32;
6000 this->PointerWidth = 32;
6001 this->IntMaxType = TargetInfo::SignedLongLong;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006002 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00006003 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00006004 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00006005 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00006006 this->SizeType = TargetInfo::UnsignedInt;
6007 this->PtrDiffType = TargetInfo::SignedInt;
6008 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +00006009 this->RegParmMax = 0; // Disallow regparm
Ivan Krasindd7403e2011-08-24 20:22:22 +00006010 }
6011
Craig Topper3164f332014-03-11 03:39:26 +00006012 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006013 }
Craig Toppere6f17d02014-03-11 04:07:52 +00006014 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006015 Builder.defineMacro("__le32__");
6016 Builder.defineMacro("__pnacl__");
6017 }
Craig Topper3164f332014-03-11 03:39:26 +00006018 void getTargetDefines(const LangOptions &Opts,
6019 MacroBuilder &Builder) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006020 getArchDefines(Opts, Builder);
6021 }
Craig Topper3164f332014-03-11 03:39:26 +00006022 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00006023 return Feature == "pnacl";
6024 }
Craig Topper3164f332014-03-11 03:39:26 +00006025 void getTargetBuiltins(const Builtin::Info *&Records,
6026 unsigned &NumRecords) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006027 }
Craig Topper3164f332014-03-11 03:39:26 +00006028 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00006029 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006030 }
Craig Topper3164f332014-03-11 03:39:26 +00006031 void getGCCRegNames(const char * const *&Names,
6032 unsigned &NumNames) const override;
6033 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6034 unsigned &NumAliases) const override;
6035 bool validateAsmConstraint(const char *&Name,
6036 TargetInfo::ConstraintInfo &Info) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006037 return false;
6038 }
6039
Craig Topper3164f332014-03-11 03:39:26 +00006040 const char *getClobbers() const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006041 return "";
6042 }
6043};
6044
6045void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
6046 unsigned &NumNames) const {
Craig Topperf1186c52014-05-08 06:41:40 +00006047 Names = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006048 NumNames = 0;
6049}
6050
6051void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
6052 unsigned &NumAliases) const {
Craig Topperf1186c52014-05-08 06:41:40 +00006053 Aliases = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006054 NumAliases = 0;
6055}
6056} // end anonymous namespace.
6057
Guy Benyeib798fc92012-12-11 21:38:14 +00006058namespace {
JF Bastien643817d2014-09-12 17:52:47 +00006059class Le64TargetInfo : public TargetInfo {
6060 static const Builtin::Info BuiltinInfo[];
6061
6062public:
6063 Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6064 BigEndian = false;
6065 NoAsmVariants = true;
6066 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6067 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6068 DescriptionString =
6069 "e-S128-p:64:64-v16:16-v32:32-v64:64-v96:32-v128:32-m:e-n8:16:32:64";
6070 }
6071
6072 void getTargetDefines(const LangOptions &Opts,
6073 MacroBuilder &Builder) const override {
6074 DefineStd(Builder, "unix", Opts);
6075 defineCPUMacros(Builder, "le64", /*Tuning=*/false);
6076 Builder.defineMacro("__ELF__");
6077 }
6078 void getTargetBuiltins(const Builtin::Info *&Records,
6079 unsigned &NumRecords) const override {
6080 Records = BuiltinInfo;
6081 NumRecords = clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin;
6082 }
6083 BuiltinVaListKind getBuiltinVaListKind() const override {
6084 return TargetInfo::PNaClABIBuiltinVaList;
6085 }
6086 const char *getClobbers() const override { return ""; }
6087 void getGCCRegNames(const char *const *&Names,
6088 unsigned &NumNames) const override {
6089 Names = nullptr;
6090 NumNames = 0;
6091 }
6092 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6093 unsigned &NumAliases) const override {
6094 Aliases = nullptr;
6095 NumAliases = 0;
6096 }
6097 bool validateAsmConstraint(const char *&Name,
6098 TargetInfo::ConstraintInfo &Info) const override {
6099 return false;
6100 }
6101
6102 bool hasProtectedVisibility() const override { return false; }
JF Bastien643817d2014-09-12 17:52:47 +00006103};
6104} // end anonymous namespace.
6105
6106const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
6107#define BUILTIN(ID, TYPE, ATTRS) \
6108 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6109#include "clang/Basic/BuiltinsLe64.def"
6110};
6111
6112namespace {
Guy Benyeib798fc92012-12-11 21:38:14 +00006113 static const unsigned SPIRAddrSpaceMap[] = {
6114 1, // opencl_global
6115 3, // opencl_local
6116 2, // opencl_constant
6117 0, // cuda_device
6118 0, // cuda_constant
6119 0 // cuda_shared
6120 };
6121 class SPIRTargetInfo : public TargetInfo {
Guy Benyeib798fc92012-12-11 21:38:14 +00006122 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006123 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006124 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
6125 "SPIR target must use unknown OS");
6126 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
6127 "SPIR target must use unknown environment type");
6128 BigEndian = false;
6129 TLSSupported = false;
6130 LongWidth = LongAlign = 64;
6131 AddrSpaceMap = &SPIRAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00006132 UseAddrSpaceMapMangling = true;
Guy Benyeib798fc92012-12-11 21:38:14 +00006133 // Define available target features
6134 // These must be defined in sorted order!
6135 NoAsmVariants = true;
6136 }
Craig Topper3164f332014-03-11 03:39:26 +00006137 void getTargetDefines(const LangOptions &Opts,
6138 MacroBuilder &Builder) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006139 DefineStd(Builder, "SPIR", Opts);
6140 }
Craig Topper3164f332014-03-11 03:39:26 +00006141 bool hasFeature(StringRef Feature) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006142 return Feature == "spir";
6143 }
Craig Topper3164f332014-03-11 03:39:26 +00006144
6145 void getTargetBuiltins(const Builtin::Info *&Records,
6146 unsigned &NumRecords) const override {}
6147 const char *getClobbers() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006148 return "";
6149 }
Craig Topper3164f332014-03-11 03:39:26 +00006150 void getGCCRegNames(const char * const *&Names,
6151 unsigned &NumNames) const override {}
6152 bool validateAsmConstraint(const char *&Name,
6153 TargetInfo::ConstraintInfo &info) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006154 return true;
6155 }
Craig Topper3164f332014-03-11 03:39:26 +00006156 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6157 unsigned &NumAliases) const override {}
6158 BuiltinVaListKind getBuiltinVaListKind() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006159 return TargetInfo::VoidPtrBuiltinVaList;
6160 }
6161 };
6162
6163
6164 class SPIR32TargetInfo : public SPIRTargetInfo {
6165 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006166 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006167 PointerWidth = PointerAlign = 32;
6168 SizeType = TargetInfo::UnsignedInt;
6169 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
6170 DescriptionString
Rafael Espindola29db13a2014-01-03 18:13:17 +00006171 = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
6172 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006173 }
Craig Topper3164f332014-03-11 03:39:26 +00006174 void getTargetDefines(const LangOptions &Opts,
6175 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006176 DefineStd(Builder, "SPIR32", Opts);
6177 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006178 };
6179
6180 class SPIR64TargetInfo : public SPIRTargetInfo {
6181 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006182 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006183 PointerWidth = PointerAlign = 64;
6184 SizeType = TargetInfo::UnsignedLong;
6185 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00006186 DescriptionString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-"
6187 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006188 }
Craig Topper3164f332014-03-11 03:39:26 +00006189 void getTargetDefines(const LangOptions &Opts,
6190 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006191 DefineStd(Builder, "SPIR64", Opts);
6192 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006193 };
6194}
6195
Robert Lytton0e076492013-08-13 09:43:10 +00006196namespace {
6197class XCoreTargetInfo : public TargetInfo {
6198 static const Builtin::Info BuiltinInfo[];
6199public:
6200 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6201 BigEndian = false;
6202 NoAsmVariants = true;
6203 LongLongAlign = 32;
6204 SuitableAlign = 32;
6205 DoubleAlign = LongDoubleAlign = 32;
Robert Lyttoncc424662013-11-12 10:09:30 +00006206 SizeType = UnsignedInt;
6207 PtrDiffType = SignedInt;
6208 IntPtrType = SignedInt;
6209 WCharType = UnsignedChar;
6210 WIntType = UnsignedInt;
Robert Lytton0e076492013-08-13 09:43:10 +00006211 UseZeroLengthBitfieldAlignment = true;
Rafael Espindolac418ae92014-01-03 19:22:05 +00006212 DescriptionString = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
Rafael Espindola26c67b72013-12-17 14:34:42 +00006213 "-f64:32-a:0:32-n32";
Robert Lytton0e076492013-08-13 09:43:10 +00006214 }
Craig Topper3164f332014-03-11 03:39:26 +00006215 void getTargetDefines(const LangOptions &Opts,
6216 MacroBuilder &Builder) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006217 Builder.defineMacro("__XS1B__");
6218 }
Craig Topper3164f332014-03-11 03:39:26 +00006219 void getTargetBuiltins(const Builtin::Info *&Records,
6220 unsigned &NumRecords) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006221 Records = BuiltinInfo;
6222 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
6223 }
Craig Topper3164f332014-03-11 03:39:26 +00006224 BuiltinVaListKind getBuiltinVaListKind() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006225 return TargetInfo::VoidPtrBuiltinVaList;
6226 }
Craig Topper3164f332014-03-11 03:39:26 +00006227 const char *getClobbers() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006228 return "";
6229 }
Craig Topper3164f332014-03-11 03:39:26 +00006230 void getGCCRegNames(const char * const *&Names,
6231 unsigned &NumNames) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006232 static const char * const GCCRegNames[] = {
6233 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6234 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
6235 };
6236 Names = GCCRegNames;
6237 NumNames = llvm::array_lengthof(GCCRegNames);
6238 }
Craig Topper3164f332014-03-11 03:39:26 +00006239 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6240 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00006241 Aliases = nullptr;
Robert Lytton0e076492013-08-13 09:43:10 +00006242 NumAliases = 0;
6243 }
Craig Topper3164f332014-03-11 03:39:26 +00006244 bool validateAsmConstraint(const char *&Name,
6245 TargetInfo::ConstraintInfo &Info) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006246 return false;
6247 }
Craig Topper3164f332014-03-11 03:39:26 +00006248 int getEHDataRegisterNumber(unsigned RegNo) const override {
Robert Lytton1a229262014-01-27 17:56:25 +00006249 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
6250 return (RegNo < 2)? RegNo : -1;
6251 }
Robert Lytton0e076492013-08-13 09:43:10 +00006252};
6253
6254const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
6255#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6256#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
6257 ALL_LANGUAGES },
6258#include "clang/Basic/BuiltinsXCore.def"
6259};
6260} // end anonymous namespace.
6261
Ivan Krasindd7403e2011-08-24 20:22:22 +00006262
Chris Lattner5ba61f02006-10-14 07:39:34 +00006263//===----------------------------------------------------------------------===//
6264// Driver code
6265//===----------------------------------------------------------------------===//
6266
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006267static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006268 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00006269
Daniel Dunbar52322032009-08-18 05:47:58 +00006270 switch (Triple.getArch()) {
6271 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006272 return nullptr;
Eli Friedmanb5366062008-05-20 14:21:01 +00006273
Tim Northover2a0783d2014-05-30 14:14:07 +00006274 case llvm::Triple::xcore:
6275 return new XCoreTargetInfo(Triple);
6276
6277 case llvm::Triple::hexagon:
6278 return new HexagonTargetInfo(Triple);
6279
6280 case llvm::Triple::aarch64:
Tim Northovera2ee4332014-03-29 15:09:45 +00006281 if (Triple.isOSDarwin())
Tim Northover573cbee2014-05-24 12:52:07 +00006282 return new DarwinAArch64TargetInfo(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006283
6284 switch (os) {
6285 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006286 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006287 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006288 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006289 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006290 return new AArch64leTargetInfo(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006291 }
6292
Christian Pirker9b019ae2014-02-25 13:51:00 +00006293 case llvm::Triple::aarch64_be:
6294 switch (os) {
6295 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006296 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006297 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006298 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006299 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006300 return new AArch64beTargetInfo(Triple);
Tim Northover9bb857a2013-01-31 12:13:10 +00006301 }
6302
Daniel Dunbar52322032009-08-18 05:47:58 +00006303 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00006304 case llvm::Triple::thumb:
Tim Northover157d9112014-01-16 08:48:16 +00006305 if (Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006306 return new DarwinARMTargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006307
Daniel Dunbar52322032009-08-18 05:47:58 +00006308 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00006309 case llvm::Triple::Linux:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006310 return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006311 case llvm::Triple::FreeBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006312 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006313 case llvm::Triple::NetBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006314 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006315 case llvm::Triple::OpenBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006316 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006317 case llvm::Triple::Bitrig:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006318 return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006319 case llvm::Triple::RTEMS:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006320 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006321 case llvm::Triple::NaCl:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006322 return new NaClTargetInfo<ARMleTargetInfo>(Triple);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006323 case llvm::Triple::Win32:
6324 switch (Triple.getEnvironment()) {
6325 default:
6326 return new ARMleTargetInfo(Triple);
6327 case llvm::Triple::Itanium:
6328 return new ItaniumWindowsARMleTargetInfo(Triple);
6329 case llvm::Triple::MSVC:
6330 return new MicrosoftARMleTargetInfo(Triple);
6331 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006332 default:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006333 return new ARMleTargetInfo(Triple);
6334 }
6335
6336 case llvm::Triple::armeb:
6337 case llvm::Triple::thumbeb:
6338 if (Triple.isOSDarwin())
6339 return new DarwinARMTargetInfo(Triple);
6340
6341 switch (os) {
6342 case llvm::Triple::Linux:
6343 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
6344 case llvm::Triple::FreeBSD:
6345 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
6346 case llvm::Triple::NetBSD:
6347 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
6348 case llvm::Triple::OpenBSD:
6349 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
6350 case llvm::Triple::Bitrig:
6351 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
6352 case llvm::Triple::RTEMS:
6353 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
6354 case llvm::Triple::NaCl:
6355 return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
6356 default:
6357 return new ARMbeTargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006358 }
Eli Friedmanb5366062008-05-20 14:21:01 +00006359
Daniel Dunbar52322032009-08-18 05:47:58 +00006360 case llvm::Triple::msp430:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006361 return new MSP430TargetInfo(Triple);
Eli Friedmanb5366062008-05-20 14:21:01 +00006362
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006363 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006364 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006365 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006366 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006367 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006368 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006369 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006370 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006371 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006372 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006373 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006374 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006375 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006376
6377 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006378 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006379 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006380 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006381 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006382 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006383 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006384 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006385 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006386 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Petar Jovanovicc19a2842013-09-21 01:27:01 +00006387 case llvm::Triple::NaCl:
6388 return new NaClTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006389 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006390 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006391 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006392
Akira Hatanakabef17452011-09-20 19:21:49 +00006393 case llvm::Triple::mips64:
6394 switch (os) {
6395 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006396 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006397 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006398 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006399 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006400 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006401 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006402 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006403 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006404 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006405 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006406 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006407 }
6408
6409 case llvm::Triple::mips64el:
6410 switch (os) {
6411 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006412 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006413 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006414 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006415 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006416 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006417 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006418 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006419 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006420 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006421 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006422 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006423 }
6424
Ivan Krasindd7403e2011-08-24 20:22:22 +00006425 case llvm::Triple::le32:
6426 switch (os) {
Eli Benderskyd7c92032012-12-04 18:38:10 +00006427 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006428 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasindd7403e2011-08-24 20:22:22 +00006429 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006430 return nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006431 }
6432
JF Bastien643817d2014-09-12 17:52:47 +00006433 case llvm::Triple::le64:
6434 return new Le64TargetInfo(Triple);
6435
Daniel Dunbar52322032009-08-18 05:47:58 +00006436 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006437 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006438 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006439 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006440 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006441 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006442 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006443 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006444 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006445 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006446 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006447 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006448 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006449 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006450 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006451 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006452 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006453
6454 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006455 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006456 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006457 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006458 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006459 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006460 case llvm::Triple::Lv2:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006461 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006462 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006463 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006464 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006465 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006466 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006467 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006468 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006469
Bill Schmidt778d3872013-07-26 01:36:11 +00006470 case llvm::Triple::ppc64le:
6471 switch (os) {
6472 case llvm::Triple::Linux:
6473 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
6474 default:
6475 return new PPC64TargetInfo(Triple);
6476 }
6477
Peter Collingbournec947aae2012-05-20 23:28:41 +00006478 case llvm::Triple::nvptx:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006479 return new NVPTX32TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006480 case llvm::Triple::nvptx64:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006481 return new NVPTX64TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006482
Eli Friedmand13b41e2012-10-12 23:32:00 +00006483 case llvm::Triple::r600:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006484 return new R600TargetInfo(Triple);
Eli Friedmand13b41e2012-10-12 23:32:00 +00006485
Daniel Dunbar52322032009-08-18 05:47:58 +00006486 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006487 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006488 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006489 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006490 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006491 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006492 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006493 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006494 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006495 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006496 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006497 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006498 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006499 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006500 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006501
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006502 case llvm::Triple::sparcv9:
6503 switch (os) {
6504 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006505 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006506 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006507 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006508 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006509 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006510 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006511 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006512 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006513 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006514 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006515 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006516 }
6517
Ulrich Weigand47445072013-05-06 16:26:41 +00006518 case llvm::Triple::systemz:
6519 switch (os) {
6520 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006521 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006522 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006523 return new SystemZTargetInfo(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006524 }
6525
Eli Friedmana9c3d712009-08-19 20:47:07 +00006526 case llvm::Triple::tce:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006527 return new TCETargetInfo(Triple);
Eli Friedmana9c3d712009-08-19 20:47:07 +00006528
Daniel Dunbar52322032009-08-18 05:47:58 +00006529 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006530 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006531 return new DarwinI386TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006532
Daniel Dunbar52322032009-08-18 05:47:58 +00006533 switch (os) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006534 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006535 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006536 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006537 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006538 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006539 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006540 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006541 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006542 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006543 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006544 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006545 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006546 case llvm::Triple::KFreeBSD:
6547 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner3e2ee142010-07-07 16:01:42 +00006548 case llvm::Triple::Minix:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006549 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006550 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006551 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006552 case llvm::Triple::Win32: {
6553 switch (Triple.getEnvironment()) {
6554 default:
6555 return new X86_32TargetInfo(Triple);
6556 case llvm::Triple::Cygnus:
6557 return new CygwinX86_32TargetInfo(Triple);
6558 case llvm::Triple::GNU:
6559 return new MinGWX86_32TargetInfo(Triple);
Saleem Abdulrasool24bd7da2014-06-28 23:34:11 +00006560 case llvm::Triple::Itanium:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006561 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006562 return new MicrosoftX86_32TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006563 }
6564 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00006565 case llvm::Triple::Haiku:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006566 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006567 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006568 return new RTEMSX86_32TargetInfo(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006569 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006570 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006571 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006572 return new X86_32TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006573 }
6574
6575 case llvm::Triple::x86_64:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006576 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006577 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006578
Daniel Dunbar52322032009-08-18 05:47:58 +00006579 switch (os) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006580 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006581 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner002ba6b2010-01-09 05:41:14 +00006582 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006583 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006584 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006585 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006586 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006587 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006588 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006589 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006590 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006591 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006592 case llvm::Triple::KFreeBSD:
6593 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006594 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006595 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006596 case llvm::Triple::Win32: {
6597 switch (Triple.getEnvironment()) {
6598 default:
6599 return new X86_64TargetInfo(Triple);
6600 case llvm::Triple::GNU:
6601 return new MinGWX86_64TargetInfo(Triple);
6602 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006603 return new MicrosoftX86_64TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006604 }
6605 }
Eli Benderskyd7c92032012-12-04 18:38:10 +00006606 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006607 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006608 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006609 return new X86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006610 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006611
6612 case llvm::Triple::spir: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006613 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006614 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006615 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006616 return new SPIR32TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006617 }
6618 case llvm::Triple::spir64: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006619 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006620 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006621 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006622 return new SPIR64TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006623 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006624 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00006625}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006626
6627/// CreateTargetInfo - Return the target info object for the specified target
6628/// triple.
Alp Toker80758082014-07-06 05:26:44 +00006629TargetInfo *
6630TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
6631 const std::shared_ptr<TargetOptions> &Opts) {
Douglas Gregorf8715de2012-11-16 04:24:59 +00006632 llvm::Triple Triple(Opts->Triple);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006633
6634 // Construct the target
Ahmed Charlesb8984322014-03-07 20:03:18 +00006635 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006636 if (!Target) {
6637 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
Craig Topperf1186c52014-05-08 06:41:40 +00006638 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006639 }
Alp Toker80758082014-07-06 05:26:44 +00006640 Target->TargetOpts = Opts;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006641
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006642 // Set the target CPU if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006643 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
6644 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Craig Topperf1186c52014-05-08 06:41:40 +00006645 return nullptr;
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006646 }
6647
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006648 // Set the target ABI if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006649 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
6650 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Craig Topperf1186c52014-05-08 06:41:40 +00006651 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006652 }
6653
Rafael Espindolaeb265472013-08-21 21:59:03 +00006654 // Set the fp math unit.
6655 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
6656 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
Craig Topperf1186c52014-05-08 06:41:40 +00006657 return nullptr;
Rafael Espindolaeb265472013-08-21 21:59:03 +00006658 }
6659
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006660 // Compute the default target features, we need the target to handle this
6661 // because features may have dependencies on one another.
6662 llvm::StringMap<bool> Features;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00006663 Target->getDefaultFeatures(Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006664
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00006665 // Apply the user specified deltas.
6666 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
6667 I < N; ++I) {
6668 const char *Name = Opts->FeaturesAsWritten[I].c_str();
Rafael Espindolaa6416a72011-11-27 20:00:43 +00006669 // Apply the feature via the target.
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00006670 bool Enabled = Name[0] == '+';
6671 Target->setFeatureEnabled(Features, Name + 1, Enabled);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006672 }
6673
6674 // Add the features to the compile options.
6675 //
6676 // FIXME: If we are completely confident that we have the right set, we only
6677 // need to pass the minuses.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006678 Opts->Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006679 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
6680 ie = Features.end(); it != ie; ++it)
Douglas Gregorf8715de2012-11-16 04:24:59 +00006681 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
Eric Christopher3ff21b32013-10-16 21:26:26 +00006682 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Craig Topperf1186c52014-05-08 06:41:40 +00006683 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006684
Ahmed Charles9a16beb2014-03-07 19:33:25 +00006685 return Target.release();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006686}