blob: 90cef3793a800dc0043860a66260f07dce9aaba9 [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"
Chris Lattner30ba6742009-08-10 19:03:04 +000028#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000029#include "llvm/Support/ErrorHandling.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000030#include <algorithm>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000031#include <memory>
Chris Lattner5ba61f02006-10-14 07:39:34 +000032using namespace clang;
33
Chris Lattner5ba61f02006-10-14 07:39:34 +000034//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000035// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000036//===----------------------------------------------------------------------===//
37
Chris Lattner1e1c0b92009-03-20 16:06:38 +000038/// DefineStd - Define a macro name and standard variants. For example if
39/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
40/// when in GNU mode.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000041static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000042 const LangOptions &Opts) {
43 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000044
Chris Lattner1e1c0b92009-03-20 16:06:38 +000045 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
46 // in the user's namespace.
47 if (Opts.GNUMode)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000048 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000049
Chris Lattner1e1c0b92009-03-20 16:06:38 +000050 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000051 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000052
Chris Lattner1e1c0b92009-03-20 16:06:38 +000053 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000054 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000055}
56
Benjamin Kramere3b442d2012-01-10 11:50:09 +000057static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
58 bool Tuning = true) {
59 Builder.defineMacro("__" + CPUName);
60 Builder.defineMacro("__" + CPUName + "__");
61 if (Tuning)
62 Builder.defineMacro("__tune_" + CPUName + "__");
63}
64
Chris Lattner09d98f52008-10-05 21:50:58 +000065//===----------------------------------------------------------------------===//
66// Defines specific to certain operating systems.
67//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000068
Torok Edwinb2b37c62009-06-30 17:10:35 +000069namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000070template<typename TgtInfo>
71class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000072protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000073 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000074 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000075public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +000076 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +000077 void getTargetDefines(const LangOptions &Opts,
78 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000079 TgtInfo::getTargetDefines(Opts, Builder);
80 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000081 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000082
83};
Chris Lattner859c37a2009-08-12 06:24:27 +000084} // end anonymous namespace
Torok Edwin4e054162009-06-30 17:00:25 +000085
Chris Lattner30ba6742009-08-10 19:03:04 +000086
Daniel Dunbard86666f2010-01-26 01:44:04 +000087static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000088 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000089 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +000090 VersionTuple &PlatformMinVersion) {
Bob Wilson834400b2013-08-19 20:23:37 +000091 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000092 Builder.defineMacro("__APPLE__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000093 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenkob4f81902012-09-20 10:10:01 +000094 // AddressSanitizer doesn't play well with source fortification, which is on
95 // by default on Darwin.
Alexey Samsonovedf99a92014-11-07 22:29:38 +000096 if (Opts.Sanitize.has(SanitizerKind::Address))
97 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
Ed Schoutenf33c6072015-03-11 08:42:46 +0000186// CloudABI Target
187template <typename Target>
188class CloudABITargetInfo : public OSTargetInfo<Target> {
189protected:
190 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
191 MacroBuilder &Builder) const override {
192 Builder.defineMacro("__CloudABI__");
193 Builder.defineMacro("__ELF__");
194
195 // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
196 Builder.defineMacro("__STDC_ISO_10646__", "201206L");
197 Builder.defineMacro("__STDC_UTF_16__");
198 Builder.defineMacro("__STDC_UTF_32__");
199 }
200
201public:
202 CloudABITargetInfo(const llvm::Triple &Triple)
203 : OSTargetInfo<Target>(Triple) {
204 this->UserLabelPrefix = "";
205 }
206};
207
Chris Lattner30ba6742009-08-10 19:03:04 +0000208namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000209template<typename Target>
210class DarwinTargetInfo : public OSTargetInfo<Target> {
211protected:
Craig Topper3164f332014-03-11 03:39:26 +0000212 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
213 MacroBuilder &Builder) const override {
Eric Christopher0c912c52011-07-07 22:55:26 +0000214 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000215 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000216 }
Mike Stump11289f42009-09-09 15:08:12 +0000217
Torok Edwinb2b37c62009-06-30 17:10:35 +0000218public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000219 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
220 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
221 this->MCountName = "\01mcount";
222 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000223
Craig Topper3164f332014-03-11 03:39:26 +0000224 std::string isValidSectionSpecifier(StringRef SR) const override {
Chris Lattner30ba6742009-08-10 19:03:04 +0000225 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000226 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000227 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000228 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000229 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000230 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000231 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000232
Craig Topper3164f332014-03-11 03:39:26 +0000233 const char *getStaticInitSectionSpecifier() const override {
Anders Carlsson851318a2010-06-08 22:47:50 +0000234 // FIXME: We should return 0 when building kexts.
235 return "__TEXT,__StaticInit,regular,pure_instructions";
236 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000237
John McCalleed64c72012-01-29 01:20:30 +0000238 /// Darwin does not support protected visibility. Darwin's "default"
239 /// is very similar to ELF's "protected"; Darwin requires a "weak"
240 /// attribute on declarations that can be dynamically replaced.
Craig Topper3164f332014-03-11 03:39:26 +0000241 bool hasProtectedVisibility() const override {
John McCalleed64c72012-01-29 01:20:30 +0000242 return false;
243 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000244};
245
Chris Lattner30ba6742009-08-10 19:03:04 +0000246
Torok Edwinb2b37c62009-06-30 17:10:35 +0000247// DragonFlyBSD Target
248template<typename Target>
249class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
250protected:
Craig Topper3164f332014-03-11 03:39:26 +0000251 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
252 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000253 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000254 Builder.defineMacro("__DragonFly__");
255 Builder.defineMacro("__DragonFly_cc_version", "100001");
256 Builder.defineMacro("__ELF__");
257 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
258 Builder.defineMacro("__tune_i386__");
259 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000260 }
261public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000262 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
263 : OSTargetInfo<Target>(Triple) {
264 this->UserLabelPrefix = "";
Eli Friedman4286fba2012-02-10 23:02:29 +0000265
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000266 switch (Triple.getArch()) {
267 default:
268 case llvm::Triple::x86:
269 case llvm::Triple::x86_64:
270 this->MCountName = ".mcount";
271 break;
272 }
Eli Friedman4286fba2012-02-10 23:02:29 +0000273 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000274};
275
276// FreeBSD Target
277template<typename Target>
278class FreeBSDTargetInfo : public OSTargetInfo<Target> {
279protected:
Craig Topper3164f332014-03-11 03:39:26 +0000280 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
281 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000282 // FreeBSD defines; list based off of gcc output
283
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000284 unsigned Release = Triple.getOSMajorVersion();
285 if (Release == 0U)
286 Release = 8;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000287
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000288 Builder.defineMacro("__FreeBSD__", Twine(Release));
289 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000290 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
291 DefineStd(Builder, "unix", Opts);
292 Builder.defineMacro("__ELF__");
Ed Schoutend0621462013-09-29 07:54:52 +0000293
294 // On FreeBSD, wchar_t contains the number of the code point as
295 // used by the character set of the locale. These character sets are
296 // not necessarily a superset of ASCII.
Richard Smith00a4a852015-01-13 01:47:45 +0000297 //
298 // FIXME: This is wrong; the macro refers to the numerical values
299 // of wchar_t *literals*, which are not locale-dependent. However,
300 // FreeBSD systems apparently depend on us getting this wrong, and
301 // setting this to 1 is conforming even if all the basic source
302 // character literals have the same encoding as char and wchar_t.
Ed Schoutend0621462013-09-29 07:54:52 +0000303 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000304 }
305public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000306 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
307 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000308
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000309 switch (Triple.getArch()) {
310 default:
311 case llvm::Triple::x86:
312 case llvm::Triple::x86_64:
313 this->MCountName = ".mcount";
314 break;
315 case llvm::Triple::mips:
316 case llvm::Triple::mipsel:
317 case llvm::Triple::ppc:
318 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +0000319 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000320 this->MCountName = "_mcount";
321 break;
322 case llvm::Triple::arm:
323 this->MCountName = "__mcount";
324 break;
Duncan Sands9cb27e92009-07-08 13:55:08 +0000325 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000326 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000327};
328
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000329// GNU/kFreeBSD Target
330template<typename Target>
331class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
332protected:
Craig Topper3164f332014-03-11 03:39:26 +0000333 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
334 MacroBuilder &Builder) const override {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000335 // GNU/kFreeBSD defines; list based off of gcc output
336
337 DefineStd(Builder, "unix", Opts);
338 Builder.defineMacro("__FreeBSD_kernel__");
339 Builder.defineMacro("__GLIBC__");
340 Builder.defineMacro("__ELF__");
341 if (Opts.POSIXThreads)
342 Builder.defineMacro("_REENTRANT");
343 if (Opts.CPlusPlus)
344 Builder.defineMacro("_GNU_SOURCE");
345 }
346public:
Eric Christopher917e9522014-11-18 22:36:15 +0000347 KFreeBSDTargetInfo(const llvm::Triple &Triple)
348 : OSTargetInfo<Target>(Triple) {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000349 this->UserLabelPrefix = "";
350 }
351};
352
Chris Lattner3e2ee142010-07-07 16:01:42 +0000353// Minix Target
354template<typename Target>
355class MinixTargetInfo : public OSTargetInfo<Target> {
356protected:
Craig Topper3164f332014-03-11 03:39:26 +0000357 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
358 MacroBuilder &Builder) const override {
Chris Lattner3e2ee142010-07-07 16:01:42 +0000359 // Minix defines
360
361 Builder.defineMacro("__minix", "3");
362 Builder.defineMacro("_EM_WSIZE", "4");
363 Builder.defineMacro("_EM_PSIZE", "4");
364 Builder.defineMacro("_EM_SSIZE", "2");
365 Builder.defineMacro("_EM_LSIZE", "4");
366 Builder.defineMacro("_EM_FSIZE", "4");
367 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000368 Builder.defineMacro("__ELF__");
Chris Lattner3e2ee142010-07-07 16:01:42 +0000369 DefineStd(Builder, "unix", Opts);
370 }
371public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000372 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
373 this->UserLabelPrefix = "";
374 }
Chris Lattner3e2ee142010-07-07 16:01:42 +0000375};
376
Torok Edwinb2b37c62009-06-30 17:10:35 +0000377// Linux target
378template<typename Target>
379class LinuxTargetInfo : public OSTargetInfo<Target> {
380protected:
Craig Topper3164f332014-03-11 03:39:26 +0000381 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
382 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000383 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000384 DefineStd(Builder, "unix", Opts);
385 DefineStd(Builder, "linux", Opts);
386 Builder.defineMacro("__gnu_linux__");
387 Builder.defineMacro("__ELF__");
Dan Albert84aee012015-03-03 18:28:38 +0000388 if (Triple.getEnvironment() == llvm::Triple::Android) {
Evgeniy Stepanov94dc4c92012-04-26 12:08:09 +0000389 Builder.defineMacro("__ANDROID__", "1");
Dan Albert84aee012015-03-03 18:28:38 +0000390 unsigned Maj, Min, Rev;
391 Triple.getOSVersion(Maj, Min, Rev);
392 this->PlatformName = "android";
393 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
394 }
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000395 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000396 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000397 if (Opts.CPlusPlus)
398 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000399 }
400public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000401 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000402 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000403 this->WIntType = TargetInfo::UnsignedInt;
Hal Finkelecdb4542014-03-30 13:00:06 +0000404
405 switch (Triple.getArch()) {
406 default:
407 break;
408 case llvm::Triple::ppc:
409 case llvm::Triple::ppc64:
410 case llvm::Triple::ppc64le:
411 this->MCountName = "_mcount";
412 break;
413 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000414 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000415
Craig Topper3164f332014-03-11 03:39:26 +0000416 const char *getStaticInitSectionSpecifier() const override {
Benjamin Kramera518b222011-10-15 17:53:33 +0000417 return ".text.startup";
418 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000419};
420
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000421// NetBSD Target
422template<typename Target>
423class NetBSDTargetInfo : public OSTargetInfo<Target> {
424protected:
Craig Topper3164f332014-03-11 03:39:26 +0000425 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
426 MacroBuilder &Builder) const override {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000427 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000428 Builder.defineMacro("__NetBSD__");
429 Builder.defineMacro("__unix__");
430 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000431 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000432 Builder.defineMacro("_POSIX_THREADS");
Joerg Sonnenbergercc1edb52014-05-13 18:58:36 +0000433
434 switch (Triple.getArch()) {
435 default:
436 break;
437 case llvm::Triple::arm:
438 case llvm::Triple::armeb:
439 case llvm::Triple::thumb:
440 case llvm::Triple::thumbeb:
441 Builder.defineMacro("__ARM_DWARF_EH__");
442 break;
443 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000444 }
445public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000446 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
447 this->UserLabelPrefix = "";
448 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000449};
450
Torok Edwinb2b37c62009-06-30 17:10:35 +0000451// OpenBSD Target
452template<typename Target>
453class OpenBSDTargetInfo : public OSTargetInfo<Target> {
454protected:
Craig Topper3164f332014-03-11 03:39:26 +0000455 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
456 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000457 // OpenBSD defines; list based off of gcc output
458
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000459 Builder.defineMacro("__OpenBSD__");
460 DefineStd(Builder, "unix", Opts);
461 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000462 if (Opts.POSIXThreads)
Chris Lattner024e12d2012-04-25 06:12:24 +0000463 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000464 }
465public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000466 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
467 this->UserLabelPrefix = "";
468 this->TLSSupported = false;
Eli Friedman3715d1f2011-12-15 02:15:56 +0000469
Eli Friedman3715d1f2011-12-15 02:15:56 +0000470 switch (Triple.getArch()) {
471 default:
472 case llvm::Triple::x86:
473 case llvm::Triple::x86_64:
474 case llvm::Triple::arm:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000475 case llvm::Triple::sparc:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000476 this->MCountName = "__mcount";
477 break;
478 case llvm::Triple::mips64:
479 case llvm::Triple::mips64el:
480 case llvm::Triple::ppc:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000481 case llvm::Triple::sparcv9:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000482 this->MCountName = "_mcount";
483 break;
484 }
485 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000486};
487
Eli Friedman9fa28852012-08-08 23:57:20 +0000488// Bitrig Target
489template<typename Target>
490class BitrigTargetInfo : public OSTargetInfo<Target> {
491protected:
Craig Topper3164f332014-03-11 03:39:26 +0000492 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
493 MacroBuilder &Builder) const override {
Eli Friedman9fa28852012-08-08 23:57:20 +0000494 // Bitrig defines; list based off of gcc output
495
496 Builder.defineMacro("__Bitrig__");
497 DefineStd(Builder, "unix", Opts);
498 Builder.defineMacro("__ELF__");
499 if (Opts.POSIXThreads)
500 Builder.defineMacro("_REENTRANT");
Renato Golin9ba39232015-02-27 16:35:48 +0000501
502 switch (Triple.getArch()) {
503 default:
504 break;
505 case llvm::Triple::arm:
506 case llvm::Triple::armeb:
507 case llvm::Triple::thumb:
508 case llvm::Triple::thumbeb:
509 Builder.defineMacro("__ARM_DWARF_EH__");
510 break;
511 }
Eli Friedman9fa28852012-08-08 23:57:20 +0000512 }
513public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000514 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
515 this->UserLabelPrefix = "";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000516 this->MCountName = "__mcount";
Eli Friedman9fa28852012-08-08 23:57:20 +0000517 }
518};
519
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000520// PSP Target
521template<typename Target>
522class PSPTargetInfo : 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 {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000526 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000527 Builder.defineMacro("PSP");
528 Builder.defineMacro("_PSP");
529 Builder.defineMacro("__psp__");
530 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000531 }
532public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000533 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000534 this->UserLabelPrefix = "";
535 }
536};
537
John Thompsone467e192009-11-19 17:18:50 +0000538// PS3 PPU Target
539template<typename Target>
540class PS3PPUTargetInfo : public OSTargetInfo<Target> {
541protected:
Craig Topper3164f332014-03-11 03:39:26 +0000542 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
543 MacroBuilder &Builder) const override {
John Thompsone467e192009-11-19 17:18:50 +0000544 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000545 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000546 Builder.defineMacro("__PPU__");
547 Builder.defineMacro("__CELLOS_LV2__");
548 Builder.defineMacro("__ELF__");
549 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000550 Builder.defineMacro("_ARCH_PPC64");
551 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000552 }
553public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000554 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompsone467e192009-11-19 17:18:50 +0000555 this->UserLabelPrefix = "";
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000556 this->LongWidth = this->LongAlign = 32;
557 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000558 this->IntMaxType = TargetInfo::SignedLongLong;
John Thompson07a61a42010-06-24 22:44:13 +0000559 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000560 this->SizeType = TargetInfo::UnsignedInt;
Rafael Espindolac418ae92014-01-03 19:22:05 +0000561 this->DescriptionString = "E-m:e-p:32:32-i64:64-n32:64";
John Thompsone467e192009-11-19 17:18:50 +0000562 }
563};
564
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000565template <typename Target>
566class PS4OSTargetInfo : public OSTargetInfo<Target> {
567protected:
568 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
569 MacroBuilder &Builder) const override {
570 Builder.defineMacro("__FreeBSD__", "9");
571 Builder.defineMacro("__FreeBSD_cc_version", "900001");
572 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
573 DefineStd(Builder, "unix", Opts);
574 Builder.defineMacro("__ELF__");
575 Builder.defineMacro("__PS4__");
576 }
577public:
578 PS4OSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
579 this->WCharType = this->UnsignedShort;
580
581 this->UserLabelPrefix = "";
582
583 switch (Triple.getArch()) {
584 default:
585 case llvm::Triple::x86_64:
586 this->MCountName = ".mcount";
587 break;
588 }
589 }
590};
591
Torok Edwinb2b37c62009-06-30 17:10:35 +0000592// Solaris target
593template<typename Target>
594class SolarisTargetInfo : public OSTargetInfo<Target> {
595protected:
Craig Topper3164f332014-03-11 03:39:26 +0000596 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
597 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000598 DefineStd(Builder, "sun", Opts);
599 DefineStd(Builder, "unix", Opts);
600 Builder.defineMacro("__ELF__");
601 Builder.defineMacro("__svr4__");
602 Builder.defineMacro("__SVR4");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000603 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
604 // newer, but to 500 for everything else. feature_test.h has a check to
605 // ensure that you are not using C99 with an old version of X/Open or C89
Richard Smithab506ad2014-10-20 23:26:58 +0000606 // with a new version.
607 if (Opts.C99)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000608 Builder.defineMacro("_XOPEN_SOURCE", "600");
609 else
610 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnalle04307e2012-03-02 10:49:52 +0000611 if (Opts.CPlusPlus)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000612 Builder.defineMacro("__C99FEATURES__");
David Chisnall0c1941cb2012-02-17 18:35:11 +0000613 Builder.defineMacro("_LARGEFILE_SOURCE");
614 Builder.defineMacro("_LARGEFILE64_SOURCE");
615 Builder.defineMacro("__EXTENSIONS__");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000616 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000617 }
618public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000619 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000620 this->UserLabelPrefix = "";
David Chisnallb526e932012-03-28 18:04:14 +0000621 this->WCharType = this->SignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000622 // FIXME: WIntType should be SignedLong
623 }
624};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000625
626// Windows target
627template<typename Target>
628class WindowsTargetInfo : public OSTargetInfo<Target> {
629protected:
Craig Topper3164f332014-03-11 03:39:26 +0000630 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
631 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000632 Builder.defineMacro("_WIN32");
633 }
634 void getVisualStudioDefines(const LangOptions &Opts,
635 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000636 if (Opts.CPlusPlus) {
David Majnemerf6072342014-07-01 22:24:56 +0000637 if (Opts.RTTIData)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000638 Builder.defineMacro("_CPPRTTI");
639
Reid Kleckner16514352015-01-30 21:42:55 +0000640 if (Opts.CXXExceptions)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000641 Builder.defineMacro("_CPPUNWIND");
642 }
643
644 if (!Opts.CharIsSigned)
645 Builder.defineMacro("_CHAR_UNSIGNED");
646
647 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
648 // but it works for now.
649 if (Opts.POSIXThreads)
650 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000651
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +0000652 if (Opts.MSCompatibilityVersion) {
653 Builder.defineMacro("_MSC_VER",
654 Twine(Opts.MSCompatibilityVersion / 100000));
655 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000656 // FIXME We cannot encode the revision information into 32-bits
657 Builder.defineMacro("_MSC_BUILD", Twine(1));
658 }
Reid Kleckner6f6e76d2014-04-16 20:10:16 +0000659
660 if (Opts.MicrosoftExt) {
661 Builder.defineMacro("_MSC_EXTENSIONS");
662
663 if (Opts.CPlusPlus11) {
664 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
665 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
666 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
667 }
668 }
669
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000670 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000671 }
672
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000673public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000674 WindowsTargetInfo(const llvm::Triple &Triple)
675 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000676};
677
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000678template <typename Target>
679class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000680protected:
Craig Topper3164f332014-03-11 03:39:26 +0000681 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
682 MacroBuilder &Builder) const override {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000683 if (Opts.POSIXThreads)
684 Builder.defineMacro("_REENTRANT");
685 if (Opts.CPlusPlus)
686 Builder.defineMacro("_GNU_SOURCE");
687
688 DefineStd(Builder, "unix", Opts);
689 Builder.defineMacro("__ELF__");
690 Builder.defineMacro("__native_client__");
691 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000692
693public:
694 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000695 this->UserLabelPrefix = "";
696 this->LongAlign = 32;
697 this->LongWidth = 32;
698 this->PointerAlign = 32;
699 this->PointerWidth = 32;
700 this->IntMaxType = TargetInfo::SignedLongLong;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000701 this->Int64Type = TargetInfo::SignedLongLong;
702 this->DoubleAlign = 64;
703 this->LongDoubleWidth = 64;
704 this->LongDoubleAlign = 64;
Jan Wen Voung1f9c4ee2014-01-15 21:42:41 +0000705 this->LongLongWidth = 64;
706 this->LongLongAlign = 64;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000707 this->SizeType = TargetInfo::UnsignedInt;
708 this->PtrDiffType = TargetInfo::SignedInt;
709 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +0000710 // RegParmMax is inherited from the underlying architecture
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000711 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Rafael Espindola1c09b262013-12-18 23:41:04 +0000712 if (Triple.getArch() == llvm::Triple::arm) {
Eric Christopher917e9522014-11-18 22:36:15 +0000713 this->DescriptionString =
714 "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000715 } else if (Triple.getArch() == llvm::Triple::x86) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000716 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000717 } else if (Triple.getArch() == llvm::Triple::x86_64) {
Rafael Espindolac418ae92014-01-03 19:22:05 +0000718 this->DescriptionString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000719 } else if (Triple.getArch() == llvm::Triple::mipsel) {
720 // Handled on mips' setDescriptionString.
721 } else {
722 assert(Triple.getArch() == llvm::Triple::le32);
723 this->DescriptionString = "e-p:32:32-i64:64";
724 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000725 }
726};
Mike Stump11289f42009-09-09 15:08:12 +0000727} // end anonymous namespace.
Torok Edwinb2b37c62009-06-30 17:10:35 +0000728
Chris Lattner09d98f52008-10-05 21:50:58 +0000729//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000730// Specific target implementations.
731//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000732
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000733namespace {
734// PPC abstract base class
735class PPCTargetInfo : public TargetInfo {
736 static const Builtin::Info BuiltinInfo[];
737 static const char * const GCCRegNames[];
738 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel8eb59282012-06-11 22:35:19 +0000739 std::string CPU;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000740
741 // Target cpu features.
742 bool HasVSX;
Bill Schmidt8c184e32014-10-10 17:21:23 +0000743 bool HasP8Vector;
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +0000744 bool HasP8Crypto;
Hal Finkel0d0a1a52015-03-11 19:14:15 +0000745 bool HasQPX;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000746
Ulrich Weigand8afad612014-07-28 13:17:52 +0000747protected:
748 std::string ABI;
749
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000750public:
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000751 PPCTargetInfo(const llvm::Triple &Triple)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +0000752 : TargetInfo(Triple), HasVSX(false), HasP8Vector(false),
Hal Finkel0d0a1a52015-03-11 19:14:15 +0000753 HasP8Crypto(false), HasQPX(false) {
Bill Schmidt778d3872013-07-26 01:36:11 +0000754 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Nico Weber3435ede2012-01-31 02:07:33 +0000755 LongDoubleWidth = LongDoubleAlign = 128;
756 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
757 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000758
Hal Finkel6b984f02012-07-03 16:51:04 +0000759 /// \brief Flags for architecture specific defines.
760 typedef enum {
761 ArchDefineNone = 0,
762 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
763 ArchDefinePpcgr = 1 << 1,
764 ArchDefinePpcsq = 1 << 2,
765 ArchDefine440 = 1 << 3,
766 ArchDefine603 = 1 << 4,
767 ArchDefine604 = 1 << 5,
768 ArchDefinePwr4 = 1 << 6,
Bill Schmidt38378a02013-02-01 20:23:10 +0000769 ArchDefinePwr5 = 1 << 7,
770 ArchDefinePwr5x = 1 << 8,
771 ArchDefinePwr6 = 1 << 9,
772 ArchDefinePwr6x = 1 << 10,
773 ArchDefinePwr7 = 1 << 11,
Will Schmidtf0487512014-06-26 13:34:10 +0000774 ArchDefinePwr8 = 1 << 12,
775 ArchDefineA2 = 1 << 13,
776 ArchDefineA2q = 1 << 14
Hal Finkel6b984f02012-07-03 16:51:04 +0000777 } ArchDefineTypes;
778
Bill Schmidt38378a02013-02-01 20:23:10 +0000779 // Note: GCC recognizes the following additional cpus:
780 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
781 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
782 // titan, rs64.
Craig Topper3164f332014-03-11 03:39:26 +0000783 bool setCPU(const std::string &Name) override {
Hal Finkel8eb59282012-06-11 22:35:19 +0000784 bool CPUKnown = llvm::StringSwitch<bool>(Name)
785 .Case("generic", true)
786 .Case("440", true)
787 .Case("450", true)
788 .Case("601", true)
789 .Case("602", true)
790 .Case("603", true)
791 .Case("603e", true)
792 .Case("603ev", true)
793 .Case("604", true)
794 .Case("604e", true)
795 .Case("620", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000796 .Case("630", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000797 .Case("g3", true)
798 .Case("7400", true)
799 .Case("g4", true)
800 .Case("7450", true)
801 .Case("g4+", true)
802 .Case("750", true)
803 .Case("970", true)
804 .Case("g5", true)
805 .Case("a2", true)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +0000806 .Case("a2q", true)
Hal Finkelf6d6cb02012-09-18 22:25:03 +0000807 .Case("e500mc", true)
808 .Case("e5500", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000809 .Case("power3", true)
810 .Case("pwr3", true)
811 .Case("power4", true)
812 .Case("pwr4", true)
813 .Case("power5", true)
814 .Case("pwr5", true)
815 .Case("power5x", true)
816 .Case("pwr5x", true)
817 .Case("power6", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000818 .Case("pwr6", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000819 .Case("power6x", true)
820 .Case("pwr6x", true)
821 .Case("power7", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000822 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +0000823 .Case("power8", true)
824 .Case("pwr8", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000825 .Case("powerpc", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000826 .Case("ppc", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000827 .Case("powerpc64", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000828 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +0000829 .Case("powerpc64le", true)
830 .Case("ppc64le", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000831 .Default(false);
832
833 if (CPUKnown)
834 CPU = Name;
835
836 return CPUKnown;
837 }
838
Ulrich Weigand8afad612014-07-28 13:17:52 +0000839
840 StringRef getABI() const override { return ABI; }
841
Craig Topper3164f332014-03-11 03:39:26 +0000842 void getTargetBuiltins(const Builtin::Info *&Records,
843 unsigned &NumRecords) const override {
Chris Lattner10a5b382007-01-29 05:24:35 +0000844 Records = BuiltinInfo;
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000845 NumRecords = clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +0000846 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000847
Craig Topper3164f332014-03-11 03:39:26 +0000848 bool isCLZForZeroUndef() const override { return false; }
Bob Wilson19a2f2b2012-01-28 18:02:29 +0000849
Craig Topper3164f332014-03-11 03:39:26 +0000850 void getTargetDefines(const LangOptions &Opts,
851 MacroBuilder &Builder) const override;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000852
Craig Topper3164f332014-03-11 03:39:26 +0000853 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
Bill Schmidt2fe4c672013-02-01 02:14:03 +0000854
Craig Topper3164f332014-03-11 03:39:26 +0000855 bool handleTargetFeatures(std::vector<std::string> &Features,
856 DiagnosticsEngine &Diags) override;
857 bool hasFeature(StringRef Feature) const override;
858
859 void getGCCRegNames(const char * const *&Names,
860 unsigned &NumNames) const override;
861 void getGCCRegAliases(const GCCRegAlias *&Aliases,
862 unsigned &NumAliases) const override;
863 bool validateAsmConstraint(const char *&Name,
864 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +0000865 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000866 default: return false;
867 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000868 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000869 case 'b': // Base register
870 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000871 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000872 break;
873 // FIXME: The following are added to allow parsing.
874 // I just took a guess at what the actions should be.
875 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000876 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000877 case 'v': // Altivec vector register
878 Info.setAllowsRegister();
879 break;
880 case 'w':
881 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000882 case 'd':// VSX vector register to hold vector double data
883 case 'f':// VSX vector register to hold vector float data
884 case 's':// VSX vector register to hold scalar float data
885 case 'a':// Any VSX register
Hal Finkelf7a07a52014-03-02 18:24:18 +0000886 case 'c':// An individual CR bit
John Thompson07a61a42010-06-24 22:44:13 +0000887 break;
888 default:
889 return false;
890 }
891 Info.setAllowsRegister();
892 Name++; // Skip over 'w'.
893 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000894 case 'h': // `MQ', `CTR', or `LINK' register
895 case 'q': // `MQ' register
896 case 'c': // `CTR' register
897 case 'l': // `LINK' register
898 case 'x': // `CR' register (condition register) number 0
899 case 'y': // `CR' register (condition register)
900 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000901 Info.setAllowsRegister();
902 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000903 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000904 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000905 // (use `L' instead for SImode constants)
906 case 'K': // Unsigned 16-bit constant
907 case 'L': // Signed 16-bit constant shifted left 16 bits
908 case 'M': // Constant larger than 31
909 case 'N': // Exact power of 2
910 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000911 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000912 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000913 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000914 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000915 break;
916 case 'm': // Memory operand. Note that on PowerPC targets, m can
917 // include addresses that update the base register. It
918 // is therefore only safe to use `m' in an asm statement
919 // if that asm statement accesses the operand exactly once.
920 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000921 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000922 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000923 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000924 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000925 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
926 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000927 // register to be updated.
928 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000929 if (Name[1] != 's')
930 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000931 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000932 // include any automodification of the base register. Unlike
933 // `m', this constraint can be used in asm statements that
934 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000935 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000936 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000937 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000938 break;
939 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000940 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000941 case 'Z': // Memory operand that is an indexed or indirect from a
942 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000943 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000944 Info.setAllowsMemory();
945 Info.setAllowsRegister();
946 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000947 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000948 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000949 // register (`p' is preferable for asm statements)
950 case 'S': // Constant suitable as a 64-bit mask operand
951 case 'T': // Constant suitable as a 32-bit mask operand
952 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +0000953 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000954 // instructions
955 case 'W': // Vector constant that does not require memory
956 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +0000957 break;
958 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +0000959 }
John Thompson07a61a42010-06-24 22:44:13 +0000960 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +0000961 }
Craig Topper3164f332014-03-11 03:39:26 +0000962 std::string convertConstraint(const char *&Constraint) const override {
Hal Finkelf7a07a52014-03-02 18:24:18 +0000963 std::string R;
964 switch (*Constraint) {
965 case 'e':
966 case 'w':
967 // Two-character constraint; add "^" hint for later parsing.
968 R = std::string("^") + std::string(Constraint, 2);
969 Constraint++;
970 break;
971 default:
972 return TargetInfo::convertConstraint(Constraint);
973 }
974 return R;
975 }
Craig Topper3164f332014-03-11 03:39:26 +0000976 const char *getClobbers() const override {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000977 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +0000978 }
Craig Topper3164f332014-03-11 03:39:26 +0000979 int getEHDataRegisterNumber(unsigned RegNo) const override {
Adhemerval Zanella5d874ae2013-01-22 20:02:45 +0000980 if (RegNo == 0) return 3;
981 if (RegNo == 1) return 4;
982 return -1;
983 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +0000984
985 bool hasSjLjLowering() const override {
986 return true;
987 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000988};
Anders Carlssonf511f642007-11-27 04:11:28 +0000989
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000990const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000991#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +0000992#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +0000993 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +0000994#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000995};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000996
Eric Christopher917e9522014-11-18 22:36:15 +0000997/// handleTargetFeatures - Perform initialization based on the user
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000998/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +0000999bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001000 DiagnosticsEngine &Diags) {
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001001 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
1002 // Ignore disabled features.
1003 if (Features[i][0] == '-')
1004 continue;
1005
1006 StringRef Feature = StringRef(Features[i]).substr(1);
1007
1008 if (Feature == "vsx") {
1009 HasVSX = true;
1010 continue;
1011 }
1012
Bill Schmidt59eb7672014-10-10 15:09:43 +00001013 if (Feature == "power8-vector") {
Bill Schmidt8c184e32014-10-10 17:21:23 +00001014 HasP8Vector = true;
Bill Schmidt59eb7672014-10-10 15:09:43 +00001015 continue;
1016 }
1017
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001018 if (Feature == "crypto") {
1019 HasP8Crypto = true;
1020 continue;
1021 }
1022
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001023 if (Feature == "qpx") {
1024 HasQPX = true;
1025 continue;
1026 }
1027
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001028 // TODO: Finish this list and add an assert that we've handled them
1029 // all.
1030 }
1031
1032 return true;
1033}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001034
Chris Lattnerecd49032009-03-02 22:27:17 +00001035/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
1036/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001037void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001038 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001039 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001040 Builder.defineMacro("__ppc__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001041 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001042 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001043 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001044 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001045 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001046 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001047 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001048 Builder.defineMacro("__ppc64__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001049 Builder.defineMacro("__PPC64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001050 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001051
Chris Lattnerecd49032009-03-02 22:27:17 +00001052 // Target properties.
Bill Schmidt778d3872013-07-26 01:36:11 +00001053 if (getTriple().getArch() == llvm::Triple::ppc64le) {
1054 Builder.defineMacro("_LITTLE_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001055 } else {
1056 if (getTriple().getOS() != llvm::Triple::NetBSD &&
1057 getTriple().getOS() != llvm::Triple::OpenBSD)
1058 Builder.defineMacro("_BIG_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001059 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001060
Ulrich Weigand8afad612014-07-28 13:17:52 +00001061 // ABI options.
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001062 if (ABI == "elfv1" || ABI == "elfv1-qpx")
Ulrich Weigand8afad612014-07-28 13:17:52 +00001063 Builder.defineMacro("_CALL_ELF", "1");
1064 if (ABI == "elfv2")
1065 Builder.defineMacro("_CALL_ELF", "2");
1066
Chris Lattnerecd49032009-03-02 22:27:17 +00001067 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001068 Builder.defineMacro("__NATURAL_ALIGNMENT__");
1069 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001070
Chris Lattnerecd49032009-03-02 22:27:17 +00001071 // FIXME: Should be controlled by command line option.
Roman Divacky13b586f2013-07-03 19:45:54 +00001072 if (LongDoubleWidth == 128)
1073 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001074
John Thompsone467e192009-11-19 17:18:50 +00001075 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001076 Builder.defineMacro("__VEC__", "10206");
1077 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +00001078 }
Hal Finkel8eb59282012-06-11 22:35:19 +00001079
1080 // CPU identification.
Hal Finkel6b984f02012-07-03 16:51:04 +00001081 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1082 .Case("440", ArchDefineName)
1083 .Case("450", ArchDefineName | ArchDefine440)
1084 .Case("601", ArchDefineName)
1085 .Case("602", ArchDefineName | ArchDefinePpcgr)
1086 .Case("603", ArchDefineName | ArchDefinePpcgr)
1087 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1088 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1089 .Case("604", ArchDefineName | ArchDefinePpcgr)
1090 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1091 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt38378a02013-02-01 20:23:10 +00001092 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel6b984f02012-07-03 16:51:04 +00001093 .Case("7400", ArchDefineName | ArchDefinePpcgr)
1094 .Case("7450", ArchDefineName | ArchDefinePpcgr)
1095 .Case("750", ArchDefineName | ArchDefinePpcgr)
1096 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1097 | ArchDefinePpcsq)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001098 .Case("a2", ArchDefineA2)
1099 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt38378a02013-02-01 20:23:10 +00001100 .Case("pwr3", ArchDefinePpcgr)
1101 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1102 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1103 | ArchDefinePpcsq)
1104 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1105 | ArchDefinePpcgr | ArchDefinePpcsq)
1106 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1107 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1108 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1109 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1110 | ArchDefinePpcsq)
1111 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1112 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001113 | ArchDefinePpcgr | ArchDefinePpcsq)
1114 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1115 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1116 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Bill Schmidt38378a02013-02-01 20:23:10 +00001117 .Case("power3", ArchDefinePpcgr)
1118 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1119 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1120 | ArchDefinePpcsq)
1121 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1122 | ArchDefinePpcgr | ArchDefinePpcsq)
1123 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1124 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1125 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1126 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1127 | ArchDefinePpcsq)
1128 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1129 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001130 | ArchDefinePpcgr | ArchDefinePpcsq)
1131 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1132 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1133 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel6b984f02012-07-03 16:51:04 +00001134 .Default(ArchDefineNone);
1135
1136 if (defs & ArchDefineName)
1137 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1138 if (defs & ArchDefinePpcgr)
1139 Builder.defineMacro("_ARCH_PPCGR");
1140 if (defs & ArchDefinePpcsq)
1141 Builder.defineMacro("_ARCH_PPCSQ");
1142 if (defs & ArchDefine440)
Hal Finkel8eb59282012-06-11 22:35:19 +00001143 Builder.defineMacro("_ARCH_440");
Hal Finkel6b984f02012-07-03 16:51:04 +00001144 if (defs & ArchDefine603)
1145 Builder.defineMacro("_ARCH_603");
1146 if (defs & ArchDefine604)
1147 Builder.defineMacro("_ARCH_604");
Bill Schmidt38378a02013-02-01 20:23:10 +00001148 if (defs & ArchDefinePwr4)
Hal Finkel6b984f02012-07-03 16:51:04 +00001149 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt38378a02013-02-01 20:23:10 +00001150 if (defs & ArchDefinePwr5)
Hal Finkel6b984f02012-07-03 16:51:04 +00001151 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt38378a02013-02-01 20:23:10 +00001152 if (defs & ArchDefinePwr5x)
1153 Builder.defineMacro("_ARCH_PWR5X");
1154 if (defs & ArchDefinePwr6)
Hal Finkel8eb59282012-06-11 22:35:19 +00001155 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt38378a02013-02-01 20:23:10 +00001156 if (defs & ArchDefinePwr6x)
1157 Builder.defineMacro("_ARCH_PWR6X");
1158 if (defs & ArchDefinePwr7)
1159 Builder.defineMacro("_ARCH_PWR7");
Will Schmidtf0487512014-06-26 13:34:10 +00001160 if (defs & ArchDefinePwr8)
1161 Builder.defineMacro("_ARCH_PWR8");
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001162 if (defs & ArchDefineA2)
1163 Builder.defineMacro("_ARCH_A2");
1164 if (defs & ArchDefineA2q) {
1165 Builder.defineMacro("_ARCH_A2Q");
1166 Builder.defineMacro("_ARCH_QP");
1167 }
1168
1169 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1170 Builder.defineMacro("__bg__");
1171 Builder.defineMacro("__THW_BLUEGENE__");
1172 Builder.defineMacro("__bgq__");
1173 Builder.defineMacro("__TOS_BGQ__");
1174 }
Bill Schmidt38378a02013-02-01 20:23:10 +00001175
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001176 if (HasVSX)
1177 Builder.defineMacro("__VSX__");
Bill Schmidt8c184e32014-10-10 17:21:23 +00001178 if (HasP8Vector)
Bill Schmidt59eb7672014-10-10 15:09:43 +00001179 Builder.defineMacro("__POWER8_VECTOR__");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001180 if (HasP8Crypto)
1181 Builder.defineMacro("__CRYPTO__");
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001182
Bill Schmidt38378a02013-02-01 20:23:10 +00001183 // FIXME: The following are not yet generated here by Clang, but are
1184 // generated by GCC:
1185 //
1186 // _SOFT_FLOAT_
1187 // __RECIP_PRECISION__
1188 // __APPLE_ALTIVEC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001189 // __RECIP__
1190 // __RECIPF__
1191 // __RSQRTE__
1192 // __RSQRTEF__
1193 // _SOFT_DOUBLE_
1194 // __NO_LWSYNC__
1195 // __HAVE_BSWAP__
1196 // __LONGDOUBLE128
1197 // __CMODEL_MEDIUM__
1198 // __CMODEL_LARGE__
1199 // _CALL_SYSV
1200 // _CALL_DARWIN
1201 // __NO_FPRS__
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001202}
1203
1204void PPCTargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
1205 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1206 .Case("7400", true)
1207 .Case("g4", true)
1208 .Case("7450", true)
1209 .Case("g4+", true)
1210 .Case("970", true)
1211 .Case("g5", true)
1212 .Case("pwr6", true)
1213 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +00001214 .Case("pwr8", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001215 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +00001216 .Case("ppc64le", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001217 .Default(false);
Hal Finkelb58ce852013-02-01 18:44:19 +00001218
1219 Features["qpx"] = (CPU == "a2q");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001220 Features["crypto"] = llvm::StringSwitch<bool>(CPU)
1221 .Case("ppc64le", true)
1222 .Case("pwr8", true)
1223 .Default(false);
1224 Features["power8-vector"] = llvm::StringSwitch<bool>(CPU)
1225 .Case("ppc64le", true)
1226 .Case("pwr8", true)
1227 .Default(false);
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001228}
1229
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001230bool PPCTargetInfo::hasFeature(StringRef Feature) const {
Bill Schmidte6e9d152014-11-02 14:56:41 +00001231 return llvm::StringSwitch<bool>(Feature)
1232 .Case("powerpc", true)
1233 .Case("vsx", HasVSX)
1234 .Case("power8-vector", HasP8Vector)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001235 .Case("crypto", HasP8Crypto)
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001236 .Case("qpx", HasQPX)
Bill Schmidte6e9d152014-11-02 14:56:41 +00001237 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001238}
Chris Lattner17df24e2008-04-21 18:56:49 +00001239
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001240const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001241 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1242 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1243 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1244 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1245 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1246 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1247 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1248 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001249 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001250 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001251 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001252 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1253 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1254 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1255 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001256 "vrsave", "vscr",
1257 "spe_acc", "spefscr",
1258 "sfp"
1259};
Chris Lattner10a5b382007-01-29 05:24:35 +00001260
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001261void PPCTargetInfo::getGCCRegNames(const char * const *&Names,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001262 unsigned &NumNames) const {
1263 Names = GCCRegNames;
1264 NumNames = llvm::array_lengthof(GCCRegNames);
1265}
Chris Lattner5ba61f02006-10-14 07:39:34 +00001266
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001267const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1268 // While some of these aliases do map to different registers
1269 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001270 { { "0" }, "r0" },
1271 { { "1"}, "r1" },
1272 { { "2" }, "r2" },
1273 { { "3" }, "r3" },
1274 { { "4" }, "r4" },
1275 { { "5" }, "r5" },
1276 { { "6" }, "r6" },
1277 { { "7" }, "r7" },
1278 { { "8" }, "r8" },
1279 { { "9" }, "r9" },
1280 { { "10" }, "r10" },
1281 { { "11" }, "r11" },
1282 { { "12" }, "r12" },
1283 { { "13" }, "r13" },
1284 { { "14" }, "r14" },
1285 { { "15" }, "r15" },
1286 { { "16" }, "r16" },
1287 { { "17" }, "r17" },
1288 { { "18" }, "r18" },
1289 { { "19" }, "r19" },
1290 { { "20" }, "r20" },
1291 { { "21" }, "r21" },
1292 { { "22" }, "r22" },
1293 { { "23" }, "r23" },
1294 { { "24" }, "r24" },
1295 { { "25" }, "r25" },
1296 { { "26" }, "r26" },
1297 { { "27" }, "r27" },
1298 { { "28" }, "r28" },
1299 { { "29" }, "r29" },
1300 { { "30" }, "r30" },
1301 { { "31" }, "r31" },
1302 { { "fr0" }, "f0" },
1303 { { "fr1" }, "f1" },
1304 { { "fr2" }, "f2" },
1305 { { "fr3" }, "f3" },
1306 { { "fr4" }, "f4" },
1307 { { "fr5" }, "f5" },
1308 { { "fr6" }, "f6" },
1309 { { "fr7" }, "f7" },
1310 { { "fr8" }, "f8" },
1311 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +00001312 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001313 { { "fr11" }, "f11" },
1314 { { "fr12" }, "f12" },
1315 { { "fr13" }, "f13" },
1316 { { "fr14" }, "f14" },
1317 { { "fr15" }, "f15" },
1318 { { "fr16" }, "f16" },
1319 { { "fr17" }, "f17" },
1320 { { "fr18" }, "f18" },
1321 { { "fr19" }, "f19" },
1322 { { "fr20" }, "f20" },
1323 { { "fr21" }, "f21" },
1324 { { "fr22" }, "f22" },
1325 { { "fr23" }, "f23" },
1326 { { "fr24" }, "f24" },
1327 { { "fr25" }, "f25" },
1328 { { "fr26" }, "f26" },
1329 { { "fr27" }, "f27" },
1330 { { "fr28" }, "f28" },
1331 { { "fr29" }, "f29" },
1332 { { "fr30" }, "f30" },
1333 { { "fr31" }, "f31" },
1334 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001335};
1336
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001337void PPCTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001338 unsigned &NumAliases) const {
1339 Aliases = GCCRegAliases;
1340 NumAliases = llvm::array_lengthof(GCCRegAliases);
1341}
1342} // end anonymous namespace.
Chris Lattner02dffbd2006-10-14 07:50:21 +00001343
Chris Lattner5ba61f02006-10-14 07:39:34 +00001344namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001345class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001346public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001347 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00001348 DescriptionString = "E-m:e-p:32:32-i64:64-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001349
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001350 switch (getTriple().getOS()) {
Nico Weber3435ede2012-01-31 02:07:33 +00001351 case llvm::Triple::Linux:
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001352 case llvm::Triple::FreeBSD:
1353 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001354 SizeType = UnsignedInt;
Hal Finkel26908382012-03-02 20:54:36 +00001355 PtrDiffType = SignedInt;
1356 IntPtrType = SignedInt;
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001357 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +00001358 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001359 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001360 }
Roman Divacky816dcd12012-03-13 16:53:54 +00001361
Roman Divacky3ffe7462012-03-13 19:20:17 +00001362 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1363 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001364 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divacky3ffe7462012-03-13 19:20:17 +00001365 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001366
1367 // PPC32 supports atomics up to 4 bytes.
1368 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divacky965b0b72011-01-06 08:27:10 +00001369 }
1370
Craig Topper3164f332014-03-11 03:39:26 +00001371 BuiltinVaListKind getBuiltinVaListKind() const override {
Roman Divacky965b0b72011-01-06 08:27:10 +00001372 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Inge5d3fb222012-06-16 03:34:49 +00001373 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedman873f65a2008-08-21 00:13:15 +00001374 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001375};
1376} // end anonymous namespace.
1377
Bill Schmidt778d3872013-07-26 01:36:11 +00001378// Note: ABI differences may eventually require us to have a separate
1379// TargetInfo for little endian.
Chris Lattner5ba61f02006-10-14 07:39:34 +00001380namespace {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001381class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001382public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001383 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001384 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001385 IntMaxType = SignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001386 Int64Type = SignedLong;
Roman Divacky816dcd12012-03-13 16:53:54 +00001387
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001388 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1389 DescriptionString = "e-m:e-i64:64-n32:64";
1390 ABI = "elfv2";
1391 } else {
1392 DescriptionString = "E-m:e-i64:64-n32:64";
1393 ABI = "elfv1";
1394 }
1395
1396 switch (getTriple().getOS()) {
1397 case llvm::Triple::FreeBSD:
Roman Divacky3ffe7462012-03-13 19:20:17 +00001398 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001399 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001400 break;
Joerg Sonnenbergeraac82c42014-10-15 19:52:03 +00001401 case llvm::Triple::NetBSD:
1402 IntMaxType = SignedLongLong;
1403 Int64Type = SignedLongLong;
1404 break;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001405 default:
1406 break;
Ulrich Weigand8afad612014-07-28 13:17:52 +00001407 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001408
1409 // PPC64 supports atomics up to 8 bytes.
1410 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001411 }
Craig Topper3164f332014-03-11 03:39:26 +00001412 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001413 return TargetInfo::CharPtrBuiltinVaList;
Roman Divacky965b0b72011-01-06 08:27:10 +00001414 }
Ulrich Weigand8afad612014-07-28 13:17:52 +00001415 // PPC64 Linux-specifc ABI options.
1416 bool setABI(const std::string &Name) override {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001417 if (Name == "elfv1" || Name == "elfv1-qpx" || Name == "elfv2") {
Ulrich Weigand8afad612014-07-28 13:17:52 +00001418 ABI = Name;
1419 return true;
1420 }
1421 return false;
1422 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001423};
1424} // end anonymous namespace.
1425
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001426
1427namespace {
Roman Divacky965b0b72011-01-06 08:27:10 +00001428class DarwinPPC32TargetInfo :
1429 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001430public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001431 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1432 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001433 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +00001434 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopher917e9522014-11-18 22:36:15 +00001435 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev68d773c2012-01-17 22:40:00 +00001436 LongLongAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001437 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001438 DescriptionString = "E-m:o-p:32:32-f64:32:64-n32";
Roman Divacky965b0b72011-01-06 08:27:10 +00001439 }
Craig Topper3164f332014-03-11 03:39:26 +00001440 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001441 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001442 }
1443};
1444
1445class DarwinPPC64TargetInfo :
1446 public DarwinTargetInfo<PPC64TargetInfo> {
1447public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001448 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1449 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001450 HasAlignMac68kSupport = true;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001451 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00001452 DescriptionString = "E-m:o-i64:64-n32:64";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001453 }
1454};
1455} // end anonymous namespace.
1456
Chris Lattner5ba61f02006-10-14 07:39:34 +00001457namespace {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001458 static const unsigned NVPTXAddrSpaceMap[] = {
1459 1, // opencl_global
1460 3, // opencl_local
1461 4, // opencl_constant
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +00001462 // FIXME: generic has to be added to the target
1463 0, // opencl_generic
Peter Collingbournec947aae2012-05-20 23:28:41 +00001464 1, // cuda_device
1465 4, // cuda_constant
1466 3, // cuda_shared
1467 };
1468 class NVPTXTargetInfo : public TargetInfo {
1469 static const char * const GCCRegNames[];
Justin Holewinski83e96682012-05-24 17:43:12 +00001470 static const Builtin::Info BuiltinInfo[];
Reid Klecknerbbc01782014-12-03 21:53:36 +00001471
1472 // The GPU profiles supported by the NVPTX backend
1473 enum GPUKind {
1474 GK_NONE,
1475 GK_SM20,
1476 GK_SM21,
1477 GK_SM30,
1478 GK_SM35,
1479 } GPU;
1480
Peter Collingbournec947aae2012-05-20 23:28:41 +00001481 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001482 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001483 BigEndian = false;
1484 TLSSupported = false;
1485 LongWidth = LongAlign = 64;
1486 AddrSpaceMap = &NVPTXAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001487 UseAddrSpaceMapMangling = true;
Justin Holewinski83e96682012-05-24 17:43:12 +00001488 // Define available target features
1489 // These must be defined in sorted order!
Justin Holewinski5fafdd92012-07-11 15:34:55 +00001490 NoAsmVariants = true;
Reid Klecknerbbc01782014-12-03 21:53:36 +00001491 // Set the default GPU to sm20
1492 GPU = GK_SM20;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001493 }
Craig Topper3164f332014-03-11 03:39:26 +00001494 void getTargetDefines(const LangOptions &Opts,
1495 MacroBuilder &Builder) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001496 Builder.defineMacro("__PTX__");
Justin Holewinski83e96682012-05-24 17:43:12 +00001497 Builder.defineMacro("__NVPTX__");
Reid Klecknerbbc01782014-12-03 21:53:36 +00001498 if (Opts.CUDAIsDevice) {
1499 // Set __CUDA_ARCH__ for the GPU specified.
1500 std::string CUDAArchCode;
1501 switch (GPU) {
1502 case GK_SM20:
1503 CUDAArchCode = "200";
1504 break;
1505 case GK_SM21:
1506 CUDAArchCode = "210";
1507 break;
1508 case GK_SM30:
1509 CUDAArchCode = "300";
1510 break;
1511 case GK_SM35:
1512 CUDAArchCode = "350";
1513 break;
1514 default:
1515 llvm_unreachable("Unhandled target CPU");
1516 }
1517 Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
1518 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001519 }
Craig Topper3164f332014-03-11 03:39:26 +00001520 void getTargetBuiltins(const Builtin::Info *&Records,
1521 unsigned &NumRecords) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001522 Records = BuiltinInfo;
1523 NumRecords = clang::NVPTX::LastTSBuiltin-Builtin::FirstTSBuiltin;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001524 }
Craig Topper3164f332014-03-11 03:39:26 +00001525 bool hasFeature(StringRef Feature) const override {
Justin Holewinski83e96682012-05-24 17:43:12 +00001526 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbournec947aae2012-05-20 23:28:41 +00001527 }
Craig Topper3164f332014-03-11 03:39:26 +00001528
1529 void getGCCRegNames(const char * const *&Names,
1530 unsigned &NumNames) const override;
1531 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1532 unsigned &NumAliases) const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001533 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00001534 Aliases = nullptr;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001535 NumAliases = 0;
1536 }
Eric Christopher917e9522014-11-18 22:36:15 +00001537 bool
1538 validateAsmConstraint(const char *&Name,
1539 TargetInfo::ConstraintInfo &Info) const override {
Justin Holewinski7ceab3a892013-06-21 18:51:24 +00001540 switch (*Name) {
1541 default: return false;
1542 case 'c':
1543 case 'h':
1544 case 'r':
1545 case 'l':
1546 case 'f':
1547 case 'd':
1548 Info.setAllowsRegister();
1549 return true;
1550 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001551 }
Craig Topper3164f332014-03-11 03:39:26 +00001552 const char *getClobbers() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001553 // FIXME: Is this really right?
1554 return "";
1555 }
Craig Topper3164f332014-03-11 03:39:26 +00001556 BuiltinVaListKind getBuiltinVaListKind() const override {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001557 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00001558 return TargetInfo::CharPtrBuiltinVaList;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001559 }
Craig Topper3164f332014-03-11 03:39:26 +00001560 bool setCPU(const std::string &Name) override {
Reid Klecknerbbc01782014-12-03 21:53:36 +00001561 GPU = llvm::StringSwitch<GPUKind>(Name)
1562 .Case("sm_20", GK_SM20)
1563 .Case("sm_21", GK_SM21)
1564 .Case("sm_30", GK_SM30)
1565 .Case("sm_35", GK_SM35)
1566 .Default(GK_NONE);
Justin Holewinski91203e82013-03-30 14:38:26 +00001567
Reid Klecknerbbc01782014-12-03 21:53:36 +00001568 return GPU != GK_NONE;
Peter Collingbournec947aae2012-05-20 23:28:41 +00001569 }
Justin Holewinski83e96682012-05-24 17:43:12 +00001570 };
1571
1572 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1573#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1574#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
1575 ALL_LANGUAGES },
1576#include "clang/Basic/BuiltinsNVPTX.def"
Peter Collingbournec947aae2012-05-20 23:28:41 +00001577 };
1578
1579 const char * const NVPTXTargetInfo::GCCRegNames[] = {
1580 "r0"
1581 };
1582
1583 void NVPTXTargetInfo::getGCCRegNames(const char * const *&Names,
1584 unsigned &NumNames) const {
1585 Names = GCCRegNames;
1586 NumNames = llvm::array_lengthof(GCCRegNames);
1587 }
1588
1589 class NVPTX32TargetInfo : public NVPTXTargetInfo {
1590 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001591 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001592 PointerWidth = PointerAlign = 32;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001593 SizeType = PtrDiffType = TargetInfo::UnsignedInt;
1594 IntPtrType = TargetInfo::SignedInt;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001595 DescriptionString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001596 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001597 };
1598
1599 class NVPTX64TargetInfo : public NVPTXTargetInfo {
1600 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001601 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Peter Collingbournec947aae2012-05-20 23:28:41 +00001602 PointerWidth = PointerAlign = 64;
Joerg Sonnenberger3809a7a2014-07-14 20:40:56 +00001603 SizeType = PtrDiffType = TargetInfo::UnsignedLongLong;
1604 IntPtrType = TargetInfo::SignedLongLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00001605 DescriptionString = "e-i64:64-v16:16-v32:32-n16:32:64";
Justin Holewinski83e96682012-05-24 17:43:12 +00001606 }
Peter Collingbournec947aae2012-05-20 23:28:41 +00001607 };
1608}
1609
1610namespace {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001611
1612static const unsigned R600AddrSpaceMap[] = {
1613 1, // opencl_global
1614 3, // opencl_local
1615 2, // opencl_constant
Matt Arsenaultbfe25b22014-12-01 16:46:03 +00001616 4, // opencl_generic
Eli Friedmand13b41e2012-10-12 23:32:00 +00001617 1, // cuda_device
1618 2, // cuda_constant
1619 3 // cuda_shared
1620};
1621
Tom Stellarda96344b2014-08-21 13:58:40 +00001622// If you edit the description strings, make sure you update
1623// getPointerWidthV().
1624
Tom Stellardc74b1e02013-03-04 17:40:53 +00001625static const char *DescriptionStringR600 =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001626 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1627 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001628
1629static const char *DescriptionStringR600DoubleOps =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001630 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1631 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001632
1633static const char *DescriptionStringSI =
Matt Arsenault23e7b082014-05-22 18:33:55 +00001634 "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 +00001635 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1636 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001637
Eli Friedmand13b41e2012-10-12 23:32:00 +00001638class R600TargetInfo : public TargetInfo {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001639 static const Builtin::Info BuiltinInfo[];
1640
Tom Stellardc74b1e02013-03-04 17:40:53 +00001641 /// \brief The GPU profiles supported by the R600 target.
1642 enum GPUKind {
1643 GK_NONE,
1644 GK_R600,
1645 GK_R600_DOUBLE_OPS,
1646 GK_R700,
1647 GK_R700_DOUBLE_OPS,
1648 GK_EVERGREEN,
1649 GK_EVERGREEN_DOUBLE_OPS,
1650 GK_NORTHERN_ISLANDS,
1651 GK_CAYMAN,
Tom Stellard08ded122013-10-29 16:38:29 +00001652 GK_SOUTHERN_ISLANDS,
1653 GK_SEA_ISLANDS
Tom Stellardc74b1e02013-03-04 17:40:53 +00001654 } GPU;
1655
Eli Friedmand13b41e2012-10-12 23:32:00 +00001656public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001657 R600TargetInfo(const llvm::Triple &Triple)
Tom Stellardd99fb952015-01-28 15:38:44 +00001658 : TargetInfo(Triple) {
1659
1660 if (Triple.getArch() == llvm::Triple::amdgcn) {
1661 DescriptionString = DescriptionStringSI;
1662 GPU = GK_SOUTHERN_ISLANDS;
1663 } else {
1664 DescriptionString = DescriptionStringR600;
1665 GPU = GK_R600;
1666 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001667 AddrSpaceMap = &R600AddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001668 UseAddrSpaceMapMangling = true;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001669 }
1670
Tom Stellarda96344b2014-08-21 13:58:40 +00001671 uint64_t getPointerWidthV(unsigned AddrSpace) const override {
1672 if (GPU <= GK_CAYMAN)
1673 return 32;
1674
1675 switch(AddrSpace) {
1676 default:
1677 return 64;
1678 case 0:
1679 case 3:
1680 case 5:
1681 return 32;
1682 }
1683 }
1684
Craig Topper3164f332014-03-11 03:39:26 +00001685 const char * getClobbers() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001686 return "";
1687 }
1688
Craig Topper3164f332014-03-11 03:39:26 +00001689 void getGCCRegNames(const char * const *&Names,
1690 unsigned &numNames) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001691 Names = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001692 numNames = 0;
1693 }
1694
Craig Topper3164f332014-03-11 03:39:26 +00001695 void getGCCRegAliases(const GCCRegAlias *&Aliases,
1696 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00001697 Aliases = nullptr;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001698 NumAliases = 0;
1699 }
1700
Craig Topper3164f332014-03-11 03:39:26 +00001701 bool validateAsmConstraint(const char *&Name,
1702 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001703 return true;
1704 }
1705
Craig Topper3164f332014-03-11 03:39:26 +00001706 void getTargetBuiltins(const Builtin::Info *&Records,
1707 unsigned &NumRecords) const override {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001708 Records = BuiltinInfo;
1709 NumRecords = clang::R600::LastTSBuiltin - Builtin::FirstTSBuiltin;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001710 }
1711
Craig Topper3164f332014-03-11 03:39:26 +00001712 void getTargetDefines(const LangOptions &Opts,
1713 MacroBuilder &Builder) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001714 Builder.defineMacro("__R600__");
Tom Stellardfded50f2015-02-27 15:10:19 +00001715 if (GPU >= GK_SOUTHERN_ISLANDS && Opts.OpenCL)
1716 Builder.defineMacro("cl_khr_fp64");
Eli Friedmand13b41e2012-10-12 23:32:00 +00001717 }
1718
Craig Topper3164f332014-03-11 03:39:26 +00001719 BuiltinVaListKind getBuiltinVaListKind() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001720 return TargetInfo::CharPtrBuiltinVaList;
1721 }
1722
Craig Topper3164f332014-03-11 03:39:26 +00001723 bool setCPU(const std::string &Name) override {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001724 GPU = llvm::StringSwitch<GPUKind>(Name)
1725 .Case("r600" , GK_R600)
1726 .Case("rv610", GK_R600)
1727 .Case("rv620", GK_R600)
1728 .Case("rv630", GK_R600)
1729 .Case("rv635", GK_R600)
1730 .Case("rs780", GK_R600)
1731 .Case("rs880", GK_R600)
1732 .Case("rv670", GK_R600_DOUBLE_OPS)
1733 .Case("rv710", GK_R700)
1734 .Case("rv730", GK_R700)
1735 .Case("rv740", GK_R700_DOUBLE_OPS)
1736 .Case("rv770", GK_R700_DOUBLE_OPS)
1737 .Case("palm", GK_EVERGREEN)
1738 .Case("cedar", GK_EVERGREEN)
1739 .Case("sumo", GK_EVERGREEN)
1740 .Case("sumo2", GK_EVERGREEN)
1741 .Case("redwood", GK_EVERGREEN)
1742 .Case("juniper", GK_EVERGREEN)
1743 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1744 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1745 .Case("barts", GK_NORTHERN_ISLANDS)
1746 .Case("turks", GK_NORTHERN_ISLANDS)
1747 .Case("caicos", GK_NORTHERN_ISLANDS)
1748 .Case("cayman", GK_CAYMAN)
1749 .Case("aruba", GK_CAYMAN)
Tom Stellard785699322013-04-01 20:56:49 +00001750 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001751 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1752 .Case("verde", GK_SOUTHERN_ISLANDS)
1753 .Case("oland", GK_SOUTHERN_ISLANDS)
Tom Stellard9affba42014-08-21 13:58:38 +00001754 .Case("hainan", GK_SOUTHERN_ISLANDS)
Tom Stellard08ded122013-10-29 16:38:29 +00001755 .Case("bonaire", GK_SEA_ISLANDS)
1756 .Case("kabini", GK_SEA_ISLANDS)
1757 .Case("kaveri", GK_SEA_ISLANDS)
Tom Stellard55583042013-11-14 23:45:53 +00001758 .Case("hawaii", GK_SEA_ISLANDS)
Tom Stellard14e03962014-07-26 01:05:20 +00001759 .Case("mullins", GK_SEA_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001760 .Default(GK_NONE);
1761
1762 if (GPU == GK_NONE) {
1763 return false;
1764 }
1765
1766 // Set the correct data layout
1767 switch (GPU) {
1768 case GK_NONE:
1769 case GK_R600:
1770 case GK_R700:
1771 case GK_EVERGREEN:
1772 case GK_NORTHERN_ISLANDS:
1773 DescriptionString = DescriptionStringR600;
1774 break;
1775 case GK_R600_DOUBLE_OPS:
1776 case GK_R700_DOUBLE_OPS:
1777 case GK_EVERGREEN_DOUBLE_OPS:
1778 case GK_CAYMAN:
1779 DescriptionString = DescriptionStringR600DoubleOps;
1780 break;
1781 case GK_SOUTHERN_ISLANDS:
Tom Stellard08ded122013-10-29 16:38:29 +00001782 case GK_SEA_ISLANDS:
Tom Stellardc74b1e02013-03-04 17:40:53 +00001783 DescriptionString = DescriptionStringSI;
1784 break;
1785 }
1786
1787 return true;
1788 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001789};
1790
Matt Arsenault56f008d2014-06-24 20:45:01 +00001791const Builtin::Info R600TargetInfo::BuiltinInfo[] = {
1792#define BUILTIN(ID, TYPE, ATTRS) \
1793 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
1794#include "clang/Basic/BuiltinsR600.def"
1795};
1796
Eli Friedmand13b41e2012-10-12 23:32:00 +00001797} // end anonymous namespace
1798
1799namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001800// Namespace for x86 abstract base class
1801const Builtin::Info BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001802#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00001803#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00001804 ALL_LANGUAGES },
Chris Lattner5abdec72009-06-14 01:05:48 +00001805#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00001806};
Eli Friedmanb5366062008-05-20 14:21:01 +00001807
Nuno Lopescfca1f02009-12-23 17:49:57 +00001808static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00001809 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
1810 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00001811 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001812 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
1813 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
1814 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00001815 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00001816 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
1817 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00001818};
1819
Eric Christophercdd36352011-06-21 00:05:20 +00001820const TargetInfo::AddlRegName AddlRegNames[] = {
1821 { { "al", "ah", "eax", "rax" }, 0 },
1822 { { "bl", "bh", "ebx", "rbx" }, 3 },
1823 { { "cl", "ch", "ecx", "rcx" }, 2 },
1824 { { "dl", "dh", "edx", "rdx" }, 1 },
1825 { { "esi", "rsi" }, 4 },
1826 { { "edi", "rdi" }, 5 },
1827 { { "esp", "rsp" }, 7 },
1828 { { "ebp", "rbp" }, 6 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00001829};
1830
1831// X86 target abstract base class; x86-32 and x86-64 are very close, so
1832// most of the implementation can be shared.
1833class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00001834 enum X86SSEEnum {
Craig Topper9c4d17f2013-08-21 03:59:22 +00001835 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Chris Lattner96e43572009-03-02 22:40:39 +00001836 } SSELevel;
Eli Friedman33465822011-07-08 23:31:17 +00001837 enum MMX3DNowEnum {
1838 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
1839 } MMX3DNowLevel;
Rafael Espindolae62e2792013-08-20 13:44:29 +00001840 enum XOPEnum {
1841 NoXOP,
1842 SSE4A,
1843 FMA4,
1844 XOP
1845 } XOPLevel;
Anders Carlssone437c682010-01-27 03:47:49 +00001846
Eric Christophere1ddaf92010-04-02 23:50:19 +00001847 bool HasAES;
Craig Topper3f122a72012-05-31 05:18:48 +00001848 bool HasPCLMUL;
Craig Topper22967d42011-12-25 05:06:45 +00001849 bool HasLZCNT;
Benjamin Kramer1e250392012-07-07 09:39:18 +00001850 bool HasRDRND;
Craig Topper8c7f2512014-11-03 06:51:41 +00001851 bool HasFSGSBASE;
Craig Topper22967d42011-12-25 05:06:45 +00001852 bool HasBMI;
1853 bool HasBMI2;
Craig Topper1de83482011-12-29 16:10:46 +00001854 bool HasPOPCNT;
Michael Liao625a8752012-11-10 05:17:46 +00001855 bool HasRTM;
Michael Liao74f4eaf2013-03-26 17:52:08 +00001856 bool HasPRFCHW;
Michael Liaoffaae352013-03-29 05:17:55 +00001857 bool HasRDSEED;
Robert Khasanov50e6f582014-09-19 09:53:48 +00001858 bool HasADX;
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00001859 bool HasTBM;
Craig Topperbba778b2012-06-03 21:46:30 +00001860 bool HasFMA;
Manman Rena45358c2012-10-11 00:59:55 +00001861 bool HasF16C;
Eric Christopher917e9522014-11-18 22:36:15 +00001862 bool HasAVX512CD, HasAVX512ER, HasAVX512PF, HasAVX512DQ, HasAVX512BW,
1863 HasAVX512VL;
Ben Langmuir58078d02013-09-19 13:22:04 +00001864 bool HasSHA;
Nick Lewycky50e8f482013-10-05 20:14:27 +00001865 bool HasCX16;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00001866
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001867 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
1868 ///
1869 /// Each enumeration represents a particular CPU supported by Clang. These
1870 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
1871 enum CPUKind {
1872 CK_Generic,
1873
1874 /// \name i386
1875 /// i386-generation processors.
1876 //@{
1877 CK_i386,
1878 //@}
1879
1880 /// \name i486
1881 /// i486-generation processors.
1882 //@{
1883 CK_i486,
1884 CK_WinChipC6,
1885 CK_WinChip2,
1886 CK_C3,
1887 //@}
1888
1889 /// \name i586
1890 /// i586-generation processors, P5 microarchitecture based.
1891 //@{
1892 CK_i586,
1893 CK_Pentium,
1894 CK_PentiumMMX,
1895 //@}
1896
1897 /// \name i686
1898 /// i686-generation processors, P6 / Pentium M microarchitecture based.
1899 //@{
1900 CK_i686,
1901 CK_PentiumPro,
1902 CK_Pentium2,
1903 CK_Pentium3,
1904 CK_Pentium3M,
1905 CK_PentiumM,
1906 CK_C3_2,
1907
1908 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
1909 /// Clang however has some logic to suport this.
1910 // FIXME: Warn, deprecate, and potentially remove this.
1911 CK_Yonah,
1912 //@}
1913
1914 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00001915 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001916 //@{
1917 CK_Pentium4,
1918 CK_Pentium4M,
1919 CK_Prescott,
1920 CK_Nocona,
1921 //@}
1922
1923 /// \name Core
1924 /// Core microarchitecture based processors.
1925 //@{
1926 CK_Core2,
1927
1928 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
1929 /// codename which GCC no longer accepts as an option to -march, but Clang
1930 /// has some logic for recognizing it.
1931 // FIXME: Warn, deprecate, and potentially remove this.
1932 CK_Penryn,
1933 //@}
1934
1935 /// \name Atom
1936 /// Atom processors
1937 //@{
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00001938 CK_Bonnell,
Preston Gurda3c58c02013-09-13 19:27:17 +00001939 CK_Silvermont,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001940 //@}
1941
1942 /// \name Nehalem
1943 /// Nehalem microarchitecture based processors.
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00001944 CK_Nehalem,
1945
1946 /// \name Westmere
1947 /// Westmere microarchitecture based processors.
1948 CK_Westmere,
1949
1950 /// \name Sandy Bridge
1951 /// Sandy Bridge microarchitecture based processors.
1952 CK_SandyBridge,
1953
1954 /// \name Ivy Bridge
1955 /// Ivy Bridge microarchitecture based processors.
1956 CK_IvyBridge,
1957
1958 /// \name Haswell
1959 /// Haswell microarchitecture based processors.
1960 CK_Haswell,
1961
1962 /// \name Broadwell
1963 /// Broadwell microarchitecture based processors.
Robert Khasanov50e6f582014-09-19 09:53:48 +00001964 CK_Broadwell,
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00001965
1966 /// \name Skylake
1967 /// Skylake microarchitecture based processors.
1968 CK_Skylake,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001969
Craig Topper449314e2013-08-20 07:09:39 +00001970 /// \name Knights Landing
1971 /// Knights Landing processor.
1972 CK_KNL,
1973
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00001974 /// \name K6
1975 /// K6 architecture processors.
1976 //@{
1977 CK_K6,
1978 CK_K6_2,
1979 CK_K6_3,
1980 //@}
1981
1982 /// \name K7
1983 /// K7 architecture processors.
1984 //@{
1985 CK_Athlon,
1986 CK_AthlonThunderbird,
1987 CK_Athlon4,
1988 CK_AthlonXP,
1989 CK_AthlonMP,
1990 //@}
1991
1992 /// \name K8
1993 /// K8 architecture processors.
1994 //@{
1995 CK_Athlon64,
1996 CK_Athlon64SSE3,
1997 CK_AthlonFX,
1998 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00001999 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002000 CK_Opteron,
2001 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00002002 CK_AMDFAM10,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002003 //@}
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002004
Benjamin Kramer569f2152012-01-10 11:50:18 +00002005 /// \name Bobcat
2006 /// Bobcat architecture processors.
2007 //@{
2008 CK_BTVER1,
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002009 CK_BTVER2,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002010 //@}
2011
2012 /// \name Bulldozer
2013 /// Bulldozer architecture processors.
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002014 //@{
2015 CK_BDVER1,
2016 CK_BDVER2,
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002017 CK_BDVER3,
Benjamin Kramer56c58222014-05-02 15:47:51 +00002018 CK_BDVER4,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002019 //@}
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002020
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002021 /// This specification is deprecated and will be removed in the future.
2022 /// Users should prefer \see CK_K8.
2023 // FIXME: Warn on this when the CPU is set to it.
Saleem Abdulrasoolcb29c1a2014-11-17 18:40:15 +00002024 //@{
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002025 CK_x86_64,
2026 //@}
2027
2028 /// \name Geode
2029 /// Geode processors.
2030 //@{
2031 CK_Geode
2032 //@}
Chandler Carruth212334f2011-09-28 08:55:37 +00002033 } CPU;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002034
Rafael Espindolaeb265472013-08-21 21:59:03 +00002035 enum FPMathKind {
2036 FP_Default,
2037 FP_SSE,
2038 FP_387
2039 } FPMath;
2040
Eli Friedman3fd920a2008-08-20 02:34:37 +00002041public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00002042 X86TargetInfo(const llvm::Triple &Triple)
2043 : TargetInfo(Triple), SSELevel(NoSSE), MMX3DNowLevel(NoMMX3DNow),
Rafael Espindolae62e2792013-08-20 13:44:29 +00002044 XOPLevel(NoXOP), HasAES(false), HasPCLMUL(false), HasLZCNT(false),
Craig Topper8c7f2512014-11-03 06:51:41 +00002045 HasRDRND(false), HasFSGSBASE(false), HasBMI(false), HasBMI2(false),
2046 HasPOPCNT(false), HasRTM(false), HasPRFCHW(false), HasRDSEED(false),
2047 HasADX(false), HasTBM(false), HasFMA(false), HasF16C(false),
2048 HasAVX512CD(false), HasAVX512ER(false), HasAVX512PF(false),
2049 HasAVX512DQ(false), HasAVX512BW(false), HasAVX512VL(false),
2050 HasSHA(false), HasCX16(false), CPU(CK_Generic), FPMath(FP_Default) {
Eli Friedman803acb32011-12-22 03:51:45 +00002051 BigEndian = false;
Eli Friedman3fd920a2008-08-20 02:34:37 +00002052 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00002053 }
Craig Topper3164f332014-03-11 03:39:26 +00002054 unsigned getFloatEvalMethod() const override {
Benjamin Kramercf501472011-12-28 15:47:06 +00002055 // X87 evaluates with 80 bits "long double" precision.
2056 return SSELevel == NoSSE ? 2 : 0;
2057 }
Craig Topper3164f332014-03-11 03:39:26 +00002058 void getTargetBuiltins(const Builtin::Info *&Records,
2059 unsigned &NumRecords) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002060 Records = BuiltinInfo;
2061 NumRecords = clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner10a5b382007-01-29 05:24:35 +00002062 }
Craig Topper3164f332014-03-11 03:39:26 +00002063 void getGCCRegNames(const char * const *&Names,
2064 unsigned &NumNames) const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002065 Names = GCCRegNames;
2066 NumNames = llvm::array_lengthof(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00002067 }
Craig Topper3164f332014-03-11 03:39:26 +00002068 void getGCCRegAliases(const GCCRegAlias *&Aliases,
2069 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00002070 Aliases = nullptr;
Eric Christophercdd36352011-06-21 00:05:20 +00002071 NumAliases = 0;
2072 }
Craig Topper3164f332014-03-11 03:39:26 +00002073 void getGCCAddlRegNames(const AddlRegName *&Names,
2074 unsigned &NumNames) const override {
Eric Christophercdd36352011-06-21 00:05:20 +00002075 Names = AddlRegNames;
2076 NumNames = llvm::array_lengthof(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00002077 }
Craig Topper3164f332014-03-11 03:39:26 +00002078 bool validateAsmConstraint(const char *&Name,
Eric Christopher917e9522014-11-18 22:36:15 +00002079 TargetInfo::ConstraintInfo &info) const override;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002080
Akira Hatanaka974131e2014-09-18 18:17:18 +00002081 bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
2082
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002083 bool validateInputSize(StringRef Constraint, unsigned Size) const override;
2084
Akira Hatanaka974131e2014-09-18 18:17:18 +00002085 virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
2086
Craig Topper3164f332014-03-11 03:39:26 +00002087 std::string convertConstraint(const char *&Constraint) const override;
2088 const char *getClobbers() const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002089 return "~{dirflag},~{fpsr},~{flags}";
2090 }
Craig Topper3164f332014-03-11 03:39:26 +00002091 void getTargetDefines(const LangOptions &Opts,
2092 MacroBuilder &Builder) const override;
Craig Topper13f61a62013-09-17 04:12:55 +00002093 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
2094 bool Enabled);
2095 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
2096 bool Enabled);
2097 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2098 bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00002099 void setFeatureEnabled(llvm::StringMap<bool> &Features,
2100 StringRef Name, bool Enabled) const override {
Craig Topper86d79ef2013-09-17 04:51:29 +00002101 setFeatureEnabledImpl(Features, Name, Enabled);
2102 }
2103 // This exists purely to cut down on the number of virtual calls in
2104 // getDefaultFeatures which calls this repeatedly.
2105 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2106 StringRef Name, bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00002107 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override;
2108 bool hasFeature(StringRef Feature) const override;
2109 bool handleTargetFeatures(std::vector<std::string> &Features,
2110 DiagnosticsEngine &Diags) override;
Alp Toker4925ba72014-06-07 23:30:42 +00002111 StringRef getABI() const override {
Derek Schuffc7dd7222012-10-11 15:52:22 +00002112 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00002113 return "avx";
Derek Schuffc7dd7222012-10-11 15:52:22 +00002114 else if (getTriple().getArch() == llvm::Triple::x86 &&
2115 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00002116 return "no-mmx";
2117 return "";
Eli Friedman33465822011-07-08 23:31:17 +00002118 }
Craig Topper3164f332014-03-11 03:39:26 +00002119 bool setCPU(const std::string &Name) override {
Chandler Carruth212334f2011-09-28 08:55:37 +00002120 CPU = llvm::StringSwitch<CPUKind>(Name)
2121 .Case("i386", CK_i386)
2122 .Case("i486", CK_i486)
2123 .Case("winchip-c6", CK_WinChipC6)
2124 .Case("winchip2", CK_WinChip2)
2125 .Case("c3", CK_C3)
2126 .Case("i586", CK_i586)
2127 .Case("pentium", CK_Pentium)
2128 .Case("pentium-mmx", CK_PentiumMMX)
2129 .Case("i686", CK_i686)
2130 .Case("pentiumpro", CK_PentiumPro)
2131 .Case("pentium2", CK_Pentium2)
2132 .Case("pentium3", CK_Pentium3)
2133 .Case("pentium3m", CK_Pentium3M)
2134 .Case("pentium-m", CK_PentiumM)
2135 .Case("c3-2", CK_C3_2)
2136 .Case("yonah", CK_Yonah)
2137 .Case("pentium4", CK_Pentium4)
2138 .Case("pentium4m", CK_Pentium4M)
2139 .Case("prescott", CK_Prescott)
2140 .Case("nocona", CK_Nocona)
2141 .Case("core2", CK_Core2)
2142 .Case("penryn", CK_Penryn)
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002143 .Case("bonnell", CK_Bonnell)
2144 .Case("atom", CK_Bonnell) // Legacy name.
2145 .Case("silvermont", CK_Silvermont)
2146 .Case("slm", CK_Silvermont) // Legacy name.
2147 .Case("nehalem", CK_Nehalem)
2148 .Case("corei7", CK_Nehalem) // Legacy name.
2149 .Case("westmere", CK_Westmere)
2150 .Case("sandybridge", CK_SandyBridge)
2151 .Case("corei7-avx", CK_SandyBridge) // Legacy name.
2152 .Case("ivybridge", CK_IvyBridge)
2153 .Case("core-avx-i", CK_IvyBridge) // Legacy name.
2154 .Case("haswell", CK_Haswell)
2155 .Case("core-avx2", CK_Haswell) // Legacy name.
Robert Khasanov50e6f582014-09-19 09:53:48 +00002156 .Case("broadwell", CK_Broadwell)
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002157 .Case("skylake", CK_Skylake)
2158 .Case("skx", CK_Skylake) // Legacy name.
Craig Topper449314e2013-08-20 07:09:39 +00002159 .Case("knl", CK_KNL)
Chandler Carruth212334f2011-09-28 08:55:37 +00002160 .Case("k6", CK_K6)
2161 .Case("k6-2", CK_K6_2)
2162 .Case("k6-3", CK_K6_3)
2163 .Case("athlon", CK_Athlon)
2164 .Case("athlon-tbird", CK_AthlonThunderbird)
2165 .Case("athlon-4", CK_Athlon4)
2166 .Case("athlon-xp", CK_AthlonXP)
2167 .Case("athlon-mp", CK_AthlonMP)
2168 .Case("athlon64", CK_Athlon64)
2169 .Case("athlon64-sse3", CK_Athlon64SSE3)
2170 .Case("athlon-fx", CK_AthlonFX)
2171 .Case("k8", CK_K8)
2172 .Case("k8-sse3", CK_K8SSE3)
2173 .Case("opteron", CK_Opteron)
2174 .Case("opteron-sse3", CK_OpteronSSE3)
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002175 .Case("barcelona", CK_AMDFAM10)
Roman Divacky43eb6f82011-10-30 07:48:46 +00002176 .Case("amdfam10", CK_AMDFAM10)
Benjamin Kramer569f2152012-01-10 11:50:18 +00002177 .Case("btver1", CK_BTVER1)
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002178 .Case("btver2", CK_BTVER2)
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002179 .Case("bdver1", CK_BDVER1)
2180 .Case("bdver2", CK_BDVER2)
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002181 .Case("bdver3", CK_BDVER3)
Benjamin Kramer56c58222014-05-02 15:47:51 +00002182 .Case("bdver4", CK_BDVER4)
Chandler Carruth212334f2011-09-28 08:55:37 +00002183 .Case("x86-64", CK_x86_64)
2184 .Case("geode", CK_Geode)
2185 .Default(CK_Generic);
2186
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002187 // Perform any per-CPU checks necessary to determine if this CPU is
2188 // acceptable.
2189 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
2190 // invalid without explaining *why*.
2191 switch (CPU) {
2192 case CK_Generic:
2193 // No processor selected!
2194 return false;
2195
2196 case CK_i386:
2197 case CK_i486:
2198 case CK_WinChipC6:
2199 case CK_WinChip2:
2200 case CK_C3:
2201 case CK_i586:
2202 case CK_Pentium:
2203 case CK_PentiumMMX:
2204 case CK_i686:
2205 case CK_PentiumPro:
2206 case CK_Pentium2:
2207 case CK_Pentium3:
2208 case CK_Pentium3M:
2209 case CK_PentiumM:
2210 case CK_Yonah:
2211 case CK_C3_2:
2212 case CK_Pentium4:
2213 case CK_Pentium4M:
2214 case CK_Prescott:
2215 case CK_K6:
2216 case CK_K6_2:
2217 case CK_K6_3:
2218 case CK_Athlon:
2219 case CK_AthlonThunderbird:
2220 case CK_Athlon4:
2221 case CK_AthlonXP:
2222 case CK_AthlonMP:
2223 case CK_Geode:
2224 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002225 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002226 return false;
2227
2228 // Fallthrough
2229 case CK_Nocona:
2230 case CK_Core2:
2231 case CK_Penryn:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002232 case CK_Bonnell:
Preston Gurda3c58c02013-09-13 19:27:17 +00002233 case CK_Silvermont:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002234 case CK_Nehalem:
2235 case CK_Westmere:
2236 case CK_SandyBridge:
2237 case CK_IvyBridge:
2238 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00002239 case CK_Broadwell:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002240 case CK_Skylake:
Craig Topper449314e2013-08-20 07:09:39 +00002241 case CK_KNL:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002242 case CK_Athlon64:
2243 case CK_Athlon64SSE3:
2244 case CK_AthlonFX:
2245 case CK_K8:
2246 case CK_K8SSE3:
2247 case CK_Opteron:
2248 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00002249 case CK_AMDFAM10:
Benjamin Kramer569f2152012-01-10 11:50:18 +00002250 case CK_BTVER1:
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002251 case CK_BTVER2:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002252 case CK_BDVER1:
2253 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002254 case CK_BDVER3:
Benjamin Kramer56c58222014-05-02 15:47:51 +00002255 case CK_BDVER4:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002256 case CK_x86_64:
2257 return true;
2258 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00002259 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002260 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002261
Craig Topper3164f332014-03-11 03:39:26 +00002262 bool setFPMath(StringRef Name) override;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002263
Craig Topper3164f332014-03-11 03:39:26 +00002264 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002265 // We accept all non-ARM calling conventions
2266 return (CC == CC_X86ThisCall ||
2267 CC == CC_X86FastCall ||
Reid Klecknerd7857f02014-10-24 17:42:17 +00002268 CC == CC_X86StdCall ||
2269 CC == CC_X86VectorCall ||
2270 CC == CC_C ||
Guy Benyeif0a014b2012-12-25 08:53:55 +00002271 CC == CC_X86Pascal ||
2272 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002273 }
2274
Craig Topper3164f332014-03-11 03:39:26 +00002275 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00002276 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002277 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +00002278
2279 bool hasSjLjLowering() const override {
2280 return true;
2281 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00002282};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002283
Rafael Espindolaeb265472013-08-21 21:59:03 +00002284bool X86TargetInfo::setFPMath(StringRef Name) {
2285 if (Name == "387") {
2286 FPMath = FP_387;
2287 return true;
2288 }
2289 if (Name == "sse") {
2290 FPMath = FP_SSE;
2291 return true;
2292 }
2293 return false;
2294}
2295
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00002296void X86TargetInfo::getDefaultFeatures(llvm::StringMap<bool> &Features) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002297 // FIXME: This *really* should not be here.
2298
2299 // X86_64 always has SSE2.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002300 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper86d79ef2013-09-17 04:51:29 +00002301 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002302
Chandler Carruth212334f2011-09-28 08:55:37 +00002303 switch (CPU) {
2304 case CK_Generic:
2305 case CK_i386:
2306 case CK_i486:
2307 case CK_i586:
2308 case CK_Pentium:
2309 case CK_i686:
2310 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00002311 break;
2312 case CK_PentiumMMX:
2313 case CK_Pentium2:
Craig Topperdb4dc082014-11-06 05:52:19 +00002314 case CK_K6:
2315 case CK_WinChipC6:
Craig Topper86d79ef2013-09-17 04:51:29 +00002316 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002317 break;
2318 case CK_Pentium3:
2319 case CK_Pentium3M:
Craig Topperdb4dc082014-11-06 05:52:19 +00002320 case CK_C3_2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002321 setFeatureEnabledImpl(Features, "sse", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002322 break;
2323 case CK_PentiumM:
2324 case CK_Pentium4:
2325 case CK_Pentium4M:
2326 case CK_x86_64:
Craig Topper86d79ef2013-09-17 04:51:29 +00002327 setFeatureEnabledImpl(Features, "sse2", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002328 break;
2329 case CK_Yonah:
2330 case CK_Prescott:
2331 case CK_Nocona:
Craig Topper86d79ef2013-09-17 04:51:29 +00002332 setFeatureEnabledImpl(Features, "sse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002333 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002334 break;
2335 case CK_Core2:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002336 case CK_Bonnell:
Craig Topper86d79ef2013-09-17 04:51:29 +00002337 setFeatureEnabledImpl(Features, "ssse3", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002338 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002339 break;
2340 case CK_Penryn:
Craig Topper86d79ef2013-09-17 04:51:29 +00002341 setFeatureEnabledImpl(Features, "sse4.1", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002342 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002343 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002344 case CK_Skylake:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002345 setFeatureEnabledImpl(Features, "avx512f", true);
2346 setFeatureEnabledImpl(Features, "avx512cd", true);
2347 setFeatureEnabledImpl(Features, "avx512dq", true);
2348 setFeatureEnabledImpl(Features, "avx512bw", true);
2349 setFeatureEnabledImpl(Features, "avx512vl", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002350 // FALLTHROUGH
2351 case CK_Broadwell:
2352 setFeatureEnabledImpl(Features, "rdseed", true);
2353 setFeatureEnabledImpl(Features, "adx", true);
2354 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002355 case CK_Haswell:
Craig Topperdb4dc082014-11-06 05:52:19 +00002356 setFeatureEnabledImpl(Features, "avx2", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002357 setFeatureEnabledImpl(Features, "lzcnt", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002358 setFeatureEnabledImpl(Features, "bmi", true);
2359 setFeatureEnabledImpl(Features, "bmi2", true);
2360 setFeatureEnabledImpl(Features, "rtm", true);
2361 setFeatureEnabledImpl(Features, "fma", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002362 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002363 case CK_IvyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00002364 setFeatureEnabledImpl(Features, "rdrnd", true);
2365 setFeatureEnabledImpl(Features, "f16c", true);
2366 setFeatureEnabledImpl(Features, "fsgsbase", true);
2367 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002368 case CK_SandyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00002369 setFeatureEnabledImpl(Features, "avx", true);
2370 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002371 case CK_Westmere:
Craig Topperdb4dc082014-11-06 05:52:19 +00002372 case CK_Silvermont:
2373 setFeatureEnabledImpl(Features, "aes", true);
2374 setFeatureEnabledImpl(Features, "pclmul", true);
2375 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002376 case CK_Nehalem:
Craig Topperdb4dc082014-11-06 05:52:19 +00002377 setFeatureEnabledImpl(Features, "sse4.2", true);
2378 setFeatureEnabledImpl(Features, "cx16", true);
2379 break;
2380 case CK_KNL:
2381 setFeatureEnabledImpl(Features, "avx512f", true);
2382 setFeatureEnabledImpl(Features, "avx512cd", true);
2383 setFeatureEnabledImpl(Features, "avx512er", true);
2384 setFeatureEnabledImpl(Features, "avx512pf", true);
Robert Khasanov50e6f582014-09-19 09:53:48 +00002385 setFeatureEnabledImpl(Features, "rdseed", true);
2386 setFeatureEnabledImpl(Features, "adx", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002387 setFeatureEnabledImpl(Features, "lzcnt", true);
2388 setFeatureEnabledImpl(Features, "bmi", true);
2389 setFeatureEnabledImpl(Features, "bmi2", true);
2390 setFeatureEnabledImpl(Features, "rtm", true);
2391 setFeatureEnabledImpl(Features, "fma", true);
2392 setFeatureEnabledImpl(Features, "rdrnd", true);
2393 setFeatureEnabledImpl(Features, "f16c", true);
2394 setFeatureEnabledImpl(Features, "fsgsbase", true);
2395 setFeatureEnabledImpl(Features, "aes", true);
2396 setFeatureEnabledImpl(Features, "pclmul", true);
2397 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002398 break;
2399 case CK_K6_2:
2400 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00002401 case CK_WinChip2:
2402 case CK_C3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002403 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002404 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002405 case CK_Athlon:
2406 case CK_AthlonThunderbird:
2407 case CK_Geode:
Craig Topper86d79ef2013-09-17 04:51:29 +00002408 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002409 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002410 case CK_Athlon4:
2411 case CK_AthlonXP:
2412 case CK_AthlonMP:
Craig Topper86d79ef2013-09-17 04:51:29 +00002413 setFeatureEnabledImpl(Features, "sse", true);
2414 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002415 break;
2416 case CK_K8:
2417 case CK_Opteron:
2418 case CK_Athlon64:
2419 case CK_AthlonFX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002420 setFeatureEnabledImpl(Features, "sse2", true);
2421 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002422 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00002423 case CK_AMDFAM10:
2424 setFeatureEnabledImpl(Features, "sse4a", true);
2425 setFeatureEnabledImpl(Features, "lzcnt", true);
2426 setFeatureEnabledImpl(Features, "popcnt", true);
2427 // FALLTHROUGH
Chandler Carruth212334f2011-09-28 08:55:37 +00002428 case CK_K8SSE3:
2429 case CK_OpteronSSE3:
2430 case CK_Athlon64SSE3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002431 setFeatureEnabledImpl(Features, "sse3", true);
2432 setFeatureEnabledImpl(Features, "3dnowa", true);
Roman Divackyce253d82011-10-30 13:47:56 +00002433 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00002434 case CK_BTVER2:
2435 setFeatureEnabledImpl(Features, "avx", true);
2436 setFeatureEnabledImpl(Features, "aes", true);
2437 setFeatureEnabledImpl(Features, "pclmul", true);
2438 setFeatureEnabledImpl(Features, "bmi", true);
2439 setFeatureEnabledImpl(Features, "f16c", true);
2440 // FALLTHROUGH
Benjamin Kramer569f2152012-01-10 11:50:18 +00002441 case CK_BTVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002442 setFeatureEnabledImpl(Features, "ssse3", true);
2443 setFeatureEnabledImpl(Features, "sse4a", true);
2444 setFeatureEnabledImpl(Features, "lzcnt", true);
2445 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002446 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002447 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002448 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002449 case CK_BDVER4:
2450 setFeatureEnabledImpl(Features, "avx2", true);
2451 setFeatureEnabledImpl(Features, "bmi2", true);
2452 // FALLTHROUGH
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002453 case CK_BDVER3:
Craig Topper8c7f2512014-11-03 06:51:41 +00002454 setFeatureEnabledImpl(Features, "fsgsbase", true);
2455 // FALLTHROUGH
2456 case CK_BDVER2:
Andrea Di Biagio9760a442014-11-06 12:08:57 +00002457 setFeatureEnabledImpl(Features, "bmi", true);
2458 setFeatureEnabledImpl(Features, "fma", true);
2459 setFeatureEnabledImpl(Features, "f16c", true);
2460 setFeatureEnabledImpl(Features, "tbm", true);
2461 // FALLTHROUGH
2462 case CK_BDVER1:
2463 // xop implies avx, sse4a and fma4.
Craig Topper86d79ef2013-09-17 04:51:29 +00002464 setFeatureEnabledImpl(Features, "xop", true);
2465 setFeatureEnabledImpl(Features, "lzcnt", true);
2466 setFeatureEnabledImpl(Features, "aes", true);
2467 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002468 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002469 setFeatureEnabledImpl(Features, "cx16", true);
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002470 break;
Eli Friedman33465822011-07-08 23:31:17 +00002471 }
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002472}
2473
Rafael Espindolae62e2792013-08-20 13:44:29 +00002474void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002475 X86SSEEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002476 if (Enabled) {
2477 switch (Level) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002478 case AVX512F:
2479 Features["avx512f"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002480 case AVX2:
2481 Features["avx2"] = true;
2482 case AVX:
2483 Features["avx"] = true;
2484 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002485 Features["sse4.2"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002486 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002487 Features["sse4.1"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002488 case SSSE3:
2489 Features["ssse3"] = true;
2490 case SSE3:
2491 Features["sse3"] = true;
2492 case SSE2:
2493 Features["sse2"] = true;
2494 case SSE1:
Rafael Espindolae62e2792013-08-20 13:44:29 +00002495 Features["sse"] = true;
2496 case NoSSE:
2497 break;
2498 }
2499 return;
2500 }
2501
2502 switch (Level) {
2503 case NoSSE:
2504 case SSE1:
2505 Features["sse"] = false;
2506 case SSE2:
Ben Langmuir58078d02013-09-19 13:22:04 +00002507 Features["sse2"] = Features["pclmul"] = Features["aes"] =
2508 Features["sha"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002509 case SSE3:
2510 Features["sse3"] = false;
2511 setXOPLevel(Features, NoXOP, false);
2512 case SSSE3:
2513 Features["ssse3"] = false;
2514 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002515 Features["sse4.1"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002516 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002517 Features["sse4.2"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002518 case AVX:
Craig Topper31db3a22013-09-16 04:54:13 +00002519 Features["fma"] = Features["avx"] = Features["f16c"] = false;
Rafael Espindola0221d862013-08-21 13:28:02 +00002520 setXOPLevel(Features, FMA4, false);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002521 case AVX2:
2522 Features["avx2"] = false;
Craig Topper9c4d17f2013-08-21 03:59:22 +00002523 case AVX512F:
Eric Christopher917e9522014-11-18 22:36:15 +00002524 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
Craig Toppera31a5da2014-12-27 06:59:37 +00002525 Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] =
2526 Features["avx512vl"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002527 }
2528}
2529
2530void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002531 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002532 if (Enabled) {
2533 switch (Level) {
2534 case AMD3DNowAthlon:
2535 Features["3dnowa"] = true;
2536 case AMD3DNow:
2537 Features["3dnow"] = true;
2538 case MMX:
2539 Features["mmx"] = true;
2540 case NoMMX3DNow:
2541 break;
2542 }
2543 return;
2544 }
2545
2546 switch (Level) {
2547 case NoMMX3DNow:
2548 case MMX:
2549 Features["mmx"] = false;
2550 case AMD3DNow:
2551 Features["3dnow"] = false;
2552 case AMD3DNowAthlon:
2553 Features["3dnowa"] = false;
2554 }
2555}
2556
2557void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper13f61a62013-09-17 04:12:55 +00002558 bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002559 if (Enabled) {
2560 switch (Level) {
2561 case XOP:
2562 Features["xop"] = true;
2563 case FMA4:
2564 Features["fma4"] = true;
2565 setSSELevel(Features, AVX, true);
2566 case SSE4A:
2567 Features["sse4a"] = true;
2568 setSSELevel(Features, SSE3, true);
2569 case NoXOP:
2570 break;
2571 }
2572 return;
2573 }
2574
2575 switch (Level) {
2576 case NoXOP:
2577 case SSE4A:
2578 Features["sse4a"] = false;
2579 case FMA4:
2580 Features["fma4"] = false;
2581 case XOP:
2582 Features["xop"] = false;
2583 }
2584}
2585
Craig Topper86d79ef2013-09-17 04:51:29 +00002586void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2587 StringRef Name, bool Enabled) {
Eric Christopher399ffa52010-03-04 02:26:37 +00002588 // FIXME: This *really* should not be here. We need some way of translating
2589 // options into llvm subtarget features.
Rafael Espindola89049822013-08-23 20:21:37 +00002590 if (Name == "sse4")
2591 Name = "sse4.2";
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002592
Rafael Espindolae62e2792013-08-20 13:44:29 +00002593 Features[Name] = Enabled;
Rafael Espindolaa6416a72011-11-27 20:00:43 +00002594
Craig Topper29561122013-09-19 01:13:07 +00002595 if (Name == "mmx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002596 setMMXLevel(Features, MMX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002597 } else if (Name == "sse") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002598 setSSELevel(Features, SSE1, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002599 } else if (Name == "sse2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002600 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002601 } else if (Name == "sse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002602 setSSELevel(Features, SSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002603 } else if (Name == "ssse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002604 setSSELevel(Features, SSSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002605 } else if (Name == "sse4.2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002606 setSSELevel(Features, SSE42, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002607 } else if (Name == "sse4.1") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002608 setSSELevel(Features, SSE41, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002609 } else if (Name == "3dnow") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002610 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002611 } else if (Name == "3dnowa") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002612 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002613 } else if (Name == "aes") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002614 if (Enabled)
2615 setSSELevel(Features, SSE2, Enabled);
2616 } else if (Name == "pclmul") {
2617 if (Enabled)
2618 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002619 } else if (Name == "avx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002620 setSSELevel(Features, AVX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002621 } else if (Name == "avx2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002622 setSSELevel(Features, AVX2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002623 } else if (Name == "avx512f") {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002624 setSSELevel(Features, AVX512F, Enabled);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002625 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf"
2626 || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") {
Craig Topper679b53a2013-08-21 05:29:10 +00002627 if (Enabled)
2628 setSSELevel(Features, AVX512F, Enabled);
2629 } else if (Name == "fma") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002630 if (Enabled)
2631 setSSELevel(Features, AVX, Enabled);
2632 } else if (Name == "fma4") {
2633 setXOPLevel(Features, FMA4, Enabled);
2634 } else if (Name == "xop") {
2635 setXOPLevel(Features, XOP, Enabled);
2636 } else if (Name == "sse4a") {
2637 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper31db3a22013-09-16 04:54:13 +00002638 } else if (Name == "f16c") {
2639 if (Enabled)
2640 setSSELevel(Features, AVX, Enabled);
Ben Langmuir58078d02013-09-19 13:22:04 +00002641 } else if (Name == "sha") {
2642 if (Enabled)
2643 setSSELevel(Features, SSE2, Enabled);
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002644 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002645}
2646
Eric Christopher3ff21b32013-10-16 21:26:26 +00002647/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002648/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00002649bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindolaeb265472013-08-21 21:59:03 +00002650 DiagnosticsEngine &Diags) {
Daniel Dunbar979586e2009-11-11 09:38:56 +00002651 // Remember the maximum enabled sselevel.
2652 for (unsigned i = 0, e = Features.size(); i !=e; ++i) {
2653 // Ignore disabled features.
2654 if (Features[i][0] == '-')
2655 continue;
2656
Benjamin Kramer27402c62012-03-05 15:10:44 +00002657 StringRef Feature = StringRef(Features[i]).substr(1);
2658
2659 if (Feature == "aes") {
Eric Christophere1ddaf92010-04-02 23:50:19 +00002660 HasAES = true;
2661 continue;
2662 }
2663
Craig Topper3f122a72012-05-31 05:18:48 +00002664 if (Feature == "pclmul") {
2665 HasPCLMUL = true;
2666 continue;
2667 }
2668
Benjamin Kramer27402c62012-03-05 15:10:44 +00002669 if (Feature == "lzcnt") {
Craig Topper22967d42011-12-25 05:06:45 +00002670 HasLZCNT = true;
2671 continue;
2672 }
2673
Rafael Espindola89049822013-08-23 20:21:37 +00002674 if (Feature == "rdrnd") {
Benjamin Kramer1e250392012-07-07 09:39:18 +00002675 HasRDRND = true;
2676 continue;
2677 }
2678
Craig Topper8c7f2512014-11-03 06:51:41 +00002679 if (Feature == "fsgsbase") {
2680 HasFSGSBASE = true;
2681 continue;
2682 }
2683
Benjamin Kramer27402c62012-03-05 15:10:44 +00002684 if (Feature == "bmi") {
Craig Topper22967d42011-12-25 05:06:45 +00002685 HasBMI = true;
2686 continue;
2687 }
2688
Benjamin Kramer27402c62012-03-05 15:10:44 +00002689 if (Feature == "bmi2") {
Craig Topper22967d42011-12-25 05:06:45 +00002690 HasBMI2 = true;
2691 continue;
2692 }
2693
Benjamin Kramer27402c62012-03-05 15:10:44 +00002694 if (Feature == "popcnt") {
Craig Topper1de83482011-12-29 16:10:46 +00002695 HasPOPCNT = true;
2696 continue;
2697 }
2698
Michael Liao625a8752012-11-10 05:17:46 +00002699 if (Feature == "rtm") {
2700 HasRTM = true;
2701 continue;
2702 }
2703
Michael Liao74f4eaf2013-03-26 17:52:08 +00002704 if (Feature == "prfchw") {
2705 HasPRFCHW = true;
2706 continue;
2707 }
2708
Michael Liaoffaae352013-03-29 05:17:55 +00002709 if (Feature == "rdseed") {
2710 HasRDSEED = true;
2711 continue;
2712 }
2713
Robert Khasanov50e6f582014-09-19 09:53:48 +00002714 if (Feature == "adx") {
2715 HasADX = true;
2716 continue;
2717 }
2718
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002719 if (Feature == "tbm") {
2720 HasTBM = true;
2721 continue;
2722 }
2723
Craig Topperbba778b2012-06-03 21:46:30 +00002724 if (Feature == "fma") {
2725 HasFMA = true;
2726 continue;
2727 }
2728
Manman Rena45358c2012-10-11 00:59:55 +00002729 if (Feature == "f16c") {
2730 HasF16C = true;
2731 continue;
2732 }
2733
Craig Topper679b53a2013-08-21 05:29:10 +00002734 if (Feature == "avx512cd") {
2735 HasAVX512CD = true;
2736 continue;
2737 }
2738
2739 if (Feature == "avx512er") {
2740 HasAVX512ER = true;
2741 continue;
2742 }
2743
2744 if (Feature == "avx512pf") {
2745 HasAVX512PF = true;
2746 continue;
2747 }
2748
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002749 if (Feature == "avx512dq") {
2750 HasAVX512DQ = true;
2751 continue;
2752 }
2753
2754 if (Feature == "avx512bw") {
2755 HasAVX512BW = true;
2756 continue;
2757 }
2758
2759 if (Feature == "avx512vl") {
2760 HasAVX512VL = true;
2761 continue;
2762 }
2763
Ben Langmuir58078d02013-09-19 13:22:04 +00002764 if (Feature == "sha") {
2765 HasSHA = true;
2766 continue;
2767 }
2768
Nick Lewycky50e8f482013-10-05 20:14:27 +00002769 if (Feature == "cx16") {
2770 HasCX16 = true;
2771 continue;
2772 }
2773
Daniel Dunbar979586e2009-11-11 09:38:56 +00002774 assert(Features[i][0] == '+' && "Invalid target feature!");
Benjamin Kramer27402c62012-03-05 15:10:44 +00002775 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Craig Topper679b53a2013-08-21 05:29:10 +00002776 .Case("avx512f", AVX512F)
Craig Topper23b92192012-01-09 09:19:09 +00002777 .Case("avx2", AVX2)
2778 .Case("avx", AVX)
Rafael Espindola89049822013-08-23 20:21:37 +00002779 .Case("sse4.2", SSE42)
2780 .Case("sse4.1", SSE41)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002781 .Case("ssse3", SSSE3)
Nuno Lopes4cbc8bd2010-03-12 10:20:09 +00002782 .Case("sse3", SSE3)
Daniel Dunbar979586e2009-11-11 09:38:56 +00002783 .Case("sse2", SSE2)
2784 .Case("sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00002785 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002786 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002787
Eli Friedman33465822011-07-08 23:31:17 +00002788 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer27402c62012-03-05 15:10:44 +00002789 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Anders Carlssone437c682010-01-27 03:47:49 +00002790 .Case("3dnowa", AMD3DNowAthlon)
2791 .Case("3dnow", AMD3DNow)
Eli Friedman33465822011-07-08 23:31:17 +00002792 .Case("mmx", MMX)
2793 .Default(NoMMX3DNow);
Eli Friedman33465822011-07-08 23:31:17 +00002794 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002795
2796 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
2797 .Case("xop", XOP)
2798 .Case("fma4", FMA4)
2799 .Case("sse4a", SSE4A)
2800 .Default(NoXOP);
2801 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00002802 }
Eli Friedman33465822011-07-08 23:31:17 +00002803
Craig Topper7481d8a2013-09-10 06:55:47 +00002804 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2805 // Can't do this earlier because we need to be able to explicitly enable
2806 // popcnt and still disable sse4.2.
2807 if (!HasPOPCNT && SSELevel >= SSE42 &&
2808 std::find(Features.begin(), Features.end(), "-popcnt") == Features.end()){
2809 HasPOPCNT = true;
2810 Features.push_back("+popcnt");
2811 }
2812
Yunzhong Gao61089362013-10-16 19:07:02 +00002813 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2814 if (!HasPRFCHW && MMX3DNowLevel >= AMD3DNow &&
2815 std::find(Features.begin(), Features.end(), "-prfchw") == Features.end()){
2816 HasPRFCHW = true;
2817 Features.push_back("+prfchw");
2818 }
2819
Rafael Espindolaeb265472013-08-21 21:59:03 +00002820 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
2821 // matches the selected sse level.
2822 if (FPMath == FP_SSE && SSELevel < SSE1) {
2823 Diags.Report(diag::err_target_unsupported_fpmath) << "sse";
2824 return false;
2825 } else if (FPMath == FP_387 && SSELevel >= SSE1) {
2826 Diags.Report(diag::err_target_unsupported_fpmath) << "387";
2827 return false;
2828 }
2829
Eli Friedman33465822011-07-08 23:31:17 +00002830 // Don't tell the backend if we're turning off mmx; it will end up disabling
2831 // SSE, which we don't want.
Craig Topperc0070a42013-09-11 06:48:53 +00002832 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2833 // then enable MMX.
Eli Friedman33465822011-07-08 23:31:17 +00002834 std::vector<std::string>::iterator it;
2835 it = std::find(Features.begin(), Features.end(), "-mmx");
2836 if (it != Features.end())
2837 Features.erase(it);
Craig Topperc0070a42013-09-11 06:48:53 +00002838 else if (SSELevel > NoSSE)
2839 MMX3DNowLevel = std::max(MMX3DNowLevel, MMX);
Rafael Espindolaeb265472013-08-21 21:59:03 +00002840 return true;
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002841}
Chris Lattnerecd49032009-03-02 22:27:17 +00002842
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002843/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
2844/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00002845void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002846 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00002847 // Target identification.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002848 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002849 Builder.defineMacro("__amd64__");
2850 Builder.defineMacro("__amd64");
2851 Builder.defineMacro("__x86_64");
2852 Builder.defineMacro("__x86_64__");
Bob Wilsona2acb1e2014-08-08 23:46:28 +00002853 if (getTriple().getArchName() == "x86_64h") {
2854 Builder.defineMacro("__x86_64h");
2855 Builder.defineMacro("__x86_64h__");
2856 }
Chris Lattnerecd49032009-03-02 22:27:17 +00002857 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00002858 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00002859 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00002860
Chris Lattnerecd49032009-03-02 22:27:17 +00002861 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002862 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
2863 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00002864 switch (CPU) {
2865 case CK_Generic:
2866 break;
2867 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002868 // The rest are coming from the i386 define above.
2869 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002870 break;
2871 case CK_i486:
2872 case CK_WinChipC6:
2873 case CK_WinChip2:
2874 case CK_C3:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002875 defineCPUMacros(Builder, "i486");
Chandler Carruth212334f2011-09-28 08:55:37 +00002876 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002877 case CK_PentiumMMX:
2878 Builder.defineMacro("__pentium_mmx__");
2879 Builder.defineMacro("__tune_pentium_mmx__");
2880 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002881 case CK_i586:
2882 case CK_Pentium:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002883 defineCPUMacros(Builder, "i586");
2884 defineCPUMacros(Builder, "pentium");
Chandler Carruth212334f2011-09-28 08:55:37 +00002885 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002886 case CK_Pentium3:
2887 case CK_Pentium3M:
2888 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002889 Builder.defineMacro("__tune_pentium3__");
2890 // Fallthrough
2891 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00002892 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002893 Builder.defineMacro("__tune_pentium2__");
2894 // Fallthrough
2895 case CK_PentiumPro:
2896 Builder.defineMacro("__tune_i686__");
2897 Builder.defineMacro("__tune_pentiumpro__");
2898 // Fallthrough
2899 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002900 Builder.defineMacro("__i686");
2901 Builder.defineMacro("__i686__");
2902 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
2903 Builder.defineMacro("__pentiumpro");
2904 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00002905 break;
2906 case CK_Pentium4:
2907 case CK_Pentium4M:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002908 defineCPUMacros(Builder, "pentium4");
Chandler Carruth212334f2011-09-28 08:55:37 +00002909 break;
2910 case CK_Yonah:
2911 case CK_Prescott:
2912 case CK_Nocona:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002913 defineCPUMacros(Builder, "nocona");
Chandler Carruth212334f2011-09-28 08:55:37 +00002914 break;
2915 case CK_Core2:
2916 case CK_Penryn:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002917 defineCPUMacros(Builder, "core2");
Chandler Carruth212334f2011-09-28 08:55:37 +00002918 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002919 case CK_Bonnell:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002920 defineCPUMacros(Builder, "atom");
Chandler Carruth212334f2011-09-28 08:55:37 +00002921 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00002922 case CK_Silvermont:
Benjamin Kramerffecc842013-08-30 14:05:34 +00002923 defineCPUMacros(Builder, "slm");
2924 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002925 case CK_Nehalem:
2926 case CK_Westmere:
2927 case CK_SandyBridge:
2928 case CK_IvyBridge:
2929 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00002930 case CK_Broadwell:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002931 // FIXME: Historically, we defined this legacy name, it would be nice to
2932 // remove it at some point. We've never exposed fine-grained names for
2933 // recent primary x86 CPUs, and we should keep it that way.
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002934 defineCPUMacros(Builder, "corei7");
Chandler Carruth212334f2011-09-28 08:55:37 +00002935 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002936 case CK_Skylake:
2937 // FIXME: Historically, we defined this legacy name, it would be nice to
2938 // remove it at some point. This is the only fine-grained CPU macro in the
2939 // main intel CPU line, and it would be better to not have these and force
2940 // people to use ISA macros.
2941 defineCPUMacros(Builder, "skx");
2942 break;
Craig Topper449314e2013-08-20 07:09:39 +00002943 case CK_KNL:
2944 defineCPUMacros(Builder, "knl");
2945 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002946 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002947 Builder.defineMacro("__k6_2__");
2948 Builder.defineMacro("__tune_k6_2__");
2949 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00002950 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002951 if (CPU != CK_K6_2) { // In case of fallthrough
2952 // FIXME: GCC may be enabling these in cases where some other k6
2953 // architecture is specified but -m3dnow is explicitly provided. The
2954 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002955 Builder.defineMacro("__k6_3__");
2956 Builder.defineMacro("__tune_k6_3__");
2957 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00002958 // Fallthrough
2959 case CK_K6:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002960 defineCPUMacros(Builder, "k6");
Chandler Carruth212334f2011-09-28 08:55:37 +00002961 break;
2962 case CK_Athlon:
2963 case CK_AthlonThunderbird:
2964 case CK_Athlon4:
2965 case CK_AthlonXP:
2966 case CK_AthlonMP:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002967 defineCPUMacros(Builder, "athlon");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002968 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002969 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00002970 Builder.defineMacro("__tune_athlon_sse__");
2971 }
Chandler Carruth212334f2011-09-28 08:55:37 +00002972 break;
2973 case CK_K8:
2974 case CK_K8SSE3:
2975 case CK_x86_64:
2976 case CK_Opteron:
2977 case CK_OpteronSSE3:
2978 case CK_Athlon64:
2979 case CK_Athlon64SSE3:
2980 case CK_AthlonFX:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002981 defineCPUMacros(Builder, "k8");
Chandler Carruth212334f2011-09-28 08:55:37 +00002982 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00002983 case CK_AMDFAM10:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002984 defineCPUMacros(Builder, "amdfam10");
Roman Divacky43eb6f82011-10-30 07:48:46 +00002985 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00002986 case CK_BTVER1:
2987 defineCPUMacros(Builder, "btver1");
2988 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002989 case CK_BTVER2:
2990 defineCPUMacros(Builder, "btver2");
2991 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002992 case CK_BDVER1:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002993 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002994 break;
2995 case CK_BDVER2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00002996 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002997 break;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002998 case CK_BDVER3:
2999 defineCPUMacros(Builder, "bdver3");
3000 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00003001 case CK_BDVER4:
3002 defineCPUMacros(Builder, "bdver4");
3003 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003004 case CK_Geode:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003005 defineCPUMacros(Builder, "geode");
Chandler Carruth212334f2011-09-28 08:55:37 +00003006 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003007 }
Chris Lattner96e43572009-03-02 22:40:39 +00003008
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003009 // Target properties.
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003010 Builder.defineMacro("__REGISTER_PREFIX__", "");
3011
Chris Lattner6df41af2009-04-19 17:32:33 +00003012 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
3013 // functions in glibc header files that use FP Stack inline asm which the
3014 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003015 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003016
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003017 if (HasAES)
3018 Builder.defineMacro("__AES__");
3019
Craig Topper3f122a72012-05-31 05:18:48 +00003020 if (HasPCLMUL)
3021 Builder.defineMacro("__PCLMUL__");
3022
Craig Topper22967d42011-12-25 05:06:45 +00003023 if (HasLZCNT)
3024 Builder.defineMacro("__LZCNT__");
3025
Benjamin Kramer1e250392012-07-07 09:39:18 +00003026 if (HasRDRND)
3027 Builder.defineMacro("__RDRND__");
3028
Craig Topper8c7f2512014-11-03 06:51:41 +00003029 if (HasFSGSBASE)
3030 Builder.defineMacro("__FSGSBASE__");
3031
Craig Topper22967d42011-12-25 05:06:45 +00003032 if (HasBMI)
3033 Builder.defineMacro("__BMI__");
3034
3035 if (HasBMI2)
3036 Builder.defineMacro("__BMI2__");
3037
Craig Topper1de83482011-12-29 16:10:46 +00003038 if (HasPOPCNT)
3039 Builder.defineMacro("__POPCNT__");
3040
Michael Liao625a8752012-11-10 05:17:46 +00003041 if (HasRTM)
3042 Builder.defineMacro("__RTM__");
3043
Michael Liao74f4eaf2013-03-26 17:52:08 +00003044 if (HasPRFCHW)
3045 Builder.defineMacro("__PRFCHW__");
3046
Michael Liaoffaae352013-03-29 05:17:55 +00003047 if (HasRDSEED)
3048 Builder.defineMacro("__RDSEED__");
3049
Robert Khasanov50e6f582014-09-19 09:53:48 +00003050 if (HasADX)
3051 Builder.defineMacro("__ADX__");
3052
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00003053 if (HasTBM)
3054 Builder.defineMacro("__TBM__");
3055
Rafael Espindolae62e2792013-08-20 13:44:29 +00003056 switch (XOPLevel) {
3057 case XOP:
3058 Builder.defineMacro("__XOP__");
3059 case FMA4:
Craig Topperffdb46c2011-12-30 07:33:42 +00003060 Builder.defineMacro("__FMA4__");
Rafael Espindolae62e2792013-08-20 13:44:29 +00003061 case SSE4A:
3062 Builder.defineMacro("__SSE4A__");
3063 case NoXOP:
3064 break;
3065 }
Craig Topperffdb46c2011-12-30 07:33:42 +00003066
Craig Topperbba778b2012-06-03 21:46:30 +00003067 if (HasFMA)
3068 Builder.defineMacro("__FMA__");
3069
Manman Rena45358c2012-10-11 00:59:55 +00003070 if (HasF16C)
3071 Builder.defineMacro("__F16C__");
3072
Craig Topper679b53a2013-08-21 05:29:10 +00003073 if (HasAVX512CD)
3074 Builder.defineMacro("__AVX512CD__");
3075 if (HasAVX512ER)
3076 Builder.defineMacro("__AVX512ER__");
3077 if (HasAVX512PF)
3078 Builder.defineMacro("__AVX512PF__");
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003079 if (HasAVX512DQ)
3080 Builder.defineMacro("__AVX512DQ__");
3081 if (HasAVX512BW)
3082 Builder.defineMacro("__AVX512BW__");
3083 if (HasAVX512VL)
3084 Builder.defineMacro("__AVX512VL__");
Craig Topper679b53a2013-08-21 05:29:10 +00003085
Ben Langmuir58078d02013-09-19 13:22:04 +00003086 if (HasSHA)
3087 Builder.defineMacro("__SHA__");
3088
Nick Lewycky50e8f482013-10-05 20:14:27 +00003089 if (HasCX16)
3090 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
3091
Chris Lattner96e43572009-03-02 22:40:39 +00003092 // Each case falls through to the previous one here.
3093 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003094 case AVX512F:
Craig Topper007b0592013-08-20 07:39:54 +00003095 Builder.defineMacro("__AVX512F__");
Craig Topper23b92192012-01-09 09:19:09 +00003096 case AVX2:
3097 Builder.defineMacro("__AVX2__");
3098 case AVX:
3099 Builder.defineMacro("__AVX__");
Chris Lattner96e43572009-03-02 22:40:39 +00003100 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003101 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00003102 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003103 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00003104 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003105 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00003106 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003107 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00003108 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003109 Builder.defineMacro("__SSE2__");
3110 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00003111 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003112 Builder.defineMacro("__SSE__");
3113 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00003114 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00003115 break;
3116 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003117
Derek Schuffc7dd7222012-10-11 15:52:22 +00003118 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003119 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003120 case AVX512F:
Craig Topper23b92192012-01-09 09:19:09 +00003121 case AVX2:
3122 case AVX:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003123 case SSE42:
3124 case SSE41:
3125 case SSSE3:
3126 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003127 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003128 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003129 break;
3130 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003131 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003132 break;
3133 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003134 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003135 }
3136 }
3137
Anders Carlssone437c682010-01-27 03:47:49 +00003138 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00003139 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00003140 case AMD3DNowAthlon:
3141 Builder.defineMacro("__3dNOW_A__");
3142 case AMD3DNow:
3143 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00003144 case MMX:
3145 Builder.defineMacro("__MMX__");
3146 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00003147 break;
3148 }
Michael J. Spencera0d5eb3a2013-04-04 23:53:43 +00003149
3150 if (CPU >= CK_i486) {
3151 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3152 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3153 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3154 }
3155 if (CPU >= CK_i586)
3156 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerecd49032009-03-02 22:27:17 +00003157}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003158
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003159bool X86TargetInfo::hasFeature(StringRef Feature) const {
3160 return llvm::StringSwitch<bool>(Feature)
3161 .Case("aes", HasAES)
3162 .Case("avx", SSELevel >= AVX)
3163 .Case("avx2", SSELevel >= AVX2)
Craig Topper9c4d17f2013-08-21 03:59:22 +00003164 .Case("avx512f", SSELevel >= AVX512F)
Craig Topper679b53a2013-08-21 05:29:10 +00003165 .Case("avx512cd", HasAVX512CD)
3166 .Case("avx512er", HasAVX512ER)
3167 .Case("avx512pf", HasAVX512PF)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003168 .Case("avx512dq", HasAVX512DQ)
3169 .Case("avx512bw", HasAVX512BW)
3170 .Case("avx512vl", HasAVX512VL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003171 .Case("bmi", HasBMI)
3172 .Case("bmi2", HasBMI2)
Nick Lewycky50e8f482013-10-05 20:14:27 +00003173 .Case("cx16", HasCX16)
3174 .Case("f16c", HasF16C)
Craig Topperbba778b2012-06-03 21:46:30 +00003175 .Case("fma", HasFMA)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003176 .Case("fma4", XOPLevel >= FMA4)
Craig Topper8c7f2512014-11-03 06:51:41 +00003177 .Case("fsgsbase", HasFSGSBASE)
Craig Topper8dbc5842014-11-03 07:05:26 +00003178 .Case("lzcnt", HasLZCNT)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003179 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
3180 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3181 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3f122a72012-05-31 05:18:48 +00003182 .Case("pclmul", HasPCLMUL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003183 .Case("popcnt", HasPOPCNT)
Michael Liao74f4eaf2013-03-26 17:52:08 +00003184 .Case("prfchw", HasPRFCHW)
Craig Topper8dbc5842014-11-03 07:05:26 +00003185 .Case("rdrnd", HasRDRND)
Michael Liaoffaae352013-03-29 05:17:55 +00003186 .Case("rdseed", HasRDSEED)
Craig Topper8dbc5842014-11-03 07:05:26 +00003187 .Case("rtm", HasRTM)
Ben Langmuir58078d02013-09-19 13:22:04 +00003188 .Case("sha", HasSHA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003189 .Case("sse", SSELevel >= SSE1)
3190 .Case("sse2", SSELevel >= SSE2)
3191 .Case("sse3", SSELevel >= SSE3)
3192 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola89049822013-08-23 20:21:37 +00003193 .Case("sse4.1", SSELevel >= SSE41)
3194 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003195 .Case("sse4a", XOPLevel >= SSE4A)
Craig Topper8dbc5842014-11-03 07:05:26 +00003196 .Case("tbm", HasTBM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003197 .Case("x86", true)
Derek Schuffc7dd7222012-10-11 15:52:22 +00003198 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
3199 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003200 .Case("xop", XOPLevel >= XOP)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003201 .Default(false);
3202}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003203
Eli Friedman3fd920a2008-08-20 02:34:37 +00003204bool
Anders Carlsson58436352009-02-28 17:11:49 +00003205X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00003206 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00003207 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003208 default: return false;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00003209 case 'I':
3210 Info.setRequiresImmediate(0, 31);
3211 return true;
3212 case 'J':
3213 Info.setRequiresImmediate(0, 63);
3214 return true;
3215 case 'K':
3216 Info.setRequiresImmediate(-128, 127);
3217 return true;
3218 case 'L':
3219 // FIXME: properly analyze this constraint:
3220 // must be one of 0xff, 0xffff, or 0xffffffff
3221 return true;
3222 case 'M':
3223 Info.setRequiresImmediate(0, 3);
3224 return true;
3225 case 'N':
3226 Info.setRequiresImmediate(0, 255);
3227 return true;
3228 case 'O':
3229 Info.setRequiresImmediate(0, 127);
3230 return true;
Dale Johannesen46742a42010-08-24 22:33:12 +00003231 case 'Y': // first letter of a pair:
3232 switch (*(Name+1)) {
3233 default: return false;
3234 case '0': // First SSE register.
3235 case 't': // Any SSE register, when SSE2 is enabled.
3236 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
3237 case 'm': // any MMX register, when inter-unit moves enabled.
3238 break; // falls through to setAllowsRegister.
3239 }
Akira Hatanaka88ef7282014-07-18 23:30:30 +00003240 case 'f': // any x87 floating point stack register.
3241 // Constraint 'f' cannot be used for output operands.
3242 if (Info.ConstraintStr[0] == '=')
3243 return false;
3244
3245 Info.setAllowsRegister();
3246 return true;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003247 case 'a': // eax.
3248 case 'b': // ebx.
3249 case 'c': // ecx.
3250 case 'd': // edx.
3251 case 'S': // esi.
3252 case 'D': // edi.
3253 case 'A': // edx:eax.
3254 case 't': // top of floating point stack.
3255 case 'u': // second from top of floating point stack.
3256 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00003257 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00003258 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003259 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00003260 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
3261 case 'l': // "Index" registers: any general register that can be used as an
3262 // index in a base+index memory access.
3263 Info.setAllowsRegister();
3264 return true;
3265 case 'C': // SSE floating point constant.
3266 case 'G': // x87 floating point constant.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003267 case 'e': // 32-bit signed integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003268 // x86_64 instructions.
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003269 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
Anders Carlssona0b89212009-01-24 18:03:09 +00003270 // x86_64 instructions.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003271 return true;
3272 }
3273}
3274
Akira Hatanaka974131e2014-09-18 18:17:18 +00003275bool X86TargetInfo::validateOutputSize(StringRef Constraint,
3276 unsigned Size) const {
3277 // Strip off constraint modifiers.
3278 while (Constraint[0] == '=' ||
3279 Constraint[0] == '+' ||
3280 Constraint[0] == '&')
3281 Constraint = Constraint.substr(1);
3282
3283 return validateOperandSize(Constraint, Size);
3284}
3285
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003286bool X86TargetInfo::validateInputSize(StringRef Constraint,
3287 unsigned Size) const {
Akira Hatanaka974131e2014-09-18 18:17:18 +00003288 return validateOperandSize(Constraint, Size);
3289}
3290
3291bool X86TargetInfo::validateOperandSize(StringRef Constraint,
3292 unsigned Size) const {
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003293 switch (Constraint[0]) {
3294 default: break;
3295 case 'y':
3296 return Size <= 64;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003297 case 'f':
3298 case 't':
3299 case 'u':
3300 return Size <= 128;
Hans Wennborg3c619a42014-09-18 20:24:04 +00003301 case 'x':
Akira Hatanakae867e422014-09-18 21:58:54 +00003302 // 256-bit ymm registers can be used if target supports AVX.
Aaron Ballmanc1953dc2014-09-19 12:21:56 +00003303 return Size <= (SSELevel >= AVX ? 256U : 128U);
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003304 }
3305
3306 return true;
3307}
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00003308
Eli Friedman3fd920a2008-08-20 02:34:37 +00003309std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003310X86TargetInfo::convertConstraint(const char *&Constraint) const {
3311 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003312 case 'a': return std::string("{ax}");
3313 case 'b': return std::string("{bx}");
3314 case 'c': return std::string("{cx}");
3315 case 'd': return std::string("{dx}");
3316 case 'S': return std::string("{si}");
3317 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00003318 case 'p': // address
3319 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00003320 case 't': // top of floating point stack.
3321 return std::string("{st}");
3322 case 'u': // second from top of floating point stack.
3323 return std::string("{st(1)}"); // second from top of floating point stack.
3324 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003325 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00003326 }
3327}
Eli Friedman3fd920a2008-08-20 02:34:37 +00003328} // end anonymous namespace
Chris Lattner5ba61f02006-10-14 07:39:34 +00003329
3330namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003331// X86-32 generic target
3332class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00003333public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003334 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003335 DoubleAlign = LongLongAlign = 32;
3336 LongDoubleWidth = 96;
3337 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00003338 SuitableAlign = 128;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003339 DescriptionString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
Eli Friedman32ca82a2009-03-29 20:31:09 +00003340 SizeType = UnsignedInt;
3341 PtrDiffType = SignedInt;
3342 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003343 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003344
3345 // Use fpret for all types.
3346 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
3347 (1 << TargetInfo::Double) |
3348 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003349
3350 // x86-32 has atomics up to 8 bytes
3351 // FIXME: Check that we actually have cmpxchg8b before setting
3352 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
3353 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003354 }
Craig Topper3164f332014-03-11 03:39:26 +00003355 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003356 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003357 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003358
Craig Topper3164f332014-03-11 03:39:26 +00003359 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003360 if (RegNo == 0) return 0;
3361 if (RegNo == 1) return 2;
3362 return -1;
3363 }
Akira Hatanaka974131e2014-09-18 18:17:18 +00003364 bool validateOperandSize(StringRef Constraint,
3365 unsigned Size) const override {
Bill Wendling887b4852012-11-12 06:42:51 +00003366 switch (Constraint[0]) {
3367 default: break;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003368 case 'R':
3369 case 'q':
3370 case 'Q':
Bill Wendling887b4852012-11-12 06:42:51 +00003371 case 'a':
3372 case 'b':
3373 case 'c':
3374 case 'd':
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003375 case 'S':
3376 case 'D':
Bill Wendling3c7fed82012-11-12 18:52:32 +00003377 return Size <= 32;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003378 case 'A':
3379 return Size <= 64;
Bill Wendling887b4852012-11-12 06:42:51 +00003380 }
3381
Akira Hatanaka974131e2014-09-18 18:17:18 +00003382 return X86TargetInfo::validateOperandSize(Constraint, Size);
Bill Wendling887b4852012-11-12 06:42:51 +00003383 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003384};
3385} // end anonymous namespace
3386
3387namespace {
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003388class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
3389public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003390 NetBSDI386TargetInfo(const llvm::Triple &Triple)
3391 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003392
Craig Topper3164f332014-03-11 03:39:26 +00003393 unsigned getFloatEvalMethod() const override {
Joerg Sonnenberger0e921f22013-11-11 14:00:37 +00003394 unsigned Major, Minor, Micro;
3395 getTriple().getOSVersion(Major, Minor, Micro);
3396 // New NetBSD uses the default rounding mode.
3397 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3398 return X86_32TargetInfo::getFloatEvalMethod();
3399 // NetBSD before 6.99.26 defaults to "double" rounding.
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003400 return 1;
3401 }
3402};
3403} // end anonymous namespace
3404
3405namespace {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003406class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
3407public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003408 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
3409 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003410 SizeType = UnsignedLong;
3411 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003412 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00003413 }
3414};
3415} // end anonymous namespace
3416
3417namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003418class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3419public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003420 BitrigI386TargetInfo(const llvm::Triple &Triple)
3421 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman9fa28852012-08-08 23:57:20 +00003422 SizeType = UnsignedLong;
3423 IntPtrType = SignedLong;
3424 PtrDiffType = SignedLong;
3425 }
3426};
3427} // end anonymous namespace
3428
3429namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00003430class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003431public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003432 DarwinI386TargetInfo(const llvm::Triple &Triple)
3433 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003434 LongDoubleWidth = 128;
3435 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003436 SuitableAlign = 128;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003437 MaxVectorAlign = 256;
Eli Friedman32ca82a2009-03-29 20:31:09 +00003438 SizeType = UnsignedLong;
3439 IntPtrType = SignedLong;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003440 DescriptionString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
Daniel Dunbarbd606522010-05-27 00:35:16 +00003441 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00003442 }
3443
Eli Friedman3fd920a2008-08-20 02:34:37 +00003444};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00003445} // end anonymous namespace
3446
3447namespace {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003448// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003449class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003450public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003451 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3452 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Chris Lattner46be2e12009-06-24 17:12:15 +00003453 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00003454 DoubleAlign = LongLongAlign = 64;
David Majnemer8fa8c382015-03-17 23:55:00 +00003455 DescriptionString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-S32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003456 }
Craig Topper3164f332014-03-11 03:39:26 +00003457 void getTargetDefines(const LangOptions &Opts,
3458 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003459 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3460 }
3461};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003462
3463// x86-32 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003464class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003465public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003466 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003467 : WindowsX86_32TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003468 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003469 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3470 }
Craig Topper3164f332014-03-11 03:39:26 +00003471 void getTargetDefines(const LangOptions &Opts,
3472 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003473 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3474 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3475 // The value of the following reflects processor type.
3476 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3477 // We lost the original triple, so we use the default.
3478 Builder.defineMacro("_M_IX86", "600");
3479 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003480};
3481} // end anonymous namespace
3482
Reid Kleckner47606832014-04-21 20:58:00 +00003483static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
3484 Builder.defineMacro("__MSVCRT__");
3485 Builder.defineMacro("__MINGW32__");
3486
3487 // Mingw defines __declspec(a) to __attribute__((a)). Clang supports
3488 // __declspec natively under -fms-extensions, but we define a no-op __declspec
3489 // macro anyway for pre-processor compatibility.
3490 if (Opts.MicrosoftExt)
3491 Builder.defineMacro("__declspec", "__declspec");
3492 else
3493 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
3494
3495 if (!Opts.MicrosoftExt) {
3496 // Provide macros for all the calling convention keywords. Provide both
3497 // single and double underscore prefixed variants. These are available on
3498 // x64 as well as x86, even though they have no effect.
3499 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
3500 for (const char *CC : CCs) {
Reid Kleckner70cfa662014-04-21 22:29:45 +00003501 std::string GCCSpelling = "__attribute__((__";
3502 GCCSpelling += CC;
3503 GCCSpelling += "__))";
Reid Kleckner47606832014-04-21 20:58:00 +00003504 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
3505 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
3506 }
3507 }
3508}
3509
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003510namespace {
3511// x86-32 MinGW target
3512class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3513public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003514 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
3515 : WindowsX86_32TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003516 void getTargetDefines(const LangOptions &Opts,
3517 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003518 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003519 DefineStd(Builder, "WIN32", Opts);
3520 DefineStd(Builder, "WINNT", Opts);
3521 Builder.defineMacro("_X86_");
Reid Kleckner47606832014-04-21 20:58:00 +00003522 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003523 }
3524};
3525} // end anonymous namespace
3526
3527namespace {
3528// x86-32 Cygwin target
3529class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3530public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003531 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3532 : X86_32TargetInfo(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003533 TLSSupported = false;
3534 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003535 DoubleAlign = LongLongAlign = 64;
David Majnemer8fa8c382015-03-17 23:55:00 +00003536 DescriptionString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-S32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003537 }
Craig Topper3164f332014-03-11 03:39:26 +00003538 void getTargetDefines(const LangOptions &Opts,
3539 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003540 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumi02f43952012-12-14 10:17:26 +00003541 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003542 Builder.defineMacro("__CYGWIN__");
3543 Builder.defineMacro("__CYGWIN32__");
3544 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00003545 if (Opts.CPlusPlus)
3546 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00003547 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003548};
3549} // end anonymous namespace
3550
3551namespace {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003552// x86-32 Haiku target
3553class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3554public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003555 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003556 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00003557 IntPtrType = SignedLong;
3558 PtrDiffType = SignedLong;
Eli Friedman4e91899e2012-11-27 02:58:24 +00003559 ProcessIDType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00003560 this->UserLabelPrefix = "";
Benjamin Kramerd0b9f092012-11-08 12:59:15 +00003561 this->TLSSupported = false;
Eli Friedman04831922010-08-22 01:00:03 +00003562 }
Craig Topper3164f332014-03-11 03:39:26 +00003563 void getTargetDefines(const LangOptions &Opts,
3564 MacroBuilder &Builder) const override {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003565 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3566 Builder.defineMacro("__INTEL__");
3567 Builder.defineMacro("__HAIKU__");
3568 }
3569};
3570} // end anonymous namespace
3571
Douglas Gregor9fabd852011-07-01 22:41:14 +00003572// RTEMS Target
3573template<typename Target>
3574class RTEMSTargetInfo : public OSTargetInfo<Target> {
3575protected:
Craig Topper3164f332014-03-11 03:39:26 +00003576 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3577 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003578 // RTEMS defines; list based off of gcc output
3579
Douglas Gregor9fabd852011-07-01 22:41:14 +00003580 Builder.defineMacro("__rtems__");
3581 Builder.defineMacro("__ELF__");
3582 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003583
Douglas Gregor9fabd852011-07-01 22:41:14 +00003584public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003585 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3586 this->UserLabelPrefix = "";
Douglas Gregor9fabd852011-07-01 22:41:14 +00003587
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003588 switch (Triple.getArch()) {
3589 default:
3590 case llvm::Triple::x86:
3591 // this->MCountName = ".mcount";
3592 break;
3593 case llvm::Triple::mips:
3594 case llvm::Triple::mipsel:
3595 case llvm::Triple::ppc:
3596 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +00003597 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003598 // this->MCountName = "_mcount";
3599 break;
3600 case llvm::Triple::arm:
3601 // this->MCountName = "__mcount";
3602 break;
Douglas Gregor9fabd852011-07-01 22:41:14 +00003603 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003604 }
Douglas Gregor9fabd852011-07-01 22:41:14 +00003605};
3606
3607namespace {
3608// x86-32 RTEMS target
3609class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3610public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003611 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003612 SizeType = UnsignedLong;
3613 IntPtrType = SignedLong;
3614 PtrDiffType = SignedLong;
3615 this->UserLabelPrefix = "";
3616 }
Craig Topper3164f332014-03-11 03:39:26 +00003617 void getTargetDefines(const LangOptions &Opts,
3618 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003619 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3620 Builder.defineMacro("__INTEL__");
3621 Builder.defineMacro("__rtems__");
3622 }
3623};
3624} // end anonymous namespace
3625
Chris Lattnerb986aba2010-04-11 19:29:39 +00003626namespace {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003627// x86-64 generic target
3628class X86_64TargetInfo : public X86TargetInfo {
3629public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003630 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
David Blaikie40f842d2014-07-10 18:46:15 +00003631 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
David Majnemer8fa8c382015-03-17 23:55:00 +00003632 bool IsWinCOFF =
3633 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
Zinovy Nis1db95732014-07-10 15:27:19 +00003634 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00003635 LongDoubleWidth = 128;
3636 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00003637 LargeArrayMinWidth = 128;
3638 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003639 SuitableAlign = 128;
Zinovy Nis1db95732014-07-10 15:27:19 +00003640 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
3641 PtrDiffType = IsX32 ? SignedInt : SignedLong;
3642 IntPtrType = IsX32 ? SignedInt : SignedLong;
3643 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Zinovy Nis1db95732014-07-10 15:27:19 +00003644 Int64Type = IsX32 ? SignedLongLong : SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003645 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00003646
Eric Christopher917e9522014-11-18 22:36:15 +00003647 // Pointers are 32-bit in x32.
David Majnemer8fa8c382015-03-17 23:55:00 +00003648 DescriptionString = IsX32 ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
3649 : IsWinCOFF
3650 ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
3651 : "e-m:e-i64:64-f80:128-n8:16:32:64-S128";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003652
3653 // Use fpret only for long double.
3654 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003655
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00003656 // Use fp2ret for _Complex long double.
3657 ComplexLongDoubleUsesFP2Ret = true;
3658
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003659 // x86-64 has atomics up to 16 bytes.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003660 MaxAtomicPromoteWidth = 128;
Tim Northover1471cb12014-07-02 10:25:45 +00003661 MaxAtomicInlineWidth = 128;
Chris Lattner10a5b382007-01-29 05:24:35 +00003662 }
Craig Topper3164f332014-03-11 03:39:26 +00003663 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003664 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson5fa3f342007-11-24 23:38:12 +00003665 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003666
Craig Topper3164f332014-03-11 03:39:26 +00003667 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003668 if (RegNo == 0) return 0;
3669 if (RegNo == 1) return 1;
3670 return -1;
3671 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003672
Craig Topper3164f332014-03-11 03:39:26 +00003673 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00003674 return (CC == CC_C ||
Reid Kleckner80944df2014-10-31 22:00:51 +00003675 CC == CC_X86VectorCall ||
Charles Davisb5a214e2013-08-30 04:39:01 +00003676 CC == CC_IntelOclBicc ||
3677 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003678 }
3679
Craig Topper3164f332014-03-11 03:39:26 +00003680 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00003681 return CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003682 }
3683
Pavel Chupinfd223e12014-08-04 12:39:43 +00003684 // for x32 we need it here explicitly
3685 bool hasInt128Type() const override { return true; }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003686};
3687} // end anonymous namespace
3688
3689namespace {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003690// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003691class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003692public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003693 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
3694 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003695 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00003696 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003697 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003698 IntMaxType = SignedLongLong;
Nate Begeman6e8865a2010-07-21 02:02:56 +00003699 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00003700 SizeType = UnsignedLongLong;
3701 PtrDiffType = SignedLongLong;
3702 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00003703 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003704 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00003705
Craig Topper3164f332014-03-11 03:39:26 +00003706 void getTargetDefines(const LangOptions &Opts,
3707 MacroBuilder &Builder) const override {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003708 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003709 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003710 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00003711
Craig Topper3164f332014-03-11 03:39:26 +00003712 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003713 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00003714 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00003715
Craig Topper3164f332014-03-11 03:39:26 +00003716 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Reid Kleckner9fde2e02015-02-26 19:43:46 +00003717 switch (CC) {
3718 case CC_X86StdCall:
3719 case CC_X86ThisCall:
3720 case CC_X86FastCall:
3721 return CCCR_Ignore;
3722 case CC_C:
3723 case CC_X86VectorCall:
3724 case CC_IntelOclBicc:
3725 case CC_X86_64SysV:
3726 return CCCR_OK;
3727 default:
3728 return CCCR_Warning;
3729 }
Charles Davisb5a214e2013-08-30 04:39:01 +00003730 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003731};
3732} // end anonymous namespace
3733
3734namespace {
3735// x86-64 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003736class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003737public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003738 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003739 : WindowsX86_64TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003740 LongDoubleWidth = LongDoubleAlign = 64;
3741 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003742 }
Craig Topper3164f332014-03-11 03:39:26 +00003743 void getTargetDefines(const LangOptions &Opts,
3744 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003745 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
3746 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003747 Builder.defineMacro("_M_X64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003748 Builder.defineMacro("_M_AMD64");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003749 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003750};
3751} // end anonymous namespace
3752
3753namespace {
3754// x86-64 MinGW target
3755class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
3756public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003757 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
3758 : WindowsX86_64TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003759 void getTargetDefines(const LangOptions &Opts,
3760 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003761 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003762 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003763 Builder.defineMacro("__MINGW64__");
Reid Kleckner47606832014-04-21 20:58:00 +00003764 addMinGWDefines(Opts, Builder);
Reid Klecknere070b992014-11-14 02:01:10 +00003765
3766 // GCC defines this macro when it is using __gxx_personality_seh0.
3767 if (!Opts.SjLjExceptions)
3768 Builder.defineMacro("__SEH__");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003769 }
3770};
3771} // end anonymous namespace
3772
3773namespace {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003774class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
3775public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003776 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
3777 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman2857ccb2009-07-01 03:36:11 +00003778 Int64Type = SignedLongLong;
Chad Rosiercc40ea72012-07-13 23:57:43 +00003779 MaxVectorAlign = 256;
Tim Northovera2ee4332014-03-29 15:09:45 +00003780 // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
3781 llvm::Triple T = llvm::Triple(Triple);
Bob Wilson946c04c2014-10-19 02:19:27 +00003782 if (T.isiOS())
Tim Northovera2ee4332014-03-29 15:09:45 +00003783 UseSignedCharForObjCBool = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003784 DescriptionString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128";
Eli Friedman2857ccb2009-07-01 03:36:11 +00003785 }
3786};
3787} // end anonymous namespace
3788
3789namespace {
Eli Friedman245f2292009-07-05 22:31:18 +00003790class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
3791public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003792 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
3793 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman245f2292009-07-05 22:31:18 +00003794 IntMaxType = SignedLongLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003795 Int64Type = SignedLongLong;
3796 }
3797};
3798} // end anonymous namespace
3799
3800namespace {
Eli Friedman9fa28852012-08-08 23:57:20 +00003801class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
3802public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003803 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
3804 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
3805 IntMaxType = SignedLongLong;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003806 Int64Type = SignedLongLong;
Eli Friedman9fa28852012-08-08 23:57:20 +00003807 }
3808};
Tim Northover9bb857a2013-01-31 12:13:10 +00003809}
3810
Eli Friedman9fa28852012-08-08 23:57:20 +00003811
3812namespace {
Eli Friedmanf05b7722008-08-20 07:44:10 +00003813class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003814 // Possible FPU choices.
3815 enum FPUMode {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00003816 VFP2FPU = (1 << 0),
3817 VFP3FPU = (1 << 1),
3818 VFP4FPU = (1 << 2),
Bernard Ogdenda13af32013-10-24 18:32:51 +00003819 NeonFPU = (1 << 3),
3820 FPARMV8 = (1 << 4)
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003821 };
3822
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003823 // Possible HWDiv features.
3824 enum HWDivMode {
3825 HWDivThumb = (1 << 0),
3826 HWDivARM = (1 << 1)
3827 };
3828
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003829 static bool FPUModeIsVFP(FPUMode Mode) {
Bernard Ogdenda13af32013-10-24 18:32:51 +00003830 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003831 }
3832
3833 static const TargetInfo::GCCRegAlias GCCRegAliases[];
3834 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00003835
Daniel Dunbaracde99e2009-12-18 18:42:37 +00003836 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003837
Rafael Espindolaeb265472013-08-21 21:59:03 +00003838 enum {
3839 FP_Default,
3840 FP_VFP,
3841 FP_Neon
3842 } FPMath;
3843
Bernard Ogdenda13af32013-10-24 18:32:51 +00003844 unsigned FPU : 5;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00003845
Logan Chien57086ce2012-10-10 06:56:20 +00003846 unsigned IsAAPCS : 1;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003847 unsigned IsThumb : 1;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00003848 unsigned HWDiv : 2;
Daniel Dunbar893d4752009-12-19 04:15:38 +00003849
3850 // Initialized via features.
3851 unsigned SoftFloat : 1;
3852 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00003853
Bernard Ogden18b57012013-10-29 09:47:51 +00003854 unsigned CRC : 1;
Tim Northover02e38602014-02-03 17:28:04 +00003855 unsigned Crypto : 1;
Bernard Ogden18b57012013-10-29 09:47:51 +00003856
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003857 // ACLE 6.5.1 Hardware floating point
3858 enum {
3859 HW_FP_HP = (1 << 1), /// half (16-bit)
3860 HW_FP_SP = (1 << 2), /// single (32-bit)
3861 HW_FP_DP = (1 << 3), /// double (64-bit)
3862 };
3863 uint32_t HW_FP;
3864
Chris Lattner5cc15e02010-03-03 19:03:45 +00003865 static const Builtin::Info BuiltinInfo[];
3866
Rafael Espindola101d5b92013-05-13 20:09:47 +00003867 static bool shouldUseInlineAtomic(const llvm::Triple &T) {
Rafael Espindola101d5b92013-05-13 20:09:47 +00003868 StringRef ArchName = T.getArchName();
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003869 if (T.getArch() == llvm::Triple::arm ||
3870 T.getArch() == llvm::Triple::armeb) {
3871 StringRef VersionStr;
3872 if (ArchName.startswith("armv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003873 VersionStr = ArchName.substr(4, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003874 else if (ArchName.startswith("armebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003875 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003876 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003877 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003878 unsigned Version;
3879 if (VersionStr.getAsInteger(10, Version))
3880 return false;
3881 return Version >= 6;
3882 }
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003883 assert(T.getArch() == llvm::Triple::thumb ||
3884 T.getArch() == llvm::Triple::thumbeb);
3885 StringRef VersionStr;
3886 if (ArchName.startswith("thumbv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003887 VersionStr = ArchName.substr(6, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003888 else if (ArchName.startswith("thumbebv"))
Tim Northovere8c37212014-07-09 09:24:43 +00003889 VersionStr = ArchName.substr(8, 1);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003890 else
Rafael Espindola92dbc312013-05-14 00:44:24 +00003891 return false;
Rafael Espindola92dbc312013-05-14 00:44:24 +00003892 unsigned Version;
3893 if (VersionStr.getAsInteger(10, Version))
3894 return false;
3895 return Version >= 7;
Rafael Espindola101d5b92013-05-13 20:09:47 +00003896 }
3897
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003898 void setABIAAPCS() {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003899 IsAAPCS = true;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003900
3901 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
Rafael Espindolac418ae92014-01-03 19:22:05 +00003902 const llvm::Triple &T = getTriple();
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003903
Renato Golin9ba39232015-02-27 16:35:48 +00003904 // size_t is unsigned long on MachO-derived environments, NetBSD and Bitrig.
3905 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
3906 T.getOS() == llvm::Triple::Bitrig)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003907 SizeType = UnsignedLong;
3908 else
3909 SizeType = UnsignedInt;
3910
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003911 switch (T.getOS()) {
3912 case llvm::Triple::NetBSD:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003913 WCharType = SignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003914 break;
3915 case llvm::Triple::Win32:
3916 WCharType = UnsignedShort;
3917 break;
3918 case llvm::Triple::Linux:
3919 default:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003920 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
3921 WCharType = UnsignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00003922 break;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003923 }
3924
3925 UseBitFieldTypeAlignment = true;
3926
3927 ZeroLengthBitfieldBoundary = 0;
3928
Tim Northover147cd2f2014-10-14 22:12:21 +00003929 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
3930 // so set preferred for small types to 32.
3931 if (T.isOSBinFormatMachO()) {
3932 DescriptionString =
3933 BigEndian ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3934 : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
3935 } else if (T.isOSWindows()) {
Tim Northover147cd2f2014-10-14 22:12:21 +00003936 assert(!BigEndian && "Windows on ARM does not support big endian");
3937 DescriptionString = "e"
David Majnemer8fa8c382015-03-17 23:55:00 +00003938 "-m:w"
Tim Northover147cd2f2014-10-14 22:12:21 +00003939 "-p:32:32"
3940 "-i64:64"
3941 "-v128:64:128"
3942 "-a:0:32"
3943 "-n32"
3944 "-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003945 } else {
Tim Northover147cd2f2014-10-14 22:12:21 +00003946 DescriptionString =
3947 BigEndian ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
3948 : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003949 }
3950
3951 // FIXME: Enumerated types are variable width in straight AAPCS.
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003952 }
3953
3954 void setABIAPCS() {
Rafael Espindolac418ae92014-01-03 19:22:05 +00003955 const llvm::Triple &T = getTriple();
3956
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003957 IsAAPCS = false;
3958
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003959 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003960
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003961 // size_t is unsigned int on FreeBSD.
Rafael Espindolac418ae92014-01-03 19:22:05 +00003962 if (T.getOS() == llvm::Triple::FreeBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003963 SizeType = UnsignedInt;
3964 else
Rafael Espindolad6c2b722013-12-18 19:47:32 +00003965 SizeType = UnsignedLong;
3966
3967 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
3968 WCharType = SignedInt;
3969
3970 // Do not respect the alignment of bit-field types when laying out
3971 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
3972 UseBitFieldTypeAlignment = false;
3973
3974 /// gcc forces the alignment to 4 bytes, regardless of the type of the
3975 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
3976 /// gcc.
3977 ZeroLengthBitfieldBoundary = 32;
3978
Tim Northover147cd2f2014-10-14 22:12:21 +00003979 if (T.isOSBinFormatMachO())
3980 DescriptionString =
3981 BigEndian
3982 ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3983 : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
3984 else
3985 DescriptionString =
3986 BigEndian
3987 ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
3988 : "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 +00003989
3990 // FIXME: Override "preferred align" for double and long long.
3991 }
3992
Chris Lattner17df24e2008-04-21 18:56:49 +00003993public:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003994 ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00003995 : TargetInfo(Triple), CPU("arm1136j-s"), FPMath(FP_Default),
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00003996 IsAAPCS(true), HW_FP(0) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00003997 BigEndian = IsBigEndian;
3998
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00003999 switch (getTriple().getOS()) {
4000 case llvm::Triple::NetBSD:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00004001 PtrDiffType = SignedLong;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00004002 break;
4003 default:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00004004 PtrDiffType = SignedInt;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00004005 break;
4006 }
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004007
Chris Lattner1a8f3942010-04-23 16:29:58 +00004008 // {} in inline assembly are neon specifiers, not assembly variant
4009 // specifiers.
4010 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004011
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004012 // FIXME: Should we just treat this as a feature?
Daniel Dunbarc454ecf2009-12-18 19:57:13 +00004013 IsThumb = getTriple().getArchName().startswith("thumb");
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004014
Eric Christopher0e261882014-12-05 01:06:59 +00004015 // FIXME: This duplicates code from the driver that sets the -target-abi
4016 // option - this code is used if -target-abi isn't passed and should
4017 // be unified in some way.
4018 if (Triple.isOSBinFormatMachO()) {
4019 // The backend is hardwired to assume AAPCS for M-class processors, ensure
4020 // the frontend matches that.
4021 if (Triple.getEnvironment() == llvm::Triple::EABI ||
4022 Triple.getOS() == llvm::Triple::UnknownOS ||
4023 StringRef(CPU).startswith("cortex-m")) {
4024 setABI("aapcs");
4025 } else {
4026 setABI("apcs-gnu");
4027 }
4028 } else if (Triple.isOSWindows()) {
4029 // FIXME: this is invalid for WindowsCE
4030 setABI("aapcs");
4031 } else {
4032 // Select the default based on the platform.
4033 switch (Triple.getEnvironment()) {
4034 case llvm::Triple::Android:
4035 case llvm::Triple::GNUEABI:
4036 case llvm::Triple::GNUEABIHF:
4037 setABI("aapcs-linux");
4038 break;
4039 case llvm::Triple::EABIHF:
4040 case llvm::Triple::EABI:
4041 setABI("aapcs");
4042 break;
Eric Christopher560cc4f2014-12-18 02:08:55 +00004043 case llvm::Triple::GNU:
4044 setABI("apcs-gnu");
4045 break;
Eric Christopher0e261882014-12-05 01:06:59 +00004046 default:
4047 if (Triple.getOS() == llvm::Triple::NetBSD)
4048 setABI("apcs-gnu");
4049 else
4050 setABI("aapcs");
4051 break;
4052 }
4053 }
John McCall86353412010-08-21 22:46:04 +00004054
4055 // ARM targets default to using the ARM C++ ABI.
John McCall359b8852013-01-25 22:30:49 +00004056 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004057
4058 // ARM has atomics up to 8 bytes
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004059 MaxAtomicPromoteWidth = 64;
Rafael Espindola101d5b92013-05-13 20:09:47 +00004060 if (shouldUseInlineAtomic(getTriple()))
4061 MaxAtomicInlineWidth = 64;
James Molloya7139222012-03-12 09:14:10 +00004062
4063 // Do force alignment of members that follow zero length bitfields. If
Eric Christopher917e9522014-11-18 22:36:15 +00004064 // the alignment of the zero-length bitfield is greater than the member
4065 // that follows it, `bar', `bar' will be aligned as the type of the
James Molloya7139222012-03-12 09:14:10 +00004066 // zero length bitfield.
4067 UseZeroLengthBitfieldAlignment = true;
Eli Friedmanb5366062008-05-20 14:21:01 +00004068 }
Alp Toker4925ba72014-06-07 23:30:42 +00004069 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00004070 bool setABI(const std::string &Name) override {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00004071 ABI = Name;
4072
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00004073 // The defaults (above) are for AAPCS, check if we need to change them.
4074 //
4075 // FIXME: We need support for -meabi... we could just mangle it into the
4076 // name.
4077 if (Name == "apcs-gnu") {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004078 setABIAPCS();
4079 return true;
4080 }
4081 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
4082 setABIAAPCS();
4083 return true;
4084 }
4085 return false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00004086 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00004087
Craig Topper3164f332014-03-11 03:39:26 +00004088 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Silviu Barangae5690462013-10-21 10:59:33 +00004089 StringRef ArchName = getTriple().getArchName();
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004090 if (CPU == "arm1136jf-s" || CPU == "arm1176jzf-s" || CPU == "mpcore")
4091 Features["vfp2"] = true;
Charlie Turner2919cbd2014-11-06 14:59:30 +00004092 else if (CPU == "cortex-a8" || CPU == "cortex-a9") {
Renato Golineefb5772013-09-13 17:02:45 +00004093 Features["vfp3"] = true;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004094 Features["neon"] = true;
Silviu Barangae5690462013-10-21 10:59:33 +00004095 }
4096 else if (CPU == "cortex-a5") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004097 Features["vfp4"] = true;
4098 Features["neon"] = true;
Ana Pazosdd6068d2013-12-06 22:43:17 +00004099 } else if (CPU == "swift" || CPU == "cortex-a7" ||
4100 CPU == "cortex-a12" || CPU == "cortex-a15" ||
Renato Golin5886bc32014-10-13 10:22:48 +00004101 CPU == "cortex-a17" || CPU == "krait") {
Silviu Barangae5690462013-10-21 10:59:33 +00004102 Features["vfp4"] = true;
4103 Features["neon"] = true;
4104 Features["hwdiv"] = true;
4105 Features["hwdiv-arm"] = true;
Tim Northovera2ee4332014-03-29 15:09:45 +00004106 } else if (CPU == "cyclone") {
4107 Features["v8fp"] = true;
4108 Features["neon"] = true;
4109 Features["hwdiv"] = true;
4110 Features["hwdiv-arm"] = true;
Renato Golin84545d72015-02-04 13:31:56 +00004111 } else if (CPU == "cortex-a53" || CPU == "cortex-a57" || CPU == "cortex-a72") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00004112 Features["fp-armv8"] = true;
4113 Features["neon"] = true;
4114 Features["hwdiv"] = true;
4115 Features["hwdiv-arm"] = true;
Bernard Ogden18b57012013-10-29 09:47:51 +00004116 Features["crc"] = true;
Tim Northover02e38602014-02-03 17:28:04 +00004117 Features["crypto"] = true;
Bradley Smithd86d6702015-02-18 10:34:48 +00004118 } else if (CPU == "cortex-r5" || CPU == "cortex-r7" ||
Silviu Barangae5690462013-10-21 10:59:33 +00004119 // Enable the hwdiv extension for all v8a AArch32 cores by
4120 // default.
4121 ArchName == "armv8a" || ArchName == "armv8" ||
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004122 ArchName == "armebv8a" || ArchName == "armebv8" ||
4123 ArchName == "thumbv8a" || ArchName == "thumbv8" ||
4124 ArchName == "thumbebv8a" || ArchName == "thumbebv8") {
Silviu Barangae5690462013-10-21 10:59:33 +00004125 Features["hwdiv"] = true;
4126 Features["hwdiv-arm"] = true;
Bradley Smithd86d6702015-02-18 10:34:48 +00004127 } else if (CPU == "cortex-m3" || CPU == "cortex-m4" || CPU == "cortex-m7" ||
4128 CPU == "sc300") {
Artyom Skrobove72a6f72014-01-29 09:43:07 +00004129 Features["hwdiv"] = true;
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004130 }
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004131 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004132
Craig Topper3164f332014-03-11 03:39:26 +00004133 bool handleTargetFeatures(std::vector<std::string> &Features,
4134 DiagnosticsEngine &Diags) override {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004135 FPU = 0;
Bernard Ogden18b57012013-10-29 09:47:51 +00004136 CRC = 0;
Tim Northover02e38602014-02-03 17:28:04 +00004137 Crypto = 0;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004138 SoftFloat = SoftFloatABI = false;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004139 HWDiv = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00004140
4141 for (const auto &Feature : Features) {
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004142 if (Feature == "+soft-float") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00004143 SoftFloat = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004144 } else if (Feature == "+soft-float-abi") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00004145 SoftFloatABI = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004146 } else if (Feature == "+vfp2") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004147 FPU |= VFP2FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004148 HW_FP = HW_FP_SP | HW_FP_DP;
4149 } else if (Feature == "+vfp3") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004150 FPU |= VFP3FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004151 HW_FP = HW_FP_SP | HW_FP_DP;
4152 } else if (Feature == "+vfp4") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004153 FPU |= VFP4FPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004154 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
4155 } else if (Feature == "+fp-armv8") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00004156 FPU |= FPARMV8;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004157 HW_FP = HW_FP_SP | HW_FP_DP | HW_FP_HP;
4158 } else if (Feature == "+neon") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004159 FPU |= NeonFPU;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004160 HW_FP = HW_FP_SP | HW_FP_DP;
4161 } else if (Feature == "+hwdiv") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004162 HWDiv |= HWDivThumb;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004163 } else if (Feature == "+hwdiv-arm") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004164 HWDiv |= HWDivARM;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004165 } else if (Feature == "+crc") {
Bernard Ogden18b57012013-10-29 09:47:51 +00004166 CRC = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004167 } else if (Feature == "+crypto") {
Tim Northover02e38602014-02-03 17:28:04 +00004168 Crypto = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004169 } else if (Feature == "+fp-only-sp") {
4170 HW_FP &= ~HW_FP_DP;
4171 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00004172 }
4173
Rafael Espindolaeb265472013-08-21 21:59:03 +00004174 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
4175 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
4176 return false;
4177 }
4178
4179 if (FPMath == FP_Neon)
4180 Features.push_back("+neonfp");
4181 else if (FPMath == FP_VFP)
4182 Features.push_back("-neonfp");
4183
Daniel Dunbar893d4752009-12-19 04:15:38 +00004184 // Remove front-end specific options which the backend handles differently.
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00004185 const StringRef FrontEndFeatures[] = { "+soft-float", "+soft-float-abi" };
4186 for (const auto &FEFeature : FrontEndFeatures) {
4187 auto Feature = std::find(Features.begin(), Features.end(), FEFeature);
4188 if (Feature != Features.end())
4189 Features.erase(Feature);
4190 }
4191
Rafael Espindolaeb265472013-08-21 21:59:03 +00004192 return true;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004193 }
4194
Craig Topper3164f332014-03-11 03:39:26 +00004195 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004196 return llvm::StringSwitch<bool>(Feature)
4197 .Case("arm", true)
4198 .Case("softfloat", SoftFloat)
4199 .Case("thumb", IsThumb)
Amara Emerson8c3de542013-09-16 18:07:35 +00004200 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004201 .Case("hwdiv", HWDiv & HWDivThumb)
4202 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004203 .Default(false);
4204 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004205 // FIXME: Should we actually have some table instead of these switches?
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004206 static const char *getCPUDefineSuffix(StringRef Name) {
Eric Christopher917e9522014-11-18 22:36:15 +00004207 return llvm::StringSwitch<const char *>(Name)
4208 .Cases("arm8", "arm810", "4")
4209 .Cases("strongarm", "strongarm110", "strongarm1100", "strongarm1110",
4210 "4")
4211 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "arm720t", "arm9", "4T")
4212 .Cases("arm9tdmi", "arm920", "arm920t", "arm922t", "arm940t", "4T")
4213 .Case("ep9312", "4T")
4214 .Cases("arm10tdmi", "arm1020t", "5T")
4215 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "5TE")
4216 .Case("arm926ej-s", "5TEJ")
4217 .Cases("arm10e", "arm1020e", "arm1022e", "5TE")
4218 .Cases("xscale", "iwmmxt", "5TE")
4219 .Case("arm1136j-s", "6J")
Renato Goline11531f2015-03-17 11:55:43 +00004220 .Case("arm1136jf-s", "6")
4221 .Cases("mpcorenovfp", "mpcore", "6K")
4222 .Cases("arm1176jz-s", "arm1176jzf-s", "6K")
Eric Christopher917e9522014-11-18 22:36:15 +00004223 .Cases("arm1156t2-s", "arm1156t2f-s", "6T2")
4224 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "7A")
4225 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait",
4226 "7A")
Bradley Smithd86d6702015-02-18 10:34:48 +00004227 .Cases("cortex-r4", "cortex-r5", "cortex-r7", "7R")
Eric Christopher917e9522014-11-18 22:36:15 +00004228 .Case("swift", "7S")
4229 .Case("cyclone", "8A")
Bradley Smithd86d6702015-02-18 10:34:48 +00004230 .Cases("sc300", "cortex-m3", "7M")
Eric Christopher917e9522014-11-18 22:36:15 +00004231 .Cases("cortex-m4", "cortex-m7", "7EM")
Bradley Smithd86d6702015-02-18 10:34:48 +00004232 .Cases("sc000", "cortex-m0", "cortex-m0plus", "cortex-m1", "6M")
Renato Golin84545d72015-02-04 13:31:56 +00004233 .Cases("cortex-a53", "cortex-a57", "cortex-a72", "8A")
Eric Christopher917e9522014-11-18 22:36:15 +00004234 .Default(nullptr);
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004235 }
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004236 static const char *getCPUProfile(StringRef Name) {
Eric Christopher917e9522014-11-18 22:36:15 +00004237 return llvm::StringSwitch<const char *>(Name)
4238 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "A")
4239 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "cortex-a17", "krait",
4240 "A")
Renato Golin84545d72015-02-04 13:31:56 +00004241 .Cases("cortex-a53", "cortex-a57", "cortex-a72", "A")
Bradley Smithd86d6702015-02-18 10:34:48 +00004242 .Cases("cortex-m3", "cortex-m4", "cortex-m0", "cortex-m0plus", "M")
4243 .Cases("cortex-m1", "cortex-m7", "sc000", "sc300", "M")
4244 .Cases("cortex-r4", "cortex-r5", "cortex-r7", "R")
Eric Christopher917e9522014-11-18 22:36:15 +00004245 .Default("");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004246 }
Craig Topper3164f332014-03-11 03:39:26 +00004247 bool setCPU(const std::string &Name) override {
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004248 if (!getCPUDefineSuffix(Name))
4249 return false;
4250
Tim Northovere8c37212014-07-09 09:24:43 +00004251 // Cortex M does not support 8 byte atomics, while general Thumb2 does.
4252 StringRef Profile = getCPUProfile(Name);
4253 if (Profile == "M" && MaxAtomicInlineWidth) {
4254 MaxAtomicPromoteWidth = 32;
4255 MaxAtomicInlineWidth = 32;
4256 }
4257
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004258 CPU = Name;
4259 return true;
4260 }
Craig Topper3164f332014-03-11 03:39:26 +00004261 bool setFPMath(StringRef Name) override;
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004262 bool supportsThumb(StringRef ArchName, StringRef CPUArch,
4263 unsigned CPUArchVer) const {
4264 return CPUArchVer >= 7 || (CPUArch.find('T') != StringRef::npos) ||
4265 (CPUArch.find('M') != StringRef::npos);
4266 }
4267 bool supportsThumb2(StringRef ArchName, StringRef CPUArch,
4268 unsigned CPUArchVer) const {
4269 // We check both CPUArchVer and ArchName because when only triple is
4270 // specified, the default CPU is arm1136j-s.
4271 return ArchName.endswith("v6t2") || ArchName.endswith("v7") ||
4272 ArchName.endswith("v8") || CPUArch == "6T2" || CPUArchVer >= 7;
4273 }
Craig Topper3164f332014-03-11 03:39:26 +00004274 void getTargetDefines(const LangOptions &Opts,
4275 MacroBuilder &Builder) const override {
Chris Lattnerecd49032009-03-02 22:27:17 +00004276 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004277 Builder.defineMacro("__arm");
4278 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00004279
Chris Lattnerecd49032009-03-02 22:27:17 +00004280 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004281 Builder.defineMacro("__REGISTER_PREFIX__", "");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004282
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004283 StringRef CPUArch = getCPUDefineSuffix(CPU);
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004284 unsigned int CPUArchVer;
Saleem Abdulrasool820e9272014-09-17 14:50:19 +00004285 if (CPUArch.substr(0, 1).getAsInteger<unsigned int>(10, CPUArchVer))
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004286 llvm_unreachable("Invalid char for architecture version number");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004287 Builder.defineMacro("__ARM_ARCH_" + CPUArch + "__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004288
4289 // ACLE 6.4.1 ARM/Thumb instruction set architecture
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004290 StringRef CPUProfile = getCPUProfile(CPU);
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004291 StringRef ArchName = getTriple().getArchName();
4292
4293 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
4294 Builder.defineMacro("__ARM_ARCH", CPUArch.substr(0, 1));
Eric Christopher917e9522014-11-18 22:36:15 +00004295 if (CPUArch[0] >= '8') {
4296 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4297 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
James Molloy0ffb0932014-09-15 11:25:38 +00004298 }
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004299
4300 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It
4301 // is not defined for the M-profile.
4302 // NOTE that the deffault profile is assumed to be 'A'
4303 if (CPUProfile.empty() || CPUProfile != "M")
4304 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
4305
4306 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original
4307 // Thumb ISA (including v6-M). It is set to 2 if the core supports the
4308 // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture.
4309 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
4310 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
4311 else if (supportsThumb(ArchName, CPUArch, CPUArchVer))
4312 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
4313
4314 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
4315 // instruction set such as ARM or Thumb.
4316 Builder.defineMacro("__ARM_32BIT_STATE", "1");
4317
4318 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
4319
4320 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004321 if (!CPUProfile.empty())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004322 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004323
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004324 // ACLE 6.5.1 Hardware Floating Point
4325 if (HW_FP)
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +00004326 Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004327
Yi Konga44c4d72014-06-27 21:25:42 +00004328 // ACLE predefines.
4329 Builder.defineMacro("__ARM_ACLE", "200");
4330
Mike Stump9d54bd72009-04-08 02:07:04 +00004331 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004332
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004333 // FIXME: It's more complicated than this and we don't really support
4334 // interworking.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004335 // Windows on ARM does not "support" interworking
4336 if (5 <= CPUArchVer && CPUArchVer <= 8 && !getTriple().isOSWindows())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004337 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004338
David Tweed8f676532012-10-25 13:33:01 +00004339 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Tim Northovere77f78c2013-11-11 19:11:22 +00004340 // Embedded targets on Darwin follow AAPCS, but not EABI.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004341 // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
4342 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
Daniel Dunbarf7124da2012-10-22 18:51:13 +00004343 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004344 Builder.defineMacro("__ARM_PCS", "1");
4345
David Tweed8f676532012-10-25 13:33:01 +00004346 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004347 Builder.defineMacro("__ARM_PCS_VFP", "1");
4348 }
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004349
Daniel Dunbar893d4752009-12-19 04:15:38 +00004350 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004351 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004352
4353 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004354 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004355
4356 if (IsThumb) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004357 Builder.defineMacro("__THUMBEL__");
4358 Builder.defineMacro("__thumb__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004359 if (supportsThumb2(ArchName, CPUArch, CPUArchVer))
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004360 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004361 }
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004362 if (((HWDiv & HWDivThumb) && IsThumb) || ((HWDiv & HWDivARM) && !IsThumb))
4363 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004364
4365 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004366 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004367
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004368 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004369 Builder.defineMacro("__VFP_FP__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004370 if (FPU & VFP2FPU)
4371 Builder.defineMacro("__ARM_VFPV2__");
4372 if (FPU & VFP3FPU)
4373 Builder.defineMacro("__ARM_VFPV3__");
4374 if (FPU & VFP4FPU)
4375 Builder.defineMacro("__ARM_VFPV4__");
4376 }
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004377
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004378 // This only gets set when Neon instructions are actually available, unlike
4379 // the VFP define, hence the soft float and arch check. This is subtly
4380 // different from gcc, we follow the intent which was that it should be set
4381 // when Neon instructions are actually available.
Tim Northover5bb34ca2013-11-21 12:36:34 +00004382 if ((FPU & NeonFPU) && !SoftFloat && CPUArchVer >= 7) {
4383 Builder.defineMacro("__ARM_NEON");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004384 Builder.defineMacro("__ARM_NEON__");
Tim Northover5bb34ca2013-11-21 12:36:34 +00004385 }
Joey Gouly1e8637b2013-09-18 10:07:09 +00004386
Bradley Smith0f28f0c2014-01-20 10:52:00 +00004387 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
4388 Opts.ShortWChar ? "2" : "4");
4389
4390 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4391 Opts.ShortEnums ? "1" : "4");
4392
Bernard Ogden18b57012013-10-29 09:47:51 +00004393 if (CRC)
Joey Gouly1e8637b2013-09-18 10:07:09 +00004394 Builder.defineMacro("__ARM_FEATURE_CRC32");
Weiming Zhao53a797c2013-09-30 22:51:32 +00004395
Tim Northover02e38602014-02-03 17:28:04 +00004396 if (Crypto)
4397 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
4398
Bernard Ogden58a05cf2013-10-24 18:32:44 +00004399 if (CPUArchVer >= 6 && CPUArch != "6M") {
Weiming Zhao53a797c2013-09-30 22:51:32 +00004400 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4401 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4402 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4403 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4404 }
Sergey Dmitrouk745f5302014-11-25 08:57:36 +00004405
4406 bool is5EOrAbove = (CPUArchVer >= 6 ||
4407 (CPUArchVer == 5 &&
4408 CPUArch.find('E') != StringRef::npos));
4409 bool is32Bit = (!IsThumb || supportsThumb2(ArchName, CPUArch, CPUArchVer));
4410 if (is5EOrAbove && is32Bit && (CPUProfile != "M" || CPUArch == "7EM"))
4411 Builder.defineMacro("__ARM_FEATURE_DSP");
Chris Lattner17df24e2008-04-21 18:56:49 +00004412 }
Craig Topper3164f332014-03-11 03:39:26 +00004413 void getTargetBuiltins(const Builtin::Info *&Records,
4414 unsigned &NumRecords) const override {
Chris Lattner5cc15e02010-03-03 19:03:45 +00004415 Records = BuiltinInfo;
4416 NumRecords = clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin;
Chris Lattner17df24e2008-04-21 18:56:49 +00004417 }
Craig Topper3164f332014-03-11 03:39:26 +00004418 bool isCLZForZeroUndef() const override { return false; }
4419 BuiltinVaListKind getBuiltinVaListKind() const override {
Logan Chien57086ce2012-10-10 06:56:20 +00004420 return IsAAPCS ? AAPCSABIBuiltinVaList : TargetInfo::VoidPtrBuiltinVaList;
Chris Lattner17df24e2008-04-21 18:56:49 +00004421 }
Craig Topper3164f332014-03-11 03:39:26 +00004422 void getGCCRegNames(const char * const *&Names,
4423 unsigned &NumNames) const override;
4424 void getGCCRegAliases(const GCCRegAlias *&Aliases,
4425 unsigned &NumAliases) const override;
4426 bool validateAsmConstraint(const char *&Name,
4427 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00004428 switch (*Name) {
Eric Christopher9e491882012-08-16 23:50:41 +00004429 default: break;
Nate Begeman2908fa02008-04-22 05:03:19 +00004430 case 'l': // r0-r7
4431 case 'h': // r8-r15
4432 case 'w': // VFP Floating point register single precision
4433 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00004434 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00004435 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00004436 case 'I':
4437 case 'J':
4438 case 'K':
4439 case 'L':
4440 case 'M':
4441 // FIXME
4442 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00004443 case 'Q': // A memory address that is a single base register.
4444 Info.setAllowsMemory();
4445 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004446 case 'U': // a memory reference...
4447 switch (Name[1]) {
4448 case 'q': // ...ARMV4 ldrsb
4449 case 'v': // ...VFP load/store (reg+constant offset)
4450 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00004451 case 't': // address valid for load/store opaque types wider
Eric Christopherfd081ca2012-11-14 22:08:59 +00004452 // than 128-bits
Eric Christopherd1048542011-06-17 01:40:49 +00004453 case 'n': // valid address for Neon doubleword vector load/store
4454 case 'm': // valid address for Neon element and structure load/store
4455 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopherfd081ca2012-11-14 22:08:59 +00004456 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004457 Info.setAllowsMemory();
4458 Name++;
4459 return true;
4460 }
Nate Begeman2908fa02008-04-22 05:03:19 +00004461 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004462 return false;
4463 }
Craig Topper3164f332014-03-11 03:39:26 +00004464 std::string convertConstraint(const char *&Constraint) const override {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004465 std::string R;
4466 switch (*Constraint) {
4467 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00004468 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004469 Constraint++;
4470 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00004471 case 'p': // 'p' should be translated to 'r' by default.
4472 R = std::string("r");
4473 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004474 default:
4475 return std::string(1, *Constraint);
4476 }
4477 return R;
4478 }
Akira Hatanaka987f1862014-08-22 06:05:21 +00004479 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004480 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004481 std::string &SuggestedModifier) const override {
Bill Wendling3c6591d2012-11-30 23:18:12 +00004482 bool isOutput = (Constraint[0] == '=');
Bill Wendling05175082012-11-30 23:46:56 +00004483 bool isInOut = (Constraint[0] == '+');
Bill Wendling3c6591d2012-11-30 23:18:12 +00004484
Bill Wendling9d1ee112012-10-25 23:28:48 +00004485 // Strip off constraint modifiers.
4486 while (Constraint[0] == '=' ||
4487 Constraint[0] == '+' ||
4488 Constraint[0] == '&')
4489 Constraint = Constraint.substr(1);
4490
4491 switch (Constraint[0]) {
4492 default: break;
4493 case 'r': {
4494 switch (Modifier) {
4495 default:
Tim Northover8f24b172013-12-08 15:24:55 +00004496 return (isInOut || isOutput || Size <= 64);
Bill Wendling9d1ee112012-10-25 23:28:48 +00004497 case 'q':
4498 // A register of size 32 cannot fit a vector type.
4499 return false;
4500 }
4501 }
4502 }
4503
4504 return true;
4505 }
Craig Topper3164f332014-03-11 03:39:26 +00004506 const char *getClobbers() const override {
Eli Friedmanf05b7722008-08-20 07:44:10 +00004507 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00004508 return "";
4509 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004510
Craig Topper3164f332014-03-11 03:39:26 +00004511 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004512 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4513 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00004514
Craig Topper3164f332014-03-11 03:39:26 +00004515 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00004516 if (RegNo == 0) return 0;
4517 if (RegNo == 1) return 1;
4518 return -1;
4519 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004520};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004521
Rafael Espindolaeb265472013-08-21 21:59:03 +00004522bool ARMTargetInfo::setFPMath(StringRef Name) {
4523 if (Name == "neon") {
4524 FPMath = FP_Neon;
4525 return true;
4526 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
4527 Name == "vfp4") {
4528 FPMath = FP_VFP;
4529 return true;
4530 }
4531 return false;
4532}
4533
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004534const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004535 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004536 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004537 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
4538
4539 // Float registers
4540 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
4541 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
4542 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004543 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00004544
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004545 // Double registers
4546 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
4547 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004548 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
4549 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004550
4551 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00004552 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
4553 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004554};
4555
4556void ARMTargetInfo::getGCCRegNames(const char * const *&Names,
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004557 unsigned &NumNames) const {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004558 Names = GCCRegNames;
4559 NumNames = llvm::array_lengthof(GCCRegNames);
4560}
4561
4562const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004563 { { "a1" }, "r0" },
4564 { { "a2" }, "r1" },
4565 { { "a3" }, "r2" },
4566 { { "a4" }, "r3" },
4567 { { "v1" }, "r4" },
4568 { { "v2" }, "r5" },
4569 { { "v3" }, "r6" },
4570 { { "v4" }, "r7" },
4571 { { "v5" }, "r8" },
4572 { { "v6", "rfp" }, "r9" },
4573 { { "sl" }, "r10" },
4574 { { "fp" }, "r11" },
4575 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00004576 { { "r13" }, "sp" },
4577 { { "r14" }, "lr" },
4578 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00004579 // The S, D and Q registers overlap, but aren't really aliases; we
4580 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004581};
4582
4583void ARMTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
4584 unsigned &NumAliases) const {
4585 Aliases = GCCRegAliases;
4586 NumAliases = llvm::array_lengthof(GCCRegAliases);
4587}
Chris Lattner5cc15e02010-03-03 19:03:45 +00004588
4589const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004590#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Fariborz Jahaniane8473c22010-11-30 17:35:24 +00004591#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
Eli Friedmanbb5c9ae2011-07-05 21:53:01 +00004592 ALL_LANGUAGES },
Tim Northovera2ee4332014-03-29 15:09:45 +00004593#include "clang/Basic/BuiltinsNEON.def"
Tim Northoverc322f832014-01-30 14:47:51 +00004594
4595#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Saleem Abdulrasool4bddd9d2014-07-02 17:41:27 +00004596#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) { #ID, TYPE, ATTRS, 0, LANG },
Tim Northoverc322f832014-01-30 14:47:51 +00004597#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
4598 ALL_LANGUAGES },
Chris Lattner5cc15e02010-03-03 19:03:45 +00004599#include "clang/Basic/BuiltinsARM.def"
4600};
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004601
4602class ARMleTargetInfo : public ARMTargetInfo {
4603public:
4604 ARMleTargetInfo(const llvm::Triple &Triple)
4605 : ARMTargetInfo(Triple, false) { }
4606 virtual void getTargetDefines(const LangOptions &Opts,
4607 MacroBuilder &Builder) const {
4608 Builder.defineMacro("__ARMEL__");
4609 ARMTargetInfo::getTargetDefines(Opts, Builder);
4610 }
4611};
4612
4613class ARMbeTargetInfo : public ARMTargetInfo {
4614public:
4615 ARMbeTargetInfo(const llvm::Triple &Triple)
4616 : ARMTargetInfo(Triple, true) { }
4617 virtual void getTargetDefines(const LangOptions &Opts,
4618 MacroBuilder &Builder) const {
4619 Builder.defineMacro("__ARMEB__");
4620 Builder.defineMacro("__ARM_BIG_ENDIAN");
4621 ARMTargetInfo::getTargetDefines(Opts, Builder);
4622 }
4623};
Chris Lattner17df24e2008-04-21 18:56:49 +00004624} // end anonymous namespace.
4625
Eli Friedmanf05b7722008-08-20 07:44:10 +00004626namespace {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004627class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
4628 const llvm::Triple Triple;
4629public:
4630 WindowsARMTargetInfo(const llvm::Triple &Triple)
4631 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
4632 TLSSupported = false;
4633 WCharType = UnsignedShort;
4634 SizeType = UnsignedInt;
4635 UserLabelPrefix = "";
4636 }
4637 void getVisualStudioDefines(const LangOptions &Opts,
4638 MacroBuilder &Builder) const {
4639 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
4640
4641 // FIXME: this is invalid for WindowsCE
4642 Builder.defineMacro("_M_ARM_NT", "1");
4643 Builder.defineMacro("_M_ARMT", "_M_ARM");
4644 Builder.defineMacro("_M_THUMB", "_M_ARM");
4645
4646 assert((Triple.getArch() == llvm::Triple::arm ||
4647 Triple.getArch() == llvm::Triple::thumb) &&
4648 "invalid architecture for Windows ARM target info");
4649 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
4650 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
4651
4652 // TODO map the complete set of values
4653 // 31: VFPv3 40: VFPv4
4654 Builder.defineMacro("_M_ARM_FP", "31");
4655 }
Saleem Abdulrasool521cec82014-06-29 23:05:41 +00004656 BuiltinVaListKind getBuiltinVaListKind() const override {
4657 return TargetInfo::CharPtrBuiltinVaList;
4658 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004659};
4660
4661// Windows ARM + Itanium C++ ABI Target
4662class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
4663public:
4664 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple)
4665 : WindowsARMTargetInfo(Triple) {
4666 TheCXXABI.set(TargetCXXABI::GenericARM);
4667 }
4668
4669 void getTargetDefines(const LangOptions &Opts,
4670 MacroBuilder &Builder) const override {
4671 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4672
4673 if (Opts.MSVCCompat)
4674 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4675 }
4676};
4677
4678// Windows ARM, MS (C++) ABI
4679class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
4680public:
4681 MicrosoftARMleTargetInfo(const llvm::Triple &Triple)
4682 : WindowsARMTargetInfo(Triple) {
4683 TheCXXABI.set(TargetCXXABI::Microsoft);
4684 }
4685
4686 void getTargetDefines(const LangOptions &Opts,
4687 MacroBuilder &Builder) const override {
4688 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
4689 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
4690 }
4691};
4692}
4693
4694
4695namespace {
Mike Stump11289f42009-09-09 15:08:12 +00004696class DarwinARMTargetInfo :
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004697 public DarwinTargetInfo<ARMleTargetInfo> {
Torok Edwinb2b37c62009-06-30 17:10:35 +00004698protected:
Craig Topper3164f332014-03-11 03:39:26 +00004699 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4700 MacroBuilder &Builder) const override {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00004701 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00004702 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004703
Torok Edwinb2b37c62009-06-30 17:10:35 +00004704public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004705 DarwinARMTargetInfo(const llvm::Triple &Triple)
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004706 : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004707 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004708 // iOS always has 64-bit atomic instructions.
Eric Christopher917e9522014-11-18 22:36:15 +00004709 // FIXME: This should be based off of the target features in
4710 // ARMleTargetInfo.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004711 MaxAtomicInlineWidth = 64;
John McCall359b8852013-01-25 22:30:49 +00004712
4713 // Darwin on iOS uses a variant of the ARM C++ ABI.
4714 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00004715 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00004716};
4717} // end anonymous namespace.
4718
Tony Linthicum76329bf2011-12-12 21:14:55 +00004719
4720namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00004721class AArch64TargetInfo : public TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00004722 virtual void setDescriptionString() = 0;
Tim Northovera2ee4332014-03-29 15:09:45 +00004723 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4724 static const char *const GCCRegNames[];
4725
James Molloy75f5f9e2014-04-16 15:33:48 +00004726 enum FPUModeEnum {
4727 FPUMode,
4728 NeonMode
4729 };
4730
4731 unsigned FPU;
Bradley Smith418c5932014-05-02 15:17:51 +00004732 unsigned CRC;
James Molloy75f5f9e2014-04-16 15:33:48 +00004733 unsigned Crypto;
4734
Tim Northovera2ee4332014-03-29 15:09:45 +00004735 static const Builtin::Info BuiltinInfo[];
4736
4737 std::string ABI;
4738
4739public:
Tim Northover573cbee2014-05-24 12:52:07 +00004740 AArch64TargetInfo(const llvm::Triple &Triple)
Tim Northovera2ee4332014-03-29 15:09:45 +00004741 : TargetInfo(Triple), ABI("aapcs") {
Tim Northover25e8a672014-05-24 12:51:25 +00004742
4743 if (getTriple().getOS() == llvm::Triple::NetBSD) {
4744 WCharType = SignedInt;
4745
4746 // NetBSD apparently prefers consistency across ARM targets to consistency
4747 // across 64-bit targets.
4748 Int64Type = SignedLongLong;
4749 IntMaxType = SignedLongLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004750 } else {
4751 WCharType = UnsignedInt;
4752 Int64Type = SignedLong;
4753 IntMaxType = SignedLong;
Tim Northover25e8a672014-05-24 12:51:25 +00004754 }
4755
Tim Northovera2ee4332014-03-29 15:09:45 +00004756 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00004757 MaxVectorAlign = 128;
4758 RegParmMax = 8;
4759 MaxAtomicInlineWidth = 128;
4760 MaxAtomicPromoteWidth = 128;
4761
Tim Northovera6a19f12015-02-06 01:25:07 +00004762 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
Tim Northovera2ee4332014-03-29 15:09:45 +00004763 LongDoubleFormat = &llvm::APFloat::IEEEquad;
4764
Tim Northovera2ee4332014-03-29 15:09:45 +00004765 // {} in inline assembly are neon specifiers, not assembly variant
4766 // specifiers.
4767 NoAsmVariants = true;
4768
Tim Northover7ad87af2015-01-16 18:44:04 +00004769 // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
4770 // contributes to the alignment of the containing aggregate in the same way
4771 // a plain (non bit-field) member of that type would, without exception for
4772 // zero-sized or anonymous bit-fields."
4773 UseBitFieldTypeAlignment = true;
4774 UseZeroLengthBitfieldAlignment = true;
4775
Tim Northover573cbee2014-05-24 12:52:07 +00004776 // AArch64 targets default to using the ARM C++ ABI.
Tim Northovera2ee4332014-03-29 15:09:45 +00004777 TheCXXABI.set(TargetCXXABI::GenericAArch64);
4778 }
4779
Alp Toker4925ba72014-06-07 23:30:42 +00004780 StringRef getABI() const override { return ABI; }
David Blaikie1cbb9712014-11-14 19:09:44 +00004781 bool setABI(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004782 if (Name != "aapcs" && Name != "darwinpcs")
4783 return false;
4784
4785 ABI = Name;
4786 return true;
4787 }
4788
David Blaikie1cbb9712014-11-14 19:09:44 +00004789 bool setCPU(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004790 bool CPUKnown = llvm::StringSwitch<bool>(Name)
James Molloy5e73df52014-04-16 15:06:20 +00004791 .Case("generic", true)
Renato Golin84545d72015-02-04 13:31:56 +00004792 .Cases("cortex-a53", "cortex-a57", "cortex-a72", true)
Tim Northovera2ee4332014-03-29 15:09:45 +00004793 .Case("cyclone", true)
4794 .Default(false);
4795 return CPUKnown;
4796 }
4797
4798 virtual void getTargetDefines(const LangOptions &Opts,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004799 MacroBuilder &Builder) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004800 // Target identification.
Tim Northovera2ee4332014-03-29 15:09:45 +00004801 Builder.defineMacro("__aarch64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004802
4803 // Target properties.
4804 Builder.defineMacro("_LP64");
4805 Builder.defineMacro("__LP64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00004806
4807 // ACLE predefines. Many can only have one possible value on v8 AArch64.
4808 Builder.defineMacro("__ARM_ACLE", "200");
4809 Builder.defineMacro("__ARM_ARCH", "8");
4810 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
4811
4812 Builder.defineMacro("__ARM_64BIT_STATE");
4813 Builder.defineMacro("__ARM_PCS_AAPCS64");
4814 Builder.defineMacro("__ARM_ARCH_ISA_A64");
4815
4816 Builder.defineMacro("__ARM_FEATURE_UNALIGNED");
4817 Builder.defineMacro("__ARM_FEATURE_CLZ");
4818 Builder.defineMacro("__ARM_FEATURE_FMA");
4819 Builder.defineMacro("__ARM_FEATURE_DIV");
James Molloy0ffb0932014-09-15 11:25:38 +00004820 Builder.defineMacro("__ARM_FEATURE_IDIV"); // As specified in ACLE
4821 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility
4822 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN");
4823 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING");
Tim Northovera2ee4332014-03-29 15:09:45 +00004824
4825 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
4826
4827 // 0xe implies support for half, single and double precision operations.
4828 Builder.defineMacro("__ARM_FP", "0xe");
4829
4830 // PCS specifies this for SysV variants, which is all we support. Other ABIs
4831 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
4832 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE");
4833
4834 if (Opts.FastMath || Opts.FiniteMathOnly)
4835 Builder.defineMacro("__ARM_FP_FAST");
4836
Richard Smithab506ad2014-10-20 23:26:58 +00004837 if (Opts.C99 && !Opts.Freestanding)
Tim Northovera2ee4332014-03-29 15:09:45 +00004838 Builder.defineMacro("__ARM_FP_FENV_ROUNDING");
4839
4840 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
4841
4842 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4843 Opts.ShortEnums ? "1" : "4");
4844
James Molloy75f5f9e2014-04-16 15:33:48 +00004845 if (FPU == NeonMode) {
4846 Builder.defineMacro("__ARM_NEON");
4847 // 64-bit NEON supports half, single and double precision operations.
Bradley Smith9a6b2952014-05-02 15:18:38 +00004848 Builder.defineMacro("__ARM_NEON_FP", "0xe");
James Molloy75f5f9e2014-04-16 15:33:48 +00004849 }
Tim Northovera2ee4332014-03-29 15:09:45 +00004850
Bradley Smith418c5932014-05-02 15:17:51 +00004851 if (CRC)
4852 Builder.defineMacro("__ARM_FEATURE_CRC32");
4853
James Molloy75f5f9e2014-04-16 15:33:48 +00004854 if (Crypto)
4855 Builder.defineMacro("__ARM_FEATURE_CRYPTO");
Tim Northovera2ee4332014-03-29 15:09:45 +00004856 }
4857
4858 virtual void getTargetBuiltins(const Builtin::Info *&Records,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004859 unsigned &NumRecords) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004860 Records = BuiltinInfo;
Tim Northover573cbee2014-05-24 12:52:07 +00004861 NumRecords = clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin;
Tim Northovera2ee4332014-03-29 15:09:45 +00004862 }
4863
David Blaikie1cbb9712014-11-14 19:09:44 +00004864 bool hasFeature(StringRef Feature) const override {
James Molloy75f5f9e2014-04-16 15:33:48 +00004865 return Feature == "aarch64" ||
4866 Feature == "arm64" ||
4867 (Feature == "neon" && FPU == NeonMode);
Tim Northovera2ee4332014-03-29 15:09:45 +00004868 }
4869
James Molloy5e73df52014-04-16 15:06:20 +00004870 bool handleTargetFeatures(std::vector<std::string> &Features,
4871 DiagnosticsEngine &Diags) override {
James Molloy75f5f9e2014-04-16 15:33:48 +00004872 FPU = FPUMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004873 CRC = 0;
James Molloy75f5f9e2014-04-16 15:33:48 +00004874 Crypto = 0;
4875 for (unsigned i = 0, e = Features.size(); i != e; ++i) {
4876 if (Features[i] == "+neon")
4877 FPU = NeonMode;
Bradley Smith418c5932014-05-02 15:17:51 +00004878 if (Features[i] == "+crc")
4879 CRC = 1;
James Molloy75f5f9e2014-04-16 15:33:48 +00004880 if (Features[i] == "+crypto")
4881 Crypto = 1;
4882 }
4883
James Molloy5e73df52014-04-16 15:06:20 +00004884 setDescriptionString();
4885
4886 return true;
4887 }
4888
David Blaikie1cbb9712014-11-14 19:09:44 +00004889 bool isCLZForZeroUndef() const override { return false; }
Tim Northovera2ee4332014-03-29 15:09:45 +00004890
David Blaikie1cbb9712014-11-14 19:09:44 +00004891 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004892 return TargetInfo::AArch64ABIBuiltinVaList;
4893 }
4894
4895 virtual void getGCCRegNames(const char *const *&Names,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004896 unsigned &NumNames) const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00004897 virtual void getGCCRegAliases(const GCCRegAlias *&Aliases,
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004898 unsigned &NumAliases) const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00004899
Eric Christopher917e9522014-11-18 22:36:15 +00004900 virtual bool
4901 validateAsmConstraint(const char *&Name,
4902 TargetInfo::ConstraintInfo &Info) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004903 switch (*Name) {
4904 default:
4905 return false;
4906 case 'w': // Floating point and SIMD registers (V0-V31)
4907 Info.setAllowsRegister();
4908 return true;
James Molloy8bdd24b2014-04-23 10:26:19 +00004909 case 'I': // Constant that can be used with an ADD instruction
4910 case 'J': // Constant that can be used with a SUB instruction
4911 case 'K': // Constant that can be used with a 32-bit logical instruction
4912 case 'L': // Constant that can be used with a 64-bit logical instruction
4913 case 'M': // Constant that can be used as a 32-bit MOV immediate
4914 case 'N': // Constant that can be used as a 64-bit MOV immediate
4915 case 'Y': // Floating point constant zero
4916 case 'Z': // Integer constant zero
4917 return true;
4918 case 'Q': // A memory reference with base register and no offset
4919 Info.setAllowsMemory();
4920 return true;
4921 case 'S': // A symbolic address
4922 Info.setAllowsRegister();
4923 return true;
4924 case 'U':
Eric Christopher917e9522014-11-18 22:36:15 +00004925 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
4926 // Utf: A memory address suitable for ldp/stp in TF mode.
4927 // Usa: An absolute symbolic address.
4928 // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
4929 llvm_unreachable("FIXME: Unimplemented support for U* constraints.");
Tim Northovera2ee4332014-03-29 15:09:45 +00004930 case 'z': // Zero register, wzr or xzr
4931 Info.setAllowsRegister();
4932 return true;
4933 case 'x': // Floating point and SIMD registers (V0-V15)
4934 Info.setAllowsRegister();
4935 return true;
Tim Northovera2ee4332014-03-29 15:09:45 +00004936 }
4937 return false;
4938 }
4939
Akira Hatanaka987f1862014-08-22 06:05:21 +00004940 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004941 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004942 std::string &SuggestedModifier) const override {
James Molloy8a157bf2014-07-25 10:19:47 +00004943 // Strip off constraint modifiers.
4944 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
4945 Constraint = Constraint.substr(1);
4946
4947 switch (Constraint[0]) {
4948 default:
4949 return true;
4950 case 'z':
4951 case 'r': {
4952 switch (Modifier) {
4953 case 'x':
4954 case 'w':
4955 // For now assume that the person knows what they're
4956 // doing with the modifier.
4957 return true;
4958 default:
4959 // By default an 'r' constraint will be in the 'x'
4960 // registers.
Akira Hatanaka987f1862014-08-22 06:05:21 +00004961 if (Size == 64)
4962 return true;
4963
4964 SuggestedModifier = "w";
4965 return false;
James Molloy8a157bf2014-07-25 10:19:47 +00004966 }
4967 }
4968 }
4969 }
4970
David Blaikie1cbb9712014-11-14 19:09:44 +00004971 const char *getClobbers() const override { return ""; }
Tim Northovera2ee4332014-03-29 15:09:45 +00004972
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00004973 int getEHDataRegisterNumber(unsigned RegNo) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00004974 if (RegNo == 0)
4975 return 0;
4976 if (RegNo == 1)
4977 return 1;
4978 return -1;
4979 }
4980};
4981
Tim Northover573cbee2014-05-24 12:52:07 +00004982const char *const AArch64TargetInfo::GCCRegNames[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00004983 // 32-bit Integer registers
4984 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
4985 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
4986 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
4987
4988 // 64-bit Integer registers
4989 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
4990 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
4991 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
4992
4993 // 32-bit floating point regsisters
4994 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10",
4995 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
4996 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
4997
4998 // 64-bit floating point regsisters
4999 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
5000 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
5001 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
5002
5003 // Vector registers
5004 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10",
5005 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
5006 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
5007};
5008
Tim Northover573cbee2014-05-24 12:52:07 +00005009void AArch64TargetInfo::getGCCRegNames(const char *const *&Names,
Tim Northovera2ee4332014-03-29 15:09:45 +00005010 unsigned &NumNames) const {
5011 Names = GCCRegNames;
5012 NumNames = llvm::array_lengthof(GCCRegNames);
5013}
5014
Tim Northover573cbee2014-05-24 12:52:07 +00005015const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00005016 { { "w31" }, "wsp" },
5017 { { "x29" }, "fp" },
5018 { { "x30" }, "lr" },
5019 { { "x31" }, "sp" },
5020 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
5021 // don't want to substitute one of these for a different-sized one.
5022};
5023
Tim Northover573cbee2014-05-24 12:52:07 +00005024void AArch64TargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
Tim Northovera2ee4332014-03-29 15:09:45 +00005025 unsigned &NumAliases) const {
5026 Aliases = GCCRegAliases;
5027 NumAliases = llvm::array_lengthof(GCCRegAliases);
5028}
5029
Tim Northover573cbee2014-05-24 12:52:07 +00005030const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00005031#define BUILTIN(ID, TYPE, ATTRS) \
5032 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5033#include "clang/Basic/BuiltinsNEON.def"
5034
5035#define BUILTIN(ID, TYPE, ATTRS) \
5036 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
Tim Northover573cbee2014-05-24 12:52:07 +00005037#include "clang/Basic/BuiltinsAArch64.def"
Tim Northovera2ee4332014-03-29 15:09:45 +00005038};
James Molloy5e73df52014-04-16 15:06:20 +00005039
Tim Northover573cbee2014-05-24 12:52:07 +00005040class AArch64leTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00005041 void setDescriptionString() override {
5042 if (getTriple().isOSBinFormatMachO())
5043 DescriptionString = "e-m:o-i64:64-i128:128-n32:64-S128";
5044 else
5045 DescriptionString = "e-m:e-i64:64-i128:128-n32:64-S128";
5046 }
5047
5048public:
Tim Northover573cbee2014-05-24 12:52:07 +00005049 AArch64leTargetInfo(const llvm::Triple &Triple)
5050 : AArch64TargetInfo(Triple) {
James Molloy5e73df52014-04-16 15:06:20 +00005051 BigEndian = false;
5052 }
5053 void getTargetDefines(const LangOptions &Opts,
5054 MacroBuilder &Builder) const override {
5055 Builder.defineMacro("__AARCH64EL__");
Tim Northover573cbee2014-05-24 12:52:07 +00005056 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00005057 }
5058};
5059
Tim Northover573cbee2014-05-24 12:52:07 +00005060class AArch64beTargetInfo : public AArch64TargetInfo {
James Molloy5e73df52014-04-16 15:06:20 +00005061 void setDescriptionString() override {
5062 assert(!getTriple().isOSBinFormatMachO());
5063 DescriptionString = "E-m:e-i64:64-i128:128-n32:64-S128";
5064 }
5065
5066public:
Tim Northover573cbee2014-05-24 12:52:07 +00005067 AArch64beTargetInfo(const llvm::Triple &Triple)
5068 : AArch64TargetInfo(Triple) { }
James Molloy5e73df52014-04-16 15:06:20 +00005069 void getTargetDefines(const LangOptions &Opts,
5070 MacroBuilder &Builder) const override {
5071 Builder.defineMacro("__AARCH64EB__");
5072 Builder.defineMacro("__AARCH_BIG_ENDIAN");
5073 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northover573cbee2014-05-24 12:52:07 +00005074 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00005075 }
5076};
Tim Northovera2ee4332014-03-29 15:09:45 +00005077} // end anonymous namespace.
5078
5079namespace {
Tim Northover573cbee2014-05-24 12:52:07 +00005080class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
James Molloy5e73df52014-04-16 15:06:20 +00005081protected:
5082 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
5083 MacroBuilder &Builder) const override {
5084 Builder.defineMacro("__AARCH64_SIMD__");
5085 Builder.defineMacro("__ARM64_ARCH_8__");
5086 Builder.defineMacro("__ARM_NEON__");
5087 Builder.defineMacro("__LITTLE_ENDIAN__");
5088 Builder.defineMacro("__REGISTER_PREFIX__", "");
5089 Builder.defineMacro("__arm64", "1");
5090 Builder.defineMacro("__arm64__", "1");
5091
5092 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
5093 }
5094
Tim Northovera2ee4332014-03-29 15:09:45 +00005095public:
Tim Northover573cbee2014-05-24 12:52:07 +00005096 DarwinAArch64TargetInfo(const llvm::Triple &Triple)
5097 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
Tim Northovera2ee4332014-03-29 15:09:45 +00005098 Int64Type = SignedLongLong;
5099 WCharType = SignedInt;
5100 UseSignedCharForObjCBool = false;
5101
Tim Northovera6a19f12015-02-06 01:25:07 +00005102 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00005103 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5104
5105 TheCXXABI.set(TargetCXXABI::iOS64);
5106 }
5107
David Blaikie1cbb9712014-11-14 19:09:44 +00005108 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005109 return TargetInfo::CharPtrBuiltinVaList;
5110 }
5111};
5112} // end anonymous namespace
5113
5114namespace {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005115// Hexagon abstract base class
5116class HexagonTargetInfo : public TargetInfo {
5117 static const Builtin::Info BuiltinInfo[];
5118 static const char * const GCCRegNames[];
5119 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5120 std::string CPU;
5121public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005122 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005123 BigEndian = false;
Rafael Espindolac418ae92014-01-03 19:22:05 +00005124 DescriptionString = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32";
Tony Linthicum76329bf2011-12-12 21:14:55 +00005125
5126 // {} in inline assembly are packet specifiers, not assembly variant
5127 // specifiers.
5128 NoAsmVariants = true;
5129 }
5130
Craig Topper3164f332014-03-11 03:39:26 +00005131 void getTargetBuiltins(const Builtin::Info *&Records,
5132 unsigned &NumRecords) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005133 Records = BuiltinInfo;
5134 NumRecords = clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin;
5135 }
5136
Craig Topper3164f332014-03-11 03:39:26 +00005137 bool validateAsmConstraint(const char *&Name,
5138 TargetInfo::ConstraintInfo &Info) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005139 return true;
5140 }
5141
Craig Topper3164f332014-03-11 03:39:26 +00005142 void getTargetDefines(const LangOptions &Opts,
5143 MacroBuilder &Builder) const override;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005144
Craig Topper3164f332014-03-11 03:39:26 +00005145 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005146 return Feature == "hexagon";
5147 }
Craig Topper3164f332014-03-11 03:39:26 +00005148
5149 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005150 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005151 }
Craig Topper3164f332014-03-11 03:39:26 +00005152 void getGCCRegNames(const char * const *&Names,
5153 unsigned &NumNames) const override;
5154 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5155 unsigned &NumAliases) const override;
5156 const char *getClobbers() const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005157 return "";
5158 }
Sebastian Pop86500282012-01-13 20:37:10 +00005159
5160 static const char *getHexagonCPUSuffix(StringRef Name) {
5161 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop86500282012-01-13 20:37:10 +00005162 .Case("hexagonv4", "4")
Sirish Pande11ebc4e2012-05-10 20:19:54 +00005163 .Case("hexagonv5", "5")
Craig Topperf1186c52014-05-08 06:41:40 +00005164 .Default(nullptr);
Sebastian Pop86500282012-01-13 20:37:10 +00005165 }
5166
Craig Topper3164f332014-03-11 03:39:26 +00005167 bool setCPU(const std::string &Name) override {
Sebastian Pop86500282012-01-13 20:37:10 +00005168 if (!getHexagonCPUSuffix(Name))
5169 return false;
5170
Tony Linthicum76329bf2011-12-12 21:14:55 +00005171 CPU = Name;
5172 return true;
5173 }
5174};
5175
5176void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
5177 MacroBuilder &Builder) const {
5178 Builder.defineMacro("qdsp6");
5179 Builder.defineMacro("__qdsp6", "1");
5180 Builder.defineMacro("__qdsp6__", "1");
5181
5182 Builder.defineMacro("hexagon");
5183 Builder.defineMacro("__hexagon", "1");
5184 Builder.defineMacro("__hexagon__", "1");
5185
5186 if(CPU == "hexagonv1") {
5187 Builder.defineMacro("__HEXAGON_V1__");
5188 Builder.defineMacro("__HEXAGON_ARCH__", "1");
5189 if(Opts.HexagonQdsp6Compat) {
5190 Builder.defineMacro("__QDSP6_V1__");
5191 Builder.defineMacro("__QDSP6_ARCH__", "1");
5192 }
5193 }
5194 else if(CPU == "hexagonv2") {
5195 Builder.defineMacro("__HEXAGON_V2__");
5196 Builder.defineMacro("__HEXAGON_ARCH__", "2");
5197 if(Opts.HexagonQdsp6Compat) {
5198 Builder.defineMacro("__QDSP6_V2__");
5199 Builder.defineMacro("__QDSP6_ARCH__", "2");
5200 }
5201 }
5202 else if(CPU == "hexagonv3") {
5203 Builder.defineMacro("__HEXAGON_V3__");
5204 Builder.defineMacro("__HEXAGON_ARCH__", "3");
5205 if(Opts.HexagonQdsp6Compat) {
5206 Builder.defineMacro("__QDSP6_V3__");
5207 Builder.defineMacro("__QDSP6_ARCH__", "3");
5208 }
5209 }
5210 else if(CPU == "hexagonv4") {
5211 Builder.defineMacro("__HEXAGON_V4__");
5212 Builder.defineMacro("__HEXAGON_ARCH__", "4");
5213 if(Opts.HexagonQdsp6Compat) {
5214 Builder.defineMacro("__QDSP6_V4__");
5215 Builder.defineMacro("__QDSP6_ARCH__", "4");
5216 }
5217 }
Sirish Pande11ebc4e2012-05-10 20:19:54 +00005218 else if(CPU == "hexagonv5") {
5219 Builder.defineMacro("__HEXAGON_V5__");
5220 Builder.defineMacro("__HEXAGON_ARCH__", "5");
5221 if(Opts.HexagonQdsp6Compat) {
5222 Builder.defineMacro("__QDSP6_V5__");
5223 Builder.defineMacro("__QDSP6_ARCH__", "5");
5224 }
5225 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005226}
5227
5228const char * const HexagonTargetInfo::GCCRegNames[] = {
5229 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5230 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5231 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5232 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
5233 "p0", "p1", "p2", "p3",
5234 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
5235};
5236
5237void HexagonTargetInfo::getGCCRegNames(const char * const *&Names,
5238 unsigned &NumNames) const {
5239 Names = GCCRegNames;
5240 NumNames = llvm::array_lengthof(GCCRegNames);
5241}
5242
5243
5244const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
5245 { { "sp" }, "r29" },
5246 { { "fp" }, "r30" },
5247 { { "lr" }, "r31" },
5248 };
5249
5250void HexagonTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5251 unsigned &NumAliases) const {
5252 Aliases = GCCRegAliases;
5253 NumAliases = llvm::array_lengthof(GCCRegAliases);
5254}
5255
5256
5257const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
5258#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
5259#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
5260 ALL_LANGUAGES },
5261#include "clang/Basic/BuiltinsHexagon.def"
5262};
5263}
5264
5265
Chris Lattner5ba61f02006-10-14 07:39:34 +00005266namespace {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005267// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
5268class SparcTargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00005269 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5270 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005271 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00005272public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005273 SparcTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005274
Craig Topper3164f332014-03-11 03:39:26 +00005275 bool handleTargetFeatures(std::vector<std::string> &Features,
5276 DiagnosticsEngine &Diags) override {
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005277 SoftFloat = false;
5278 for (unsigned i = 0, e = Features.size(); i != e; ++i)
5279 if (Features[i] == "+soft-float")
5280 SoftFloat = true;
Rafael Espindolaeb265472013-08-21 21:59:03 +00005281 return true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005282 }
Craig Topper3164f332014-03-11 03:39:26 +00005283 void getTargetDefines(const LangOptions &Opts,
5284 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005285 DefineStd(Builder, "sparc", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005286 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005287
5288 if (SoftFloat)
5289 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00005290 }
Craig Topper3164f332014-03-11 03:39:26 +00005291
5292 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005293 return llvm::StringSwitch<bool>(Feature)
5294 .Case("softfloat", SoftFloat)
5295 .Case("sparc", true)
5296 .Default(false);
5297 }
Craig Topper3164f332014-03-11 03:39:26 +00005298
5299 void getTargetBuiltins(const Builtin::Info *&Records,
5300 unsigned &NumRecords) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005301 // FIXME: Implement!
Gabor Greif49991682008-02-21 16:29:08 +00005302 }
Craig Topper3164f332014-03-11 03:39:26 +00005303 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005304 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif49991682008-02-21 16:29:08 +00005305 }
Craig Topper3164f332014-03-11 03:39:26 +00005306 void getGCCRegNames(const char * const *&Names,
5307 unsigned &NumNames) const override;
5308 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5309 unsigned &NumAliases) const override;
5310 bool validateAsmConstraint(const char *&Name,
5311 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005312 // FIXME: Implement!
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00005313 switch (*Name) {
5314 case 'I': // Signed 13-bit constant
5315 case 'J': // Zero
5316 case 'K': // 32-bit constant with the low 12 bits clear
5317 case 'L': // A constant in the range supported by movcc (11-bit signed imm)
5318 case 'M': // A constant in the range supported by movrcc (19-bit signed imm)
5319 case 'N': // Same as 'K' but zext (required for SIMode)
5320 case 'O': // The constant 4096
5321 return true;
5322 }
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005323 return false;
Gabor Greif49991682008-02-21 16:29:08 +00005324 }
Craig Topper3164f332014-03-11 03:39:26 +00005325 const char *getClobbers() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005326 // FIXME: Implement!
5327 return "";
Gabor Greif49991682008-02-21 16:29:08 +00005328 }
5329};
5330
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005331const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattner9b415d62009-01-27 01:58:38 +00005332 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5333 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5334 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5335 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
5336};
5337
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005338void SparcTargetInfo::getGCCRegNames(const char * const *&Names,
5339 unsigned &NumNames) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005340 Names = GCCRegNames;
5341 NumNames = llvm::array_lengthof(GCCRegNames);
5342}
5343
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005344const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00005345 { { "g0" }, "r0" },
5346 { { "g1" }, "r1" },
5347 { { "g2" }, "r2" },
5348 { { "g3" }, "r3" },
5349 { { "g4" }, "r4" },
5350 { { "g5" }, "r5" },
5351 { { "g6" }, "r6" },
5352 { { "g7" }, "r7" },
5353 { { "o0" }, "r8" },
5354 { { "o1" }, "r9" },
5355 { { "o2" }, "r10" },
5356 { { "o3" }, "r11" },
5357 { { "o4" }, "r12" },
5358 { { "o5" }, "r13" },
5359 { { "o6", "sp" }, "r14" },
5360 { { "o7" }, "r15" },
5361 { { "l0" }, "r16" },
5362 { { "l1" }, "r17" },
5363 { { "l2" }, "r18" },
5364 { { "l3" }, "r19" },
5365 { { "l4" }, "r20" },
5366 { { "l5" }, "r21" },
5367 { { "l6" }, "r22" },
5368 { { "l7" }, "r23" },
5369 { { "i0" }, "r24" },
5370 { { "i1" }, "r25" },
5371 { { "i2" }, "r26" },
5372 { { "i3" }, "r27" },
5373 { { "i4" }, "r28" },
5374 { { "i5" }, "r29" },
5375 { { "i6", "fp" }, "r30" },
5376 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00005377};
5378
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005379void SparcTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
5380 unsigned &NumAliases) const {
Chris Lattner9b415d62009-01-27 01:58:38 +00005381 Aliases = GCCRegAliases;
5382 NumAliases = llvm::array_lengthof(GCCRegAliases);
5383}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005384
5385// SPARC v8 is the 32-bit mode selected by Triple::sparc.
5386class SparcV8TargetInfo : public SparcTargetInfo {
5387public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005388 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005389 DescriptionString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64";
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005390 }
5391
Craig Topper3164f332014-03-11 03:39:26 +00005392 void getTargetDefines(const LangOptions &Opts,
5393 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005394 SparcTargetInfo::getTargetDefines(Opts, Builder);
5395 Builder.defineMacro("__sparcv8");
5396 }
5397};
5398
5399// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
5400class SparcV9TargetInfo : public SparcTargetInfo {
5401public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005402 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005403 // FIXME: Support Sparc quad-precision long double?
Rafael Espindolac418ae92014-01-03 19:22:05 +00005404 DescriptionString = "E-m:e-i64:64-n32:64-S128";
Jakob Stoklund Olesen248520b2013-05-15 03:22:33 +00005405 // This is an LP64 platform.
5406 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005407
5408 // OpenBSD uses long long for int64_t and intmax_t.
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005409 if (getTriple().getOS() == llvm::Triple::OpenBSD)
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005410 IntMaxType = SignedLongLong;
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00005411 else
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005412 IntMaxType = SignedLong;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00005413 Int64Type = IntMaxType;
Jakob Stoklund Olesen497332c2014-01-16 16:43:19 +00005414
5415 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
5416 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
5417 LongDoubleWidth = 128;
5418 LongDoubleAlign = 128;
5419 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Jakob Stoklund Olesen5b630b42014-01-30 04:48:04 +00005420 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005421 }
5422
Craig Topper3164f332014-03-11 03:39:26 +00005423 void getTargetDefines(const LangOptions &Opts,
5424 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005425 SparcTargetInfo::getTargetDefines(Opts, Builder);
5426 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005427 Builder.defineMacro("__arch64__");
Rafael Espindola76483742014-08-14 15:14:51 +00005428 // Solaris doesn't need these variants, but the BSDs do.
5429 if (getTriple().getOS() != llvm::Triple::Solaris) {
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00005430 Builder.defineMacro("__sparc64__");
5431 Builder.defineMacro("__sparc_v9__");
5432 Builder.defineMacro("__sparcv9__");
5433 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005434 }
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005435
Craig Topper3164f332014-03-11 03:39:26 +00005436 bool setCPU(const std::string &Name) override {
Roman Divackyb1ae3d42014-02-25 18:35:30 +00005437 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5438 .Case("v9", true)
5439 .Case("ultrasparc", true)
5440 .Case("ultrasparc3", true)
5441 .Case("niagara", true)
5442 .Case("niagara2", true)
5443 .Case("niagara3", true)
5444 .Case("niagara4", true)
5445 .Default(false);
5446
5447 // No need to store the CPU yet. There aren't any CPU-specific
5448 // macros to define.
5449 return CPUKnown;
5450 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005451};
5452
Gabor Greif49991682008-02-21 16:29:08 +00005453} // end anonymous namespace.
5454
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005455namespace {
Torok Edwinb2b37c62009-06-30 17:10:35 +00005456class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005457public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005458 SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
5459 : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
Eli Friedmand50881c2008-11-02 02:43:55 +00005460 SizeType = UnsignedInt;
5461 PtrDiffType = SignedInt;
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005462 }
5463};
5464} // end anonymous namespace.
Chris Lattner5ba61f02006-10-14 07:39:34 +00005465
Chris Lattnerb781dc792008-05-08 05:58:21 +00005466namespace {
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005467class SystemZTargetInfo : public TargetInfo {
5468 static const char *const GCCRegNames[];
Ulrich Weigand47445072013-05-06 16:26:41 +00005469
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005470public:
5471 SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
5472 TLSSupported = true;
5473 IntWidth = IntAlign = 32;
5474 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
5475 PointerWidth = PointerAlign = 64;
5476 LongDoubleWidth = 128;
5477 LongDoubleAlign = 64;
5478 LongDoubleFormat = &llvm::APFloat::IEEEquad;
5479 MinGlobalAlign = 16;
5480 DescriptionString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
5481 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
5482 }
5483 void getTargetDefines(const LangOptions &Opts,
5484 MacroBuilder &Builder) const override {
5485 Builder.defineMacro("__s390__");
5486 Builder.defineMacro("__s390x__");
5487 Builder.defineMacro("__zarch__");
5488 Builder.defineMacro("__LONG_DOUBLE_128__");
5489 }
5490 void getTargetBuiltins(const Builtin::Info *&Records,
5491 unsigned &NumRecords) const override {
5492 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005493 Records = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005494 NumRecords = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005495 }
5496
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005497 void getGCCRegNames(const char *const *&Names,
5498 unsigned &NumNames) const override;
5499 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5500 unsigned &NumAliases) const override {
5501 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005502 Aliases = nullptr;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005503 NumAliases = 0;
Ulrich Weigand47445072013-05-06 16:26:41 +00005504 }
Richard Sandifordd03f7b72014-04-10 09:56:24 +00005505 bool validateAsmConstraint(const char *&Name,
5506 TargetInfo::ConstraintInfo &info) const override;
5507 const char *getClobbers() const override {
5508 // FIXME: Is this really right?
5509 return "";
5510 }
5511 BuiltinVaListKind getBuiltinVaListKind() const override {
5512 return TargetInfo::SystemZBuiltinVaList;
5513 }
5514 bool setCPU(const std::string &Name) override {
5515 bool CPUKnown = llvm::StringSwitch<bool>(Name)
5516 .Case("z10", true)
5517 .Case("z196", true)
5518 .Case("zEC12", true)
5519 .Default(false);
5520
5521 // No need to store the CPU yet. There aren't any CPU-specific
5522 // macros to define.
5523 return CPUKnown;
5524 }
5525};
5526
5527const char *const SystemZTargetInfo::GCCRegNames[] = {
5528 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5529 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5530 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
5531 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
5532};
5533
5534void SystemZTargetInfo::getGCCRegNames(const char *const *&Names,
5535 unsigned &NumNames) const {
5536 Names = GCCRegNames;
5537 NumNames = llvm::array_lengthof(GCCRegNames);
5538}
5539
5540bool SystemZTargetInfo::
5541validateAsmConstraint(const char *&Name,
5542 TargetInfo::ConstraintInfo &Info) const {
5543 switch (*Name) {
5544 default:
5545 return false;
5546
5547 case 'a': // Address register
5548 case 'd': // Data register (equivalent to 'r')
5549 case 'f': // Floating-point register
5550 Info.setAllowsRegister();
5551 return true;
5552
5553 case 'I': // Unsigned 8-bit constant
5554 case 'J': // Unsigned 12-bit constant
5555 case 'K': // Signed 16-bit constant
5556 case 'L': // Signed 20-bit displacement (on all targets we support)
5557 case 'M': // 0x7fffffff
5558 return true;
5559
5560 case 'Q': // Memory with base and unsigned 12-bit displacement
5561 case 'R': // Likewise, plus an index
5562 case 'S': // Memory with base and signed 20-bit displacement
5563 case 'T': // Likewise, plus an index
5564 Info.setAllowsMemory();
5565 return true;
5566 }
5567}
Ulrich Weigand47445072013-05-06 16:26:41 +00005568}
5569
5570namespace {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005571 class MSP430TargetInfo : public TargetInfo {
5572 static const char * const GCCRegNames[];
5573 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005574 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005575 BigEndian = false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005576 TLSSupported = false;
Anton Korobeynikovcbc4e982010-01-30 12:55:11 +00005577 IntWidth = 16; IntAlign = 16;
5578 LongWidth = 32; LongLongWidth = 64;
5579 LongAlign = LongLongAlign = 16;
5580 PointerWidth = 16; PointerAlign = 16;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005581 SuitableAlign = 16;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005582 SizeType = UnsignedInt;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005583 IntMaxType = SignedLongLong;
Anton Korobeynikovef412902013-07-01 19:42:40 +00005584 IntPtrType = SignedInt;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005585 PtrDiffType = SignedInt;
Edward O'Callaghan847f2a12009-11-21 00:49:54 +00005586 SigAtomicType = SignedLong;
Job Noormanac95cd52014-09-30 11:19:13 +00005587 DescriptionString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16";
Craig Topper3164f332014-03-11 03:39:26 +00005588 }
5589 void getTargetDefines(const LangOptions &Opts,
5590 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005591 Builder.defineMacro("MSP430");
5592 Builder.defineMacro("__MSP430__");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005593 // FIXME: defines for different 'flavours' of MCU
5594 }
Craig Topper3164f332014-03-11 03:39:26 +00005595 void getTargetBuiltins(const Builtin::Info *&Records,
5596 unsigned &NumRecords) const override {
5597 // FIXME: Implement.
Craig Topperf1186c52014-05-08 06:41:40 +00005598 Records = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005599 NumRecords = 0;
5600 }
Craig Topper3164f332014-03-11 03:39:26 +00005601 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005602 return Feature == "msp430";
5603 }
Craig Topper3164f332014-03-11 03:39:26 +00005604 void getGCCRegNames(const char * const *&Names,
5605 unsigned &NumNames) const override;
5606 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5607 unsigned &NumAliases) const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005608 // No aliases.
Craig Topperf1186c52014-05-08 06:41:40 +00005609 Aliases = nullptr;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005610 NumAliases = 0;
5611 }
Eric Christopher917e9522014-11-18 22:36:15 +00005612 bool
5613 validateAsmConstraint(const char *&Name,
5614 TargetInfo::ConstraintInfo &info) const override {
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00005615 // FIXME: implement
5616 switch (*Name) {
5617 case 'K': // the constant 1
5618 case 'L': // constant -1^20 .. 1^19
5619 case 'M': // constant 1-4:
5620 return true;
5621 }
Anton Korobeynikov051913b2009-10-15 23:17:13 +00005622 // No target constraints for now.
5623 return false;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005624 }
Craig Topper3164f332014-03-11 03:39:26 +00005625 const char *getClobbers() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005626 // FIXME: Is this really right?
5627 return "";
5628 }
Craig Topper3164f332014-03-11 03:39:26 +00005629 BuiltinVaListKind getBuiltinVaListKind() const override {
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005630 // FIXME: implement
Meador Inge5d3fb222012-06-16 03:34:49 +00005631 return TargetInfo::CharPtrBuiltinVaList;
Anton Korobeynikova0f54372009-05-03 13:43:08 +00005632 }
5633 };
5634
5635 const char * const MSP430TargetInfo::GCCRegNames[] = {
5636 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5637 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
5638 };
5639
5640 void MSP430TargetInfo::getGCCRegNames(const char * const *&Names,
5641 unsigned &NumNames) const {
5642 Names = GCCRegNames;
5643 NumNames = llvm::array_lengthof(GCCRegNames);
5644 }
5645}
5646
Jakob Stoklund Olesen0de52f92009-08-17 20:08:44 +00005647namespace {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005648
Mike Stump11289f42009-09-09 15:08:12 +00005649 // LLVM and Clang cannot be used directly to output native binaries for
5650 // target, but is used to compile C code to llvm bitcode with correct
Eli Friedmana9c3d712009-08-19 20:47:07 +00005651 // type and alignment information.
Mike Stump11289f42009-09-09 15:08:12 +00005652 //
5653 // TCE uses the llvm bitcode as input and uses it for generating customized
5654 // target processor and program binary. TCE co-design environment is
Eli Friedmana9c3d712009-08-19 20:47:07 +00005655 // publicly available in http://tce.cs.tut.fi
5656
Eli Friedman1f191002011-10-07 19:51:42 +00005657 static const unsigned TCEOpenCLAddrSpaceMap[] = {
5658 3, // opencl_global
5659 4, // opencl_local
Peter Collingbournef44bdf92012-05-20 21:08:35 +00005660 5, // opencl_constant
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +00005661 // FIXME: generic has to be added to the target
5662 0, // opencl_generic
Peter Collingbournef44bdf92012-05-20 21:08:35 +00005663 0, // cuda_device
5664 0, // cuda_constant
5665 0 // cuda_shared
Eli Friedman1f191002011-10-07 19:51:42 +00005666 };
5667
Eli Friedmana9c3d712009-08-19 20:47:07 +00005668 class TCETargetInfo : public TargetInfo{
5669 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005670 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedmana9c3d712009-08-19 20:47:07 +00005671 TLSSupported = false;
5672 IntWidth = 32;
5673 LongWidth = LongLongWidth = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005674 PointerWidth = 32;
5675 IntAlign = 32;
5676 LongAlign = LongLongAlign = 32;
5677 PointerAlign = 32;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00005678 SuitableAlign = 32;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005679 SizeType = UnsignedInt;
5680 IntMaxType = SignedLong;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005681 IntPtrType = SignedInt;
5682 PtrDiffType = SignedInt;
5683 FloatWidth = 32;
5684 FloatAlign = 32;
5685 DoubleWidth = 32;
5686 DoubleAlign = 32;
5687 LongDoubleWidth = 32;
5688 LongDoubleAlign = 32;
5689 FloatFormat = &llvm::APFloat::IEEEsingle;
5690 DoubleFormat = &llvm::APFloat::IEEEsingle;
5691 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
Rafael Espindola29db13a2014-01-03 18:13:17 +00005692 DescriptionString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
5693 "-f64:32-v64:32-v128:32-a:0:32-n32";
Eli Friedman1f191002011-10-07 19:51:42 +00005694 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00005695 UseAddrSpaceMapMangling = true;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005696 }
5697
Craig Topper3164f332014-03-11 03:39:26 +00005698 void getTargetDefines(const LangOptions &Opts,
5699 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005700 DefineStd(Builder, "tce", Opts);
5701 Builder.defineMacro("__TCE__");
5702 Builder.defineMacro("__TCE_V1__");
Eli Friedmana9c3d712009-08-19 20:47:07 +00005703 }
Craig Topper3164f332014-03-11 03:39:26 +00005704 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005705 return Feature == "tce";
5706 }
Craig Topper3164f332014-03-11 03:39:26 +00005707
5708 void getTargetBuiltins(const Builtin::Info *&Records,
5709 unsigned &NumRecords) const override {}
5710 const char *getClobbers() const override {
Daniel Dunbar576d90d2009-08-24 09:54:37 +00005711 return "";
5712 }
Craig Topper3164f332014-03-11 03:39:26 +00005713 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005714 return TargetInfo::VoidPtrBuiltinVaList;
Eli Friedmana9c3d712009-08-19 20:47:07 +00005715 }
Craig Topper3164f332014-03-11 03:39:26 +00005716 void getGCCRegNames(const char * const *&Names,
5717 unsigned &NumNames) const override {}
5718 bool validateAsmConstraint(const char *&Name,
5719 TargetInfo::ConstraintInfo &info) const override{
Eli Friedmana9c3d712009-08-19 20:47:07 +00005720 return true;
5721 }
Craig Topper3164f332014-03-11 03:39:26 +00005722 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5723 unsigned &NumAliases) const override {}
Eli Friedmana9c3d712009-08-19 20:47:07 +00005724 };
5725}
5726
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005727namespace {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005728class MipsTargetInfoBase : public TargetInfo {
Akira Hatanaka9064e362013-10-29 18:30:33 +00005729 virtual void setDescriptionString() = 0;
5730
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005731 static const Builtin::Info BuiltinInfo[];
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005732 std::string CPU;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005733 bool IsMips16;
Simon Atanasyan60777612013-04-14 14:07:51 +00005734 bool IsMicromips;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005735 bool IsNan2008;
Simon Atanasyan16071912013-04-14 14:07:30 +00005736 bool IsSingleFloat;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005737 enum MipsFloatABI {
Simon Atanasyan16071912013-04-14 14:07:30 +00005738 HardFloat, SoftFloat
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005739 } FloatABI;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005740 enum DspRevEnum {
5741 NoDSP, DSP1, DSP2
5742 } DspRev;
Jack Carter44ff1e52013-08-12 17:20:29 +00005743 bool HasMSA;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005744
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005745protected:
Akira Hatanaka618b2982013-10-29 19:00:35 +00005746 bool HasFP64;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005747 std::string ABI;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005748
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005749public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005750 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
5751 const std::string &CPUStr)
5752 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005753 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
Zoran Jovanovic26a12162015-02-18 15:21:35 +00005754 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {
5755 TheCXXABI.set(TargetCXXABI::GenericMIPS);
5756 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005757
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005758 bool isNaN2008Default() const {
5759 return CPU == "mips32r6" || CPU == "mips64r6";
5760 }
5761
5762 bool isFP64Default() const {
5763 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
5764 }
5765
Petar Jovanovicd55ae6b2015-02-26 18:19:22 +00005766 bool isNan2008() const override {
5767 return IsNan2008;
5768 }
5769
Alp Toker4925ba72014-06-07 23:30:42 +00005770 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00005771 bool setCPU(const std::string &Name) override {
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005772 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
5773 getTriple().getArch() == llvm::Triple::mipsel;
Eric Christopher0b26a612010-03-02 02:41:08 +00005774 CPU = Name;
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005775 return llvm::StringSwitch<bool>(Name)
Simon Atanasyan26610c52014-07-04 12:36:56 +00005776 .Case("mips1", IsMips32)
5777 .Case("mips2", IsMips32)
5778 .Case("mips3", true)
5779 .Case("mips4", true)
5780 .Case("mips5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005781 .Case("mips32", IsMips32)
5782 .Case("mips32r2", IsMips32)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005783 .Case("mips32r3", IsMips32)
5784 .Case("mips32r5", IsMips32)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005785 .Case("mips32r6", IsMips32)
5786 .Case("mips64", true)
5787 .Case("mips64r2", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00005788 .Case("mips64r3", true)
5789 .Case("mips64r5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005790 .Case("mips64r6", true)
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005791 .Case("octeon", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00005792 .Default(false);
Eric Christopher0b26a612010-03-02 02:41:08 +00005793 }
Matheus Almeidab84b37d2014-06-05 14:59:18 +00005794 const std::string& getCPU() const { return CPU; }
Craig Topper3164f332014-03-11 03:39:26 +00005795 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Simon Atanasyan4e16a422014-07-04 12:37:04 +00005796 if (CPU == "octeon")
5797 Features["mips64r2"] = Features["cnmips"] = true;
5798 else
5799 Features[CPU] = true;
Eric Christopher0b26a612010-03-02 02:41:08 +00005800 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005801
Craig Topper3164f332014-03-11 03:39:26 +00005802 void getTargetDefines(const LangOptions &Opts,
5803 MacroBuilder &Builder) const override {
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005804 Builder.defineMacro("__mips__");
Simon Atanasyan683535b2012-08-29 19:14:58 +00005805 Builder.defineMacro("_mips");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00005806 if (Opts.GNUMode)
5807 Builder.defineMacro("mips");
5808
Simon Atanasyan683535b2012-08-29 19:14:58 +00005809 Builder.defineMacro("__REGISTER_PREFIX__", "");
5810
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005811 switch (FloatABI) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005812 case HardFloat:
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005813 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005814 break;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005815 case SoftFloat:
5816 Builder.defineMacro("__mips_soft_float", Twine(1));
5817 break;
Simon Atanasyand3d173d2012-06-05 13:06:56 +00005818 }
Simon Atanasyan26f19672012-04-05 19:28:31 +00005819
Simon Atanasyan16071912013-04-14 14:07:30 +00005820 if (IsSingleFloat)
5821 Builder.defineMacro("__mips_single_float", Twine(1));
5822
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005823 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
5824 Builder.defineMacro("_MIPS_FPSET",
5825 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
5826
Simon Atanasyan72244b62012-07-05 16:06:06 +00005827 if (IsMips16)
5828 Builder.defineMacro("__mips16", Twine(1));
5829
Simon Atanasyan60777612013-04-14 14:07:51 +00005830 if (IsMicromips)
5831 Builder.defineMacro("__mips_micromips", Twine(1));
5832
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005833 if (IsNan2008)
5834 Builder.defineMacro("__mips_nan2008", Twine(1));
5835
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005836 switch (DspRev) {
5837 default:
5838 break;
5839 case DSP1:
5840 Builder.defineMacro("__mips_dsp_rev", Twine(1));
5841 Builder.defineMacro("__mips_dsp", Twine(1));
5842 break;
5843 case DSP2:
5844 Builder.defineMacro("__mips_dsp_rev", Twine(2));
5845 Builder.defineMacro("__mips_dspr2", Twine(1));
5846 Builder.defineMacro("__mips_dsp", Twine(1));
5847 break;
5848 }
5849
Jack Carter44ff1e52013-08-12 17:20:29 +00005850 if (HasMSA)
5851 Builder.defineMacro("__mips_msa", Twine(1));
5852
Simon Atanasyan26f19672012-04-05 19:28:31 +00005853 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
5854 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
5855 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan5a0642f2012-08-29 15:17:29 +00005856
5857 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
5858 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005859 }
5860
Craig Topper3164f332014-03-11 03:39:26 +00005861 void getTargetBuiltins(const Builtin::Info *&Records,
5862 unsigned &NumRecords) const override {
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00005863 Records = BuiltinInfo;
5864 NumRecords = clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005865 }
Craig Topper3164f332014-03-11 03:39:26 +00005866 bool hasFeature(StringRef Feature) const override {
Akira Hatanaka618b2982013-10-29 19:00:35 +00005867 return llvm::StringSwitch<bool>(Feature)
5868 .Case("mips", true)
5869 .Case("fp64", HasFP64)
5870 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005871 }
Craig Topper3164f332014-03-11 03:39:26 +00005872 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005873 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005874 }
Craig Topper3164f332014-03-11 03:39:26 +00005875 void getGCCRegNames(const char * const *&Names,
5876 unsigned &NumNames) const override {
Daniel Sanders8b59af12013-11-12 12:56:01 +00005877 static const char *const GCCRegNames[] = {
Eric Christopher8b6d0512012-03-27 19:56:11 +00005878 // CPU register names
5879 // Must match second column of GCCRegAliases
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005880 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
5881 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
5882 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005883 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
5884 // Floating point register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005885 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
5886 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
5887 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
5888 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopher8b6d0512012-03-27 19:56:11 +00005889 // Hi/lo and condition register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005890 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
Daniel Sanders8b59af12013-11-12 12:56:01 +00005891 "$fcc5","$fcc6","$fcc7",
5892 // MSA register names
5893 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7",
5894 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
5895 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
5896 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
5897 // MSA control register names
5898 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
5899 "$msarequest", "$msamap", "$msaunmap"
Akira Hatanakaf6da3312011-09-20 19:00:23 +00005900 };
5901 Names = GCCRegNames;
5902 NumNames = llvm::array_lengthof(GCCRegNames);
5903 }
Craig Topper3164f332014-03-11 03:39:26 +00005904 void getGCCRegAliases(const GCCRegAlias *&Aliases,
5905 unsigned &NumAliases) const override = 0;
5906 bool validateAsmConstraint(const char *&Name,
5907 TargetInfo::ConstraintInfo &Info) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005908 switch (*Name) {
5909 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00005910 return false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005911 case 'r': // CPU registers.
5912 case 'd': // Equivalent to "r" unless generating MIPS16 code.
Alp Toker958027b2014-07-14 19:42:55 +00005913 case 'y': // Equivalent to "r", backward compatibility only.
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005914 case 'f': // floating-point registers.
Eric Christopherb7e28cc2012-04-03 01:16:32 +00005915 case 'c': // $25 for indirect jumps
5916 case 'l': // lo register
5917 case 'x': // hilo register pair
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005918 Info.setAllowsRegister();
5919 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00005920 case 'I': // Signed 16-bit constant
5921 case 'J': // Integer 0
5922 case 'K': // Unsigned 16-bit constant
5923 case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui)
5924 case 'M': // Constants not loadable via lui, addiu, or ori
5925 case 'N': // Constant -1 to -65535
5926 case 'O': // A signed 15-bit constant
5927 case 'P': // A constant between 1 go 65535
5928 return true;
Jack Carterbeaccdd2013-03-05 19:10:54 +00005929 case 'R': // An address that can be used in a non-macro load or store
Jack Carter427b4042013-03-04 21:36:11 +00005930 Info.setAllowsMemory();
5931 return true;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005932 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005933 }
5934
Craig Topper3164f332014-03-11 03:39:26 +00005935 const char *getClobbers() const override {
Toma Tabacucfab40f2015-01-12 14:41:30 +00005936 // In GCC, $1 is not widely used in generated code (it's used only in a few
5937 // specific situations), so there is no real need for users to add it to
5938 // the clobbers list if they want to use it in their inline assembly code.
5939 //
5940 // In LLVM, $1 is treated as a normal GPR and is always allocatable during
5941 // code generation, so using it in inline assembly without adding it to the
5942 // clobbers list can cause conflicts between the inline assembly code and
5943 // the surrounding generated code.
5944 //
5945 // Another problem is that LLVM is allowed to choose $1 for inline assembly
5946 // operands, which will conflict with the ".set at" assembler option (which
5947 // we use only for inline assembly, in order to maintain compatibility with
5948 // GCC) and will also conflict with the user's usage of $1.
5949 //
5950 // The easiest way to avoid these conflicts and keep $1 as an allocatable
5951 // register for generated code is to automatically clobber $1 for all inline
5952 // assembly code.
5953 //
5954 // FIXME: We should automatically clobber $1 only for inline assembly code
5955 // which actually uses it. This would allow LLVM to use $1 for inline
5956 // assembly operands if the user's assembly code doesn't use it.
Toma Tabacu99411952014-12-17 12:02:58 +00005957 return "~{$1}";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00005958 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005959
Craig Topper3164f332014-03-11 03:39:26 +00005960 bool handleTargetFeatures(std::vector<std::string> &Features,
5961 DiagnosticsEngine &Diags) override {
Simon Atanasyan72244b62012-07-05 16:06:06 +00005962 IsMips16 = false;
Simon Atanasyan60777612013-04-14 14:07:51 +00005963 IsMicromips = false;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005964 IsNan2008 = isNaN2008Default();
Simon Atanasyan16071912013-04-14 14:07:30 +00005965 IsSingleFloat = false;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005966 FloatABI = HardFloat;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005967 DspRev = NoDSP;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005968 HasFP64 = isFP64Default();
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005969
5970 for (std::vector<std::string>::iterator it = Features.begin(),
5971 ie = Features.end(); it != ie; ++it) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005972 if (*it == "+single-float")
Simon Atanasyan16071912013-04-14 14:07:30 +00005973 IsSingleFloat = true;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005974 else if (*it == "+soft-float")
5975 FloatABI = SoftFloat;
Simon Atanasyan72244b62012-07-05 16:06:06 +00005976 else if (*it == "+mips16")
5977 IsMips16 = true;
Simon Atanasyan60777612013-04-14 14:07:51 +00005978 else if (*it == "+micromips")
5979 IsMicromips = true;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00005980 else if (*it == "+dsp")
5981 DspRev = std::max(DspRev, DSP1);
5982 else if (*it == "+dspr2")
5983 DspRev = std::max(DspRev, DSP2);
Jack Carter44ff1e52013-08-12 17:20:29 +00005984 else if (*it == "+msa")
5985 HasMSA = true;
Simon Atanasyan2c97a812013-10-18 13:13:53 +00005986 else if (*it == "+fp64")
5987 HasFP64 = true;
5988 else if (*it == "-fp64")
5989 HasFP64 = false;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005990 else if (*it == "+nan2008")
5991 IsNan2008 = true;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00005992 else if (*it == "-nan2008")
5993 IsNan2008 = false;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00005994 }
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005995
Simon Atanasyan22127ce2013-09-24 09:09:16 +00005996 // Remove front-end specific options.
Simon Atanasyan9f444d52012-07-05 15:32:46 +00005997 std::vector<std::string>::iterator it =
5998 std::find(Features.begin(), Features.end(), "+soft-float");
5999 if (it != Features.end())
6000 Features.erase(it);
Rafael Espindolaeb265472013-08-21 21:59:03 +00006001
Akira Hatanaka9064e362013-10-29 18:30:33 +00006002 setDescriptionString();
6003
Rafael Espindolaeb265472013-08-21 21:59:03 +00006004 return true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006005 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00006006
Craig Topper3164f332014-03-11 03:39:26 +00006007 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00006008 if (RegNo == 0) return 4;
6009 if (RegNo == 1) return 5;
6010 return -1;
6011 }
Daniel Sanderscfbb71d2014-07-09 13:43:19 +00006012
6013 bool isCLZForZeroUndef() const override { return false; }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006014};
6015
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00006016const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
6017#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6018#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
6019 ALL_LANGUAGES },
6020#include "clang/Basic/BuiltinsMips.def"
6021};
6022
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006023class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006024public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006025 Mips32TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00006026 : MipsTargetInfoBase(Triple, "o32", "mips32r2") {
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00006027 SizeType = UnsignedInt;
6028 PtrDiffType = SignedInt;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006029 Int64Type = SignedLongLong;
6030 IntMaxType = Int64Type;
Akira Hatanakab2206e72013-01-18 21:58:11 +00006031 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00006032 }
Craig Topper3164f332014-03-11 03:39:26 +00006033 bool setABI(const std::string &Name) override {
Simon Atanasyan755d7f92014-06-28 15:56:03 +00006034 if (Name == "o32" || Name == "eabi") {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006035 ABI = Name;
6036 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006037 }
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006038 return false;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006039 }
Craig Topper3164f332014-03-11 03:39:26 +00006040 void getTargetDefines(const LangOptions &Opts,
6041 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006042 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006043
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006044 Builder.defineMacro("__mips", "32");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00006045 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
6046
6047 const std::string& CPUStr = getCPU();
6048 if (CPUStr == "mips32")
6049 Builder.defineMacro("__mips_isa_rev", "1");
6050 else if (CPUStr == "mips32r2")
6051 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan162feb52015-02-20 23:37:40 +00006052 else if (CPUStr == "mips32r3")
6053 Builder.defineMacro("__mips_isa_rev", "3");
6054 else if (CPUStr == "mips32r5")
6055 Builder.defineMacro("__mips_isa_rev", "5");
Simon Atanasyane6694eb2015-01-15 07:04:48 +00006056 else if (CPUStr == "mips32r6")
6057 Builder.defineMacro("__mips_isa_rev", "6");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006058
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006059 if (ABI == "o32") {
6060 Builder.defineMacro("__mips_o32");
6061 Builder.defineMacro("_ABIO32", "1");
6062 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
6063 }
6064 else if (ABI == "eabi")
6065 Builder.defineMacro("__mips_eabi");
6066 else
David Blaikie83d382b2011-09-23 05:06:16 +00006067 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006068 }
Craig Topper3164f332014-03-11 03:39:26 +00006069 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6070 unsigned &NumAliases) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006071 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
6072 { { "at" }, "$1" },
6073 { { "v0" }, "$2" },
6074 { { "v1" }, "$3" },
6075 { { "a0" }, "$4" },
6076 { { "a1" }, "$5" },
6077 { { "a2" }, "$6" },
6078 { { "a3" }, "$7" },
6079 { { "t0" }, "$8" },
6080 { { "t1" }, "$9" },
6081 { { "t2" }, "$10" },
6082 { { "t3" }, "$11" },
6083 { { "t4" }, "$12" },
6084 { { "t5" }, "$13" },
6085 { { "t6" }, "$14" },
6086 { { "t7" }, "$15" },
6087 { { "s0" }, "$16" },
6088 { { "s1" }, "$17" },
6089 { { "s2" }, "$18" },
6090 { { "s3" }, "$19" },
6091 { { "s4" }, "$20" },
6092 { { "s5" }, "$21" },
6093 { { "s6" }, "$22" },
6094 { { "s7" }, "$23" },
6095 { { "t8" }, "$24" },
6096 { { "t9" }, "$25" },
6097 { { "k0" }, "$26" },
6098 { { "k1" }, "$27" },
6099 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00006100 { { "sp","$sp" }, "$29" },
6101 { { "fp","$fp" }, "$30" },
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006102 { { "ra" }, "$31" }
6103 };
6104 Aliases = GCCRegAliases;
6105 NumAliases = llvm::array_lengthof(GCCRegAliases);
6106 }
6107};
6108
6109class Mips32EBTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00006110 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00006111 DescriptionString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00006112 }
6113
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006114public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006115 Mips32EBTargetInfo(const llvm::Triple &Triple)
6116 : Mips32TargetInfoBase(Triple) {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006117 }
Craig Topper3164f332014-03-11 03:39:26 +00006118 void getTargetDefines(const LangOptions &Opts,
6119 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006120 DefineStd(Builder, "MIPSEB", Opts);
6121 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006122 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006123 }
6124};
6125
6126class Mips32ELTargetInfo : public Mips32TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00006127 void setDescriptionString() override {
Rafael Espindolac418ae92014-01-03 19:22:05 +00006128 DescriptionString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00006129 }
6130
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006131public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006132 Mips32ELTargetInfo(const llvm::Triple &Triple)
6133 : Mips32TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00006134 BigEndian = false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006135 }
Craig Topper3164f332014-03-11 03:39:26 +00006136 void getTargetDefines(const LangOptions &Opts,
6137 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006138 DefineStd(Builder, "MIPSEL", Opts);
6139 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006140 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006141 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006142};
Akira Hatanakabef17452011-09-20 19:21:49 +00006143
6144class Mips64TargetInfoBase : public MipsTargetInfoBase {
Akira Hatanakabef17452011-09-20 19:21:49 +00006145public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006146 Mips64TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00006147 : MipsTargetInfoBase(Triple, "n64", "mips64r2") {
Akira Hatanakac12a2712011-10-22 00:07:27 +00006148 LongDoubleWidth = LongDoubleAlign = 128;
6149 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnalla87d8592012-12-08 09:06:08 +00006150 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
6151 LongDoubleWidth = LongDoubleAlign = 64;
6152 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
6153 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006154 setN64ABITypes();
Nick Lewyckyf59e1292011-12-16 22:34:14 +00006155 SuitableAlign = 128;
Akira Hatanakab2206e72013-01-18 21:58:11 +00006156 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac12a2712011-10-22 00:07:27 +00006157 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006158
6159 void setN64ABITypes() {
6160 LongWidth = LongAlign = 64;
6161 PointerWidth = PointerAlign = 64;
6162 SizeType = UnsignedLong;
6163 PtrDiffType = SignedLong;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006164 Int64Type = SignedLong;
6165 IntMaxType = Int64Type;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006166 }
6167
6168 void setN32ABITypes() {
6169 LongWidth = LongAlign = 32;
6170 PointerWidth = PointerAlign = 32;
6171 SizeType = UnsignedInt;
6172 PtrDiffType = SignedInt;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006173 Int64Type = SignedLongLong;
6174 IntMaxType = Int64Type;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006175 }
6176
Craig Topper3164f332014-03-11 03:39:26 +00006177 bool setABI(const std::string &Name) override {
Akira Hatanakac12a2712011-10-22 00:07:27 +00006178 if (Name == "n32") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00006179 setN32ABITypes();
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006180 ABI = Name;
6181 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006182 }
Simon Atanasyanad805952014-07-01 10:59:09 +00006183 if (Name == "n64") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00006184 setN64ABITypes();
Simon Atanasyanad805952014-07-01 10:59:09 +00006185 ABI = Name;
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006186 return true;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006187 }
6188 return false;
Akira Hatanakabef17452011-09-20 19:21:49 +00006189 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006190
Craig Topper3164f332014-03-11 03:39:26 +00006191 void getTargetDefines(const LangOptions &Opts,
6192 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006193 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006194
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006195 Builder.defineMacro("__mips", "64");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00006196 Builder.defineMacro("__mips64");
6197 Builder.defineMacro("__mips64__");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00006198 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
6199
6200 const std::string& CPUStr = getCPU();
6201 if (CPUStr == "mips64")
6202 Builder.defineMacro("__mips_isa_rev", "1");
6203 else if (CPUStr == "mips64r2")
6204 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan162feb52015-02-20 23:37:40 +00006205 else if (CPUStr == "mips64r3")
6206 Builder.defineMacro("__mips_isa_rev", "3");
6207 else if (CPUStr == "mips64r5")
6208 Builder.defineMacro("__mips_isa_rev", "5");
Simon Atanasyane6694eb2015-01-15 07:04:48 +00006209 else if (CPUStr == "mips64r6")
6210 Builder.defineMacro("__mips_isa_rev", "6");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00006211
Akira Hatanakabef17452011-09-20 19:21:49 +00006212 if (ABI == "n32") {
6213 Builder.defineMacro("__mips_n32");
6214 Builder.defineMacro("_ABIN32", "2");
6215 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
6216 }
6217 else if (ABI == "n64") {
6218 Builder.defineMacro("__mips_n64");
6219 Builder.defineMacro("_ABI64", "3");
6220 Builder.defineMacro("_MIPS_SIM", "_ABI64");
6221 }
6222 else
David Blaikie83d382b2011-09-23 05:06:16 +00006223 llvm_unreachable("Invalid ABI for Mips64.");
Akira Hatanakabef17452011-09-20 19:21:49 +00006224 }
Craig Topper3164f332014-03-11 03:39:26 +00006225 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6226 unsigned &NumAliases) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00006227 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
6228 { { "at" }, "$1" },
6229 { { "v0" }, "$2" },
6230 { { "v1" }, "$3" },
6231 { { "a0" }, "$4" },
6232 { { "a1" }, "$5" },
6233 { { "a2" }, "$6" },
6234 { { "a3" }, "$7" },
6235 { { "a4" }, "$8" },
6236 { { "a5" }, "$9" },
6237 { { "a6" }, "$10" },
6238 { { "a7" }, "$11" },
6239 { { "t0" }, "$12" },
6240 { { "t1" }, "$13" },
6241 { { "t2" }, "$14" },
6242 { { "t3" }, "$15" },
6243 { { "s0" }, "$16" },
6244 { { "s1" }, "$17" },
6245 { { "s2" }, "$18" },
6246 { { "s3" }, "$19" },
6247 { { "s4" }, "$20" },
6248 { { "s5" }, "$21" },
6249 { { "s6" }, "$22" },
6250 { { "s7" }, "$23" },
6251 { { "t8" }, "$24" },
6252 { { "t9" }, "$25" },
6253 { { "k0" }, "$26" },
6254 { { "k1" }, "$27" },
6255 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00006256 { { "sp","$sp" }, "$29" },
6257 { { "fp","$fp" }, "$30" },
Akira Hatanakabef17452011-09-20 19:21:49 +00006258 { { "ra" }, "$31" }
6259 };
6260 Aliases = GCCRegAliases;
6261 NumAliases = llvm::array_lengthof(GCCRegAliases);
6262 }
Daniel Sanders81ea6012014-04-24 16:05:26 +00006263
6264 bool hasInt128Type() const override { return true; }
Akira Hatanakabef17452011-09-20 19:21:49 +00006265};
6266
6267class Mips64EBTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00006268 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00006269 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00006270 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 +00006271 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00006272 DescriptionString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00006273
Akira Hatanakabef17452011-09-20 19:21:49 +00006274 }
Akira Hatanaka9064e362013-10-29 18:30:33 +00006275
Akira Hatanakabef17452011-09-20 19:21:49 +00006276public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006277 Mips64EBTargetInfo(const llvm::Triple &Triple)
Akira Hatanaka9064e362013-10-29 18:30:33 +00006278 : Mips64TargetInfoBase(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00006279 void getTargetDefines(const LangOptions &Opts,
6280 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00006281 DefineStd(Builder, "MIPSEB", Opts);
6282 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006283 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00006284 }
6285};
6286
6287class Mips64ELTargetInfo : public Mips64TargetInfoBase {
Craig Topper3164f332014-03-11 03:39:26 +00006288 void setDescriptionString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00006289 if (ABI == "n32")
Rafael Espindolac418ae92014-01-03 19:22:05 +00006290 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 +00006291 else
Rafael Espindolac418ae92014-01-03 19:22:05 +00006292 DescriptionString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanakabef17452011-09-20 19:21:49 +00006293 }
6294public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006295 Mips64ELTargetInfo(const llvm::Triple &Triple)
6296 : Mips64TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00006297 // Default ABI is n64.
6298 BigEndian = false;
Akira Hatanakabef17452011-09-20 19:21:49 +00006299 }
Craig Topper3164f332014-03-11 03:39:26 +00006300 void getTargetDefines(const LangOptions &Opts,
6301 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00006302 DefineStd(Builder, "MIPSEL", Opts);
6303 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006304 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00006305 }
6306};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006307} // end anonymous namespace.
6308
Ivan Krasindd7403e2011-08-24 20:22:22 +00006309namespace {
6310class PNaClTargetInfo : public TargetInfo {
6311public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006312 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00006313 BigEndian = false;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006314 this->UserLabelPrefix = "";
6315 this->LongAlign = 32;
6316 this->LongWidth = 32;
6317 this->PointerAlign = 32;
6318 this->PointerWidth = 32;
6319 this->IntMaxType = TargetInfo::SignedLongLong;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006320 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00006321 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00006322 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00006323 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00006324 this->SizeType = TargetInfo::UnsignedInt;
6325 this->PtrDiffType = TargetInfo::SignedInt;
6326 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +00006327 this->RegParmMax = 0; // Disallow regparm
Ivan Krasindd7403e2011-08-24 20:22:22 +00006328 }
6329
Craig Topper3164f332014-03-11 03:39:26 +00006330 void getDefaultFeatures(llvm::StringMap<bool> &Features) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006331 }
Craig Toppere6f17d02014-03-11 04:07:52 +00006332 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006333 Builder.defineMacro("__le32__");
6334 Builder.defineMacro("__pnacl__");
6335 }
Craig Topper3164f332014-03-11 03:39:26 +00006336 void getTargetDefines(const LangOptions &Opts,
6337 MacroBuilder &Builder) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006338 getArchDefines(Opts, Builder);
6339 }
Craig Topper3164f332014-03-11 03:39:26 +00006340 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00006341 return Feature == "pnacl";
6342 }
Craig Topper3164f332014-03-11 03:39:26 +00006343 void getTargetBuiltins(const Builtin::Info *&Records,
6344 unsigned &NumRecords) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006345 }
Craig Topper3164f332014-03-11 03:39:26 +00006346 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00006347 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006348 }
Craig Topper3164f332014-03-11 03:39:26 +00006349 void getGCCRegNames(const char * const *&Names,
6350 unsigned &NumNames) const override;
6351 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6352 unsigned &NumAliases) const override;
6353 bool validateAsmConstraint(const char *&Name,
6354 TargetInfo::ConstraintInfo &Info) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006355 return false;
6356 }
6357
Craig Topper3164f332014-03-11 03:39:26 +00006358 const char *getClobbers() const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00006359 return "";
6360 }
6361};
6362
6363void PNaClTargetInfo::getGCCRegNames(const char * const *&Names,
6364 unsigned &NumNames) const {
Craig Topperf1186c52014-05-08 06:41:40 +00006365 Names = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006366 NumNames = 0;
6367}
6368
6369void PNaClTargetInfo::getGCCRegAliases(const GCCRegAlias *&Aliases,
6370 unsigned &NumAliases) const {
Craig Topperf1186c52014-05-08 06:41:40 +00006371 Aliases = nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006372 NumAliases = 0;
6373}
6374} // end anonymous namespace.
6375
Guy Benyeib798fc92012-12-11 21:38:14 +00006376namespace {
JF Bastien643817d2014-09-12 17:52:47 +00006377class Le64TargetInfo : public TargetInfo {
6378 static const Builtin::Info BuiltinInfo[];
6379
6380public:
6381 Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6382 BigEndian = false;
6383 NoAsmVariants = true;
6384 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6385 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6386 DescriptionString =
JF Bastien1e6e41b2014-12-02 19:19:59 +00006387 "e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128";
JF Bastien643817d2014-09-12 17:52:47 +00006388 }
6389
6390 void getTargetDefines(const LangOptions &Opts,
6391 MacroBuilder &Builder) const override {
6392 DefineStd(Builder, "unix", Opts);
6393 defineCPUMacros(Builder, "le64", /*Tuning=*/false);
6394 Builder.defineMacro("__ELF__");
6395 }
6396 void getTargetBuiltins(const Builtin::Info *&Records,
6397 unsigned &NumRecords) const override {
6398 Records = BuiltinInfo;
6399 NumRecords = clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin;
6400 }
6401 BuiltinVaListKind getBuiltinVaListKind() const override {
6402 return TargetInfo::PNaClABIBuiltinVaList;
6403 }
6404 const char *getClobbers() const override { return ""; }
6405 void getGCCRegNames(const char *const *&Names,
6406 unsigned &NumNames) const override {
6407 Names = nullptr;
6408 NumNames = 0;
6409 }
6410 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6411 unsigned &NumAliases) const override {
6412 Aliases = nullptr;
6413 NumAliases = 0;
6414 }
6415 bool validateAsmConstraint(const char *&Name,
6416 TargetInfo::ConstraintInfo &Info) const override {
6417 return false;
6418 }
6419
6420 bool hasProtectedVisibility() const override { return false; }
JF Bastien643817d2014-09-12 17:52:47 +00006421};
6422} // end anonymous namespace.
6423
6424const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
6425#define BUILTIN(ID, TYPE, ATTRS) \
6426 { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6427#include "clang/Basic/BuiltinsLe64.def"
6428};
6429
6430namespace {
Guy Benyeib798fc92012-12-11 21:38:14 +00006431 static const unsigned SPIRAddrSpaceMap[] = {
6432 1, // opencl_global
6433 3, // opencl_local
6434 2, // opencl_constant
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +00006435 4, // opencl_generic
Guy Benyeib798fc92012-12-11 21:38:14 +00006436 0, // cuda_device
6437 0, // cuda_constant
6438 0 // cuda_shared
6439 };
6440 class SPIRTargetInfo : public TargetInfo {
Guy Benyeib798fc92012-12-11 21:38:14 +00006441 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006442 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006443 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
6444 "SPIR target must use unknown OS");
6445 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
6446 "SPIR target must use unknown environment type");
6447 BigEndian = false;
6448 TLSSupported = false;
6449 LongWidth = LongAlign = 64;
6450 AddrSpaceMap = &SPIRAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00006451 UseAddrSpaceMapMangling = true;
Guy Benyeib798fc92012-12-11 21:38:14 +00006452 // Define available target features
6453 // These must be defined in sorted order!
6454 NoAsmVariants = true;
6455 }
Craig Topper3164f332014-03-11 03:39:26 +00006456 void getTargetDefines(const LangOptions &Opts,
6457 MacroBuilder &Builder) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006458 DefineStd(Builder, "SPIR", Opts);
6459 }
Craig Topper3164f332014-03-11 03:39:26 +00006460 bool hasFeature(StringRef Feature) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006461 return Feature == "spir";
6462 }
Craig Topper3164f332014-03-11 03:39:26 +00006463
6464 void getTargetBuiltins(const Builtin::Info *&Records,
6465 unsigned &NumRecords) const override {}
6466 const char *getClobbers() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006467 return "";
6468 }
Craig Topper3164f332014-03-11 03:39:26 +00006469 void getGCCRegNames(const char * const *&Names,
6470 unsigned &NumNames) const override {}
Eric Christopher917e9522014-11-18 22:36:15 +00006471 bool
6472 validateAsmConstraint(const char *&Name,
6473 TargetInfo::ConstraintInfo &info) const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006474 return true;
6475 }
Craig Topper3164f332014-03-11 03:39:26 +00006476 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6477 unsigned &NumAliases) const override {}
6478 BuiltinVaListKind getBuiltinVaListKind() const override {
Guy Benyeib798fc92012-12-11 21:38:14 +00006479 return TargetInfo::VoidPtrBuiltinVaList;
6480 }
Alexander Kornienko21de0ae2015-01-20 11:20:41 +00006481
6482 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
6483 return (CC == CC_SpirFunction ||
6484 CC == CC_SpirKernel) ? CCCR_OK : CCCR_Warning;
6485 }
6486
6487 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
6488 return CC_SpirFunction;
6489 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006490 };
6491
6492
6493 class SPIR32TargetInfo : public SPIRTargetInfo {
6494 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006495 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006496 PointerWidth = PointerAlign = 32;
6497 SizeType = TargetInfo::UnsignedInt;
6498 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
6499 DescriptionString
Rafael Espindola29db13a2014-01-03 18:13:17 +00006500 = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
6501 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006502 }
Craig Topper3164f332014-03-11 03:39:26 +00006503 void getTargetDefines(const LangOptions &Opts,
6504 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006505 DefineStd(Builder, "SPIR32", Opts);
6506 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006507 };
6508
6509 class SPIR64TargetInfo : public SPIRTargetInfo {
6510 public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006511 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
Guy Benyeib798fc92012-12-11 21:38:14 +00006512 PointerWidth = PointerAlign = 64;
6513 SizeType = TargetInfo::UnsignedLong;
6514 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
Rafael Espindola29db13a2014-01-03 18:13:17 +00006515 DescriptionString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-"
6516 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
Guy Benyei5ea30272013-03-07 13:06:10 +00006517 }
Craig Topper3164f332014-03-11 03:39:26 +00006518 void getTargetDefines(const LangOptions &Opts,
6519 MacroBuilder &Builder) const override {
Guy Benyei5ea30272013-03-07 13:06:10 +00006520 DefineStd(Builder, "SPIR64", Opts);
6521 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006522 };
6523}
6524
Robert Lytton0e076492013-08-13 09:43:10 +00006525namespace {
6526class XCoreTargetInfo : public TargetInfo {
6527 static const Builtin::Info BuiltinInfo[];
6528public:
6529 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6530 BigEndian = false;
6531 NoAsmVariants = true;
6532 LongLongAlign = 32;
6533 SuitableAlign = 32;
6534 DoubleAlign = LongDoubleAlign = 32;
Robert Lyttoncc424662013-11-12 10:09:30 +00006535 SizeType = UnsignedInt;
6536 PtrDiffType = SignedInt;
6537 IntPtrType = SignedInt;
6538 WCharType = UnsignedChar;
6539 WIntType = UnsignedInt;
Robert Lytton0e076492013-08-13 09:43:10 +00006540 UseZeroLengthBitfieldAlignment = true;
Rafael Espindolac418ae92014-01-03 19:22:05 +00006541 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 +00006542 "-f64:32-a:0:32-n32";
Robert Lytton0e076492013-08-13 09:43:10 +00006543 }
Craig Topper3164f332014-03-11 03:39:26 +00006544 void getTargetDefines(const LangOptions &Opts,
6545 MacroBuilder &Builder) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006546 Builder.defineMacro("__XS1B__");
6547 }
Craig Topper3164f332014-03-11 03:39:26 +00006548 void getTargetBuiltins(const Builtin::Info *&Records,
6549 unsigned &NumRecords) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006550 Records = BuiltinInfo;
6551 NumRecords = clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin;
6552 }
Craig Topper3164f332014-03-11 03:39:26 +00006553 BuiltinVaListKind getBuiltinVaListKind() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006554 return TargetInfo::VoidPtrBuiltinVaList;
6555 }
Craig Topper3164f332014-03-11 03:39:26 +00006556 const char *getClobbers() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006557 return "";
6558 }
Craig Topper3164f332014-03-11 03:39:26 +00006559 void getGCCRegNames(const char * const *&Names,
6560 unsigned &NumNames) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006561 static const char * const GCCRegNames[] = {
6562 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6563 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
6564 };
6565 Names = GCCRegNames;
6566 NumNames = llvm::array_lengthof(GCCRegNames);
6567 }
Craig Topper3164f332014-03-11 03:39:26 +00006568 void getGCCRegAliases(const GCCRegAlias *&Aliases,
6569 unsigned &NumAliases) const override {
Craig Topperf1186c52014-05-08 06:41:40 +00006570 Aliases = nullptr;
Robert Lytton0e076492013-08-13 09:43:10 +00006571 NumAliases = 0;
6572 }
Craig Topper3164f332014-03-11 03:39:26 +00006573 bool validateAsmConstraint(const char *&Name,
6574 TargetInfo::ConstraintInfo &Info) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00006575 return false;
6576 }
Craig Topper3164f332014-03-11 03:39:26 +00006577 int getEHDataRegisterNumber(unsigned RegNo) const override {
Robert Lytton1a229262014-01-27 17:56:25 +00006578 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
6579 return (RegNo < 2)? RegNo : -1;
6580 }
Robert Lytton0e076492013-08-13 09:43:10 +00006581};
6582
6583const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
6584#define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
6585#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
6586 ALL_LANGUAGES },
6587#include "clang/Basic/BuiltinsXCore.def"
6588};
6589} // end anonymous namespace.
6590
Ivan Krasindd7403e2011-08-24 20:22:22 +00006591
Chris Lattner5ba61f02006-10-14 07:39:34 +00006592//===----------------------------------------------------------------------===//
6593// Driver code
6594//===----------------------------------------------------------------------===//
6595
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006596static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006597 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00006598
Daniel Dunbar52322032009-08-18 05:47:58 +00006599 switch (Triple.getArch()) {
6600 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006601 return nullptr;
Eli Friedmanb5366062008-05-20 14:21:01 +00006602
Tim Northover2a0783d2014-05-30 14:14:07 +00006603 case llvm::Triple::xcore:
6604 return new XCoreTargetInfo(Triple);
6605
6606 case llvm::Triple::hexagon:
6607 return new HexagonTargetInfo(Triple);
6608
6609 case llvm::Triple::aarch64:
Tim Northovera2ee4332014-03-29 15:09:45 +00006610 if (Triple.isOSDarwin())
Tim Northover573cbee2014-05-24 12:52:07 +00006611 return new DarwinAArch64TargetInfo(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006612
6613 switch (os) {
Ed Maste6a9eda52014-11-13 16:55:42 +00006614 case llvm::Triple::FreeBSD:
6615 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006616 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006617 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006618 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006619 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00006620 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006621 return new AArch64leTargetInfo(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00006622 }
6623
Christian Pirker9b019ae2014-02-25 13:51:00 +00006624 case llvm::Triple::aarch64_be:
6625 switch (os) {
Ed Maste6a9eda52014-11-13 16:55:42 +00006626 case llvm::Triple::FreeBSD:
6627 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006628 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00006629 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006630 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00006631 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00006632 default:
Tim Northover573cbee2014-05-24 12:52:07 +00006633 return new AArch64beTargetInfo(Triple);
Tim Northover9bb857a2013-01-31 12:13:10 +00006634 }
6635
Daniel Dunbar52322032009-08-18 05:47:58 +00006636 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00006637 case llvm::Triple::thumb:
Tim Northover157d9112014-01-16 08:48:16 +00006638 if (Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006639 return new DarwinARMTargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006640
Daniel Dunbar52322032009-08-18 05:47:58 +00006641 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00006642 case llvm::Triple::Linux:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006643 return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006644 case llvm::Triple::FreeBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006645 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006646 case llvm::Triple::NetBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006647 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006648 case llvm::Triple::OpenBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006649 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006650 case llvm::Triple::Bitrig:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006651 return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006652 case llvm::Triple::RTEMS:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006653 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006654 case llvm::Triple::NaCl:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006655 return new NaClTargetInfo<ARMleTargetInfo>(Triple);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006656 case llvm::Triple::Win32:
6657 switch (Triple.getEnvironment()) {
6658 default:
6659 return new ARMleTargetInfo(Triple);
6660 case llvm::Triple::Itanium:
6661 return new ItaniumWindowsARMleTargetInfo(Triple);
6662 case llvm::Triple::MSVC:
6663 return new MicrosoftARMleTargetInfo(Triple);
6664 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006665 default:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00006666 return new ARMleTargetInfo(Triple);
6667 }
6668
6669 case llvm::Triple::armeb:
6670 case llvm::Triple::thumbeb:
6671 if (Triple.isOSDarwin())
6672 return new DarwinARMTargetInfo(Triple);
6673
6674 switch (os) {
6675 case llvm::Triple::Linux:
6676 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
6677 case llvm::Triple::FreeBSD:
6678 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
6679 case llvm::Triple::NetBSD:
6680 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
6681 case llvm::Triple::OpenBSD:
6682 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
6683 case llvm::Triple::Bitrig:
6684 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
6685 case llvm::Triple::RTEMS:
6686 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
6687 case llvm::Triple::NaCl:
6688 return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
6689 default:
6690 return new ARMbeTargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006691 }
Eli Friedmanb5366062008-05-20 14:21:01 +00006692
Daniel Dunbar52322032009-08-18 05:47:58 +00006693 case llvm::Triple::msp430:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006694 return new MSP430TargetInfo(Triple);
Eli Friedmanb5366062008-05-20 14:21:01 +00006695
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006696 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006697 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006698 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006699 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006700 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006701 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006702 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006703 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006704 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006705 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006706 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006707 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00006708 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006709
6710 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006711 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006712 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006713 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006714 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006715 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006716 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006717 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006718 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006719 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Petar Jovanovicc19a2842013-09-21 01:27:01 +00006720 case llvm::Triple::NaCl:
6721 return new NaClTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006722 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006723 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00006724 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006725
Akira Hatanakabef17452011-09-20 19:21:49 +00006726 case llvm::Triple::mips64:
6727 switch (os) {
6728 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006729 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006730 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006731 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006732 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006733 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006734 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006735 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006736 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006737 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006738 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006739 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006740 }
6741
6742 case llvm::Triple::mips64el:
6743 switch (os) {
6744 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006745 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006746 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006747 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006748 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006749 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006750 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006751 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006752 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006753 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006754 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006755 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00006756 }
6757
Ivan Krasindd7403e2011-08-24 20:22:22 +00006758 case llvm::Triple::le32:
6759 switch (os) {
Eli Benderskyd7c92032012-12-04 18:38:10 +00006760 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006761 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
Ivan Krasindd7403e2011-08-24 20:22:22 +00006762 default:
Craig Topperf1186c52014-05-08 06:41:40 +00006763 return nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00006764 }
6765
JF Bastien643817d2014-09-12 17:52:47 +00006766 case llvm::Triple::le64:
6767 return new Le64TargetInfo(Triple);
6768
Daniel Dunbar52322032009-08-18 05:47:58 +00006769 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006770 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006771 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006772 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006773 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006774 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006775 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006776 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006777 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006778 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006779 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006780 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006781 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006782 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006783 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006784 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006785 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006786
6787 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006788 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006789 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006790 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006791 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006792 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006793 case llvm::Triple::Lv2:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006794 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006795 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006796 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006797 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006798 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006799 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006800 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006801 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006802
Bill Schmidt778d3872013-07-26 01:36:11 +00006803 case llvm::Triple::ppc64le:
6804 switch (os) {
6805 case llvm::Triple::Linux:
6806 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
6807 default:
6808 return new PPC64TargetInfo(Triple);
6809 }
6810
Peter Collingbournec947aae2012-05-20 23:28:41 +00006811 case llvm::Triple::nvptx:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006812 return new NVPTX32TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006813 case llvm::Triple::nvptx64:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006814 return new NVPTX64TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00006815
Tom Stellardd8e38a32015-01-06 20:34:47 +00006816 case llvm::Triple::amdgcn:
Eli Friedmand13b41e2012-10-12 23:32:00 +00006817 case llvm::Triple::r600:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006818 return new R600TargetInfo(Triple);
Eli Friedmand13b41e2012-10-12 23:32:00 +00006819
Daniel Dunbar52322032009-08-18 05:47:58 +00006820 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006821 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00006822 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006823 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006824 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006825 return new SolarisSparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006826 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006827 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00006828 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006829 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006830 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006831 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006832 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006833 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00006834 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006835
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006836 case llvm::Triple::sparcv9:
6837 switch (os) {
6838 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006839 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006840 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006841 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006842 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006843 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006844 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006845 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006846 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006847 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006848 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006849 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006850 }
6851
Ulrich Weigand47445072013-05-06 16:26:41 +00006852 case llvm::Triple::systemz:
6853 switch (os) {
6854 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006855 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006856 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006857 return new SystemZTargetInfo(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00006858 }
6859
Eli Friedmana9c3d712009-08-19 20:47:07 +00006860 case llvm::Triple::tce:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006861 return new TCETargetInfo(Triple);
Eli Friedmana9c3d712009-08-19 20:47:07 +00006862
Daniel Dunbar52322032009-08-18 05:47:58 +00006863 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006864 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006865 return new DarwinI386TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006866
Daniel Dunbar52322032009-08-18 05:47:58 +00006867 switch (os) {
Daniel Dunbar52322032009-08-18 05:47:58 +00006868 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006869 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006870 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006871 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006872 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006873 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006874 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006875 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006876 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006877 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006878 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006879 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006880 case llvm::Triple::KFreeBSD:
6881 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner3e2ee142010-07-07 16:01:42 +00006882 case llvm::Triple::Minix:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006883 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006884 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006885 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006886 case llvm::Triple::Win32: {
6887 switch (Triple.getEnvironment()) {
6888 default:
6889 return new X86_32TargetInfo(Triple);
6890 case llvm::Triple::Cygnus:
6891 return new CygwinX86_32TargetInfo(Triple);
6892 case llvm::Triple::GNU:
6893 return new MinGWX86_32TargetInfo(Triple);
Saleem Abdulrasool24bd7da2014-06-28 23:34:11 +00006894 case llvm::Triple::Itanium:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006895 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006896 return new MicrosoftX86_32TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006897 }
6898 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00006899 case llvm::Triple::Haiku:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006900 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00006901 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006902 return new RTEMSX86_32TargetInfo(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00006903 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006904 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006905 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006906 return new X86_32TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006907 }
6908
6909 case llvm::Triple::x86_64:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006910 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006911 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00006912
Daniel Dunbar52322032009-08-18 05:47:58 +00006913 switch (os) {
Ed Schoutenf33c6072015-03-11 08:42:46 +00006914 case llvm::Triple::CloudABI:
6915 return new CloudABITargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006916 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006917 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
Chris Lattner002ba6b2010-01-09 05:41:14 +00006918 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006919 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006920 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006921 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006922 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006923 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00006924 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006925 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006926 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006927 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00006928 case llvm::Triple::KFreeBSD:
6929 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006930 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006931 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006932 case llvm::Triple::Win32: {
6933 switch (Triple.getEnvironment()) {
6934 default:
6935 return new X86_64TargetInfo(Triple);
6936 case llvm::Triple::GNU:
6937 return new MinGWX86_64TargetInfo(Triple);
6938 case llvm::Triple::MSVC:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00006939 return new MicrosoftX86_64TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00006940 }
6941 }
Eli Benderskyd7c92032012-12-04 18:38:10 +00006942 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006943 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Alex Rosenberg12207fa2015-01-27 14:47:44 +00006944 case llvm::Triple::PS4:
6945 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006946 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006947 return new X86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00006948 }
Guy Benyeib798fc92012-12-11 21:38:14 +00006949
6950 case llvm::Triple::spir: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006951 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006952 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006953 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006954 return new SPIR32TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006955 }
6956 case llvm::Triple::spir64: {
Guy Benyeib798fc92012-12-11 21:38:14 +00006957 if (Triple.getOS() != llvm::Triple::UnknownOS ||
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006958 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
Craig Topperf1186c52014-05-08 06:41:40 +00006959 return nullptr;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006960 return new SPIR64TargetInfo(Triple);
Guy Benyeib798fc92012-12-11 21:38:14 +00006961 }
Daniel Dunbar52322032009-08-18 05:47:58 +00006962 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00006963}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006964
6965/// CreateTargetInfo - Return the target info object for the specified target
6966/// triple.
Alp Toker80758082014-07-06 05:26:44 +00006967TargetInfo *
6968TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
6969 const std::shared_ptr<TargetOptions> &Opts) {
Douglas Gregorf8715de2012-11-16 04:24:59 +00006970 llvm::Triple Triple(Opts->Triple);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006971
6972 // Construct the target
Ahmed Charlesb8984322014-03-07 20:03:18 +00006973 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006974 if (!Target) {
6975 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
Craig Topperf1186c52014-05-08 06:41:40 +00006976 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006977 }
Alp Toker80758082014-07-06 05:26:44 +00006978 Target->TargetOpts = Opts;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006979
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006980 // Set the target CPU if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006981 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
6982 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Craig Topperf1186c52014-05-08 06:41:40 +00006983 return nullptr;
Daniel Dunbaracde99e2009-12-18 18:42:37 +00006984 }
6985
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006986 // Set the target ABI if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00006987 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
6988 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Craig Topperf1186c52014-05-08 06:41:40 +00006989 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006990 }
6991
Rafael Espindolaeb265472013-08-21 21:59:03 +00006992 // Set the fp math unit.
6993 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
6994 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
Craig Topperf1186c52014-05-08 06:41:40 +00006995 return nullptr;
Rafael Espindolaeb265472013-08-21 21:59:03 +00006996 }
6997
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00006998 // Compute the default target features, we need the target to handle this
6999 // because features may have dependencies on one another.
7000 llvm::StringMap<bool> Features;
Chandler Carruth8bdcf9e2011-09-28 05:56:05 +00007001 Target->getDefaultFeatures(Features);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007002
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00007003 // Apply the user specified deltas.
7004 for (unsigned I = 0, N = Opts->FeaturesAsWritten.size();
7005 I < N; ++I) {
7006 const char *Name = Opts->FeaturesAsWritten[I].c_str();
Rafael Espindolaa6416a72011-11-27 20:00:43 +00007007 // Apply the feature via the target.
Rafael Espindoladb0fcfb2013-08-20 18:57:55 +00007008 bool Enabled = Name[0] == '+';
7009 Target->setFeatureEnabled(Features, Name + 1, Enabled);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007010 }
7011
7012 // Add the features to the compile options.
7013 //
7014 // FIXME: If we are completely confident that we have the right set, we only
7015 // need to pass the minuses.
Douglas Gregorf8715de2012-11-16 04:24:59 +00007016 Opts->Features.clear();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007017 for (llvm::StringMap<bool>::const_iterator it = Features.begin(),
7018 ie = Features.end(); it != ie; ++it)
Douglas Gregorf8715de2012-11-16 04:24:59 +00007019 Opts->Features.push_back((it->second ? "+" : "-") + it->first().str());
Eric Christopher3ff21b32013-10-16 21:26:26 +00007020 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Craig Topperf1186c52014-05-08 06:41:40 +00007021 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007022
Ahmed Charles9a16beb2014-03-07 19:33:25 +00007023 return Target.release();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007024}