blob: 409c4ec5401963e43cf1ff243e8eb700a44bb5fc [file] [log] [blame]
Eric Christopherb39156d2015-08-26 04:23:11 +00001//===--- Targets.cpp - Implement target feature support -------------------===//
Chris Lattner5ba61f02006-10-14 07:39:34 +00002//
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"
Tim Northover756447a2015-10-30 16:30:36 +000022#include "clang/Basic/Version.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000023#include "llvm/ADT/APFloat.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000024#include "llvm/ADT/STLExtras.h"
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +000025#include "llvm/ADT/StringExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000026#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000027#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000028#include "llvm/ADT/Triple.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000029#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000030#include "llvm/Support/ErrorHandling.h"
Renato Golinf5c4dec2015-05-27 13:33:00 +000031#include "llvm/Support/TargetParser.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000032#include <algorithm>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000033#include <memory>
Hans Wennborg7eb54642015-09-10 17:07:54 +000034
Chris Lattner5ba61f02006-10-14 07:39:34 +000035using namespace clang;
36
Chris Lattner5ba61f02006-10-14 07:39:34 +000037//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000038// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000039//===----------------------------------------------------------------------===//
40
Chris Lattner1e1c0b92009-03-20 16:06:38 +000041/// DefineStd - Define a macro name and standard variants. For example if
42/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
43/// when in GNU mode.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000044static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000045 const LangOptions &Opts) {
46 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000047
Chris Lattner1e1c0b92009-03-20 16:06:38 +000048 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
49 // in the user's namespace.
50 if (Opts.GNUMode)
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);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000055
Chris Lattner1e1c0b92009-03-20 16:06:38 +000056 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000057 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000058}
59
Benjamin Kramere3b442d2012-01-10 11:50:09 +000060static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
61 bool Tuning = true) {
62 Builder.defineMacro("__" + CPUName);
63 Builder.defineMacro("__" + CPUName + "__");
64 if (Tuning)
65 Builder.defineMacro("__tune_" + CPUName + "__");
66}
67
Chris Lattner09d98f52008-10-05 21:50:58 +000068//===----------------------------------------------------------------------===//
69// Defines specific to certain operating systems.
70//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000071
Torok Edwinb2b37c62009-06-30 17:10:35 +000072namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000073template<typename TgtInfo>
74class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000075protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000076 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000077 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000078public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +000079 OSTargetInfo(const llvm::Triple &Triple) : TgtInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +000080 void getTargetDefines(const LangOptions &Opts,
81 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000082 TgtInfo::getTargetDefines(Opts, Builder);
83 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000084 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000085
86};
Chris Lattner30ba6742009-08-10 19:03:04 +000087
Eric Christopher7d0c7252015-09-24 21:17:04 +000088// CloudABI Target
89template <typename Target>
90class CloudABITargetInfo : public OSTargetInfo<Target> {
91protected:
92 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
93 MacroBuilder &Builder) const override {
94 Builder.defineMacro("__CloudABI__");
95 Builder.defineMacro("__ELF__");
96
97 // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
98 Builder.defineMacro("__STDC_ISO_10646__", "201206L");
99 Builder.defineMacro("__STDC_UTF_16__");
100 Builder.defineMacro("__STDC_UTF_32__");
101 }
102
103public:
104 CloudABITargetInfo(const llvm::Triple &Triple)
105 : OSTargetInfo<Target>(Triple) {
106 this->UserLabelPrefix = "";
107 }
108};
109
Daniel Dunbard86666f2010-01-26 01:44:04 +0000110static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000111 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000112 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000113 VersionTuple &PlatformMinVersion) {
Bob Wilson834400b2013-08-19 20:23:37 +0000114 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000115 Builder.defineMacro("__APPLE__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000116 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenkob4f81902012-09-20 10:10:01 +0000117 // AddressSanitizer doesn't play well with source fortification, which is on
118 // by default on Darwin.
Alexey Samsonovedf99a92014-11-07 22:29:38 +0000119 if (Opts.Sanitize.has(SanitizerKind::Address))
120 Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000121
John McCall460ce582015-10-22 18:38:17 +0000122 // Darwin defines __weak, __strong, and __unsafe_unretained even in C mode.
123 if (!Opts.ObjC1) {
John McCall31168b02011-06-15 23:02:42 +0000124 // __weak is always defined, for use in blocks and with objc pointers.
125 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
John McCall460ce582015-10-22 18:38:17 +0000126 Builder.defineMacro("__strong", "");
John McCall31168b02011-06-15 23:02:42 +0000127 Builder.defineMacro("__unsafe_unretained", "");
John McCall31168b02011-06-15 23:02:42 +0000128 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000129
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000130 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000131 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000132 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000133 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000134
135 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000136 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000137
Daniel Dunbarecf13562011-04-19 21:40:34 +0000138 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000139 unsigned Maj, Min, Rev;
Bob Wilson8e5acc52012-01-31 23:52:58 +0000140 if (Triple.isMacOSX()) {
141 Triple.getMacOSXVersion(Maj, Min, Rev);
Daniel Dunbarecf13562011-04-19 21:40:34 +0000142 PlatformName = "macosx";
Daniel Dunbarecf13562011-04-19 21:40:34 +0000143 } else {
Bob Wilson8e5acc52012-01-31 23:52:58 +0000144 Triple.getOSVersion(Maj, Min, Rev);
145 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000146 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000147
Sebastian Pop422377c2012-01-20 22:01:23 +0000148 // If -target arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000149 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-07-19 20:00:06 +0000150 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
151 if (PlatformName == "win32") {
152 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
153 return;
154 }
155
Evan Cheng31dd9a62014-01-26 23:12:43 +0000156 // Set the appropriate OS version define.
157 if (Triple.isiOS()) {
158 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
159 char Str[6];
160 Str[0] = '0' + Maj;
161 Str[1] = '0' + (Min / 10);
162 Str[2] = '0' + (Min % 10);
163 Str[3] = '0' + (Rev / 10);
164 Str[4] = '0' + (Rev % 10);
165 Str[5] = '\0';
Tim Northover67465f82015-10-30 16:30:30 +0000166 if (Triple.isTvOS())
167 Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str);
168 else
169 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
170 Str);
171
172 } else if (Triple.isWatchOS()) {
173 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
174 char Str[6];
175 Str[0] = '0' + Maj;
176 Str[1] = '0' + (Min / 10);
177 Str[2] = '0' + (Min % 10);
178 Str[3] = '0' + (Rev / 10);
179 Str[4] = '0' + (Rev % 10);
180 Str[5] = '\0';
181 Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
Evan Cheng31dd9a62014-01-26 23:12:43 +0000182 } else if (Triple.isMacOSX()) {
183 // Note that the Driver allows versions which aren't representable in the
184 // define (because we only get a single digit for the minor and micro
185 // revision numbers). So, we limit them to the maximum representable
186 // version.
187 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Bob Wilson2a3710e2014-08-08 21:45:53 +0000188 char Str[7];
189 if (Maj < 10 || (Maj == 10 && Min < 10)) {
190 Str[0] = '0' + (Maj / 10);
191 Str[1] = '0' + (Maj % 10);
192 Str[2] = '0' + std::min(Min, 9U);
193 Str[3] = '0' + std::min(Rev, 9U);
194 Str[4] = '\0';
195 } else {
196 // Handle versions > 10.9.
197 Str[0] = '0' + (Maj / 10);
198 Str[1] = '0' + (Maj % 10);
199 Str[2] = '0' + (Min / 10);
200 Str[3] = '0' + (Min % 10);
201 Str[4] = '0' + (Rev / 10);
202 Str[5] = '0' + (Rev % 10);
203 Str[6] = '\0';
204 }
Evan Cheng31dd9a62014-01-26 23:12:43 +0000205 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000206 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000207
Tim Northover157d9112014-01-16 08:48:16 +0000208 // Tell users about the kernel if there is one.
209 if (Triple.isOSDarwin())
210 Builder.defineMacro("__MACH__");
211
Daniel Dunbarecf13562011-04-19 21:40:34 +0000212 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000213}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000214
Torok Edwinb2b37c62009-06-30 17:10:35 +0000215template<typename Target>
216class DarwinTargetInfo : public OSTargetInfo<Target> {
217protected:
Craig Topper3164f332014-03-11 03:39:26 +0000218 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
219 MacroBuilder &Builder) const override {
Eric Christopher0c912c52011-07-07 22:55:26 +0000220 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000221 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000222 }
Mike Stump11289f42009-09-09 15:08:12 +0000223
Torok Edwinb2b37c62009-06-30 17:10:35 +0000224public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000225 DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
226 this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
227 this->MCountName = "\01mcount";
228 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000229
Craig Topper3164f332014-03-11 03:39:26 +0000230 std::string isValidSectionSpecifier(StringRef SR) const override {
Chris Lattner30ba6742009-08-10 19:03:04 +0000231 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000232 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000233 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000234 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000235 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000236 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000237 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000238
Craig Topper3164f332014-03-11 03:39:26 +0000239 const char *getStaticInitSectionSpecifier() const override {
Anders Carlsson851318a2010-06-08 22:47:50 +0000240 // FIXME: We should return 0 when building kexts.
241 return "__TEXT,__StaticInit,regular,pure_instructions";
242 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000243
John McCalleed64c72012-01-29 01:20:30 +0000244 /// Darwin does not support protected visibility. Darwin's "default"
245 /// is very similar to ELF's "protected"; Darwin requires a "weak"
246 /// attribute on declarations that can be dynamically replaced.
Craig Topper3164f332014-03-11 03:39:26 +0000247 bool hasProtectedVisibility() const override {
John McCalleed64c72012-01-29 01:20:30 +0000248 return false;
249 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000250};
251
Chris Lattner30ba6742009-08-10 19:03:04 +0000252
Torok Edwinb2b37c62009-06-30 17:10:35 +0000253// DragonFlyBSD Target
254template<typename Target>
255class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
256protected:
Craig Topper3164f332014-03-11 03:39:26 +0000257 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
258 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000259 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000260 Builder.defineMacro("__DragonFly__");
261 Builder.defineMacro("__DragonFly_cc_version", "100001");
262 Builder.defineMacro("__ELF__");
263 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
264 Builder.defineMacro("__tune_i386__");
265 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000266 }
267public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000268 DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
269 : OSTargetInfo<Target>(Triple) {
270 this->UserLabelPrefix = "";
Eli Friedman4286fba2012-02-10 23:02:29 +0000271
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000272 switch (Triple.getArch()) {
273 default:
274 case llvm::Triple::x86:
275 case llvm::Triple::x86_64:
276 this->MCountName = ".mcount";
277 break;
278 }
Eli Friedman4286fba2012-02-10 23:02:29 +0000279 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000280};
281
282// FreeBSD Target
283template<typename Target>
284class FreeBSDTargetInfo : public OSTargetInfo<Target> {
285protected:
Craig Topper3164f332014-03-11 03:39:26 +0000286 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
287 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000288 // FreeBSD defines; list based off of gcc output
289
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000290 unsigned Release = Triple.getOSMajorVersion();
291 if (Release == 0U)
292 Release = 8;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000293
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000294 Builder.defineMacro("__FreeBSD__", Twine(Release));
295 Builder.defineMacro("__FreeBSD_cc_version", Twine(Release * 100000U + 1U));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000296 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
297 DefineStd(Builder, "unix", Opts);
298 Builder.defineMacro("__ELF__");
Ed Schoutend0621462013-09-29 07:54:52 +0000299
300 // On FreeBSD, wchar_t contains the number of the code point as
301 // used by the character set of the locale. These character sets are
302 // not necessarily a superset of ASCII.
Richard Smith00a4a852015-01-13 01:47:45 +0000303 //
304 // FIXME: This is wrong; the macro refers to the numerical values
305 // of wchar_t *literals*, which are not locale-dependent. However,
306 // FreeBSD systems apparently depend on us getting this wrong, and
307 // setting this to 1 is conforming even if all the basic source
308 // character literals have the same encoding as char and wchar_t.
Ed Schoutend0621462013-09-29 07:54:52 +0000309 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000310 }
311public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000312 FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
313 this->UserLabelPrefix = "";
Roman Divacky178e01602011-02-10 16:52:03 +0000314
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000315 switch (Triple.getArch()) {
316 default:
317 case llvm::Triple::x86:
318 case llvm::Triple::x86_64:
319 this->MCountName = ".mcount";
320 break;
321 case llvm::Triple::mips:
322 case llvm::Triple::mipsel:
323 case llvm::Triple::ppc:
324 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +0000325 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000326 this->MCountName = "_mcount";
327 break;
328 case llvm::Triple::arm:
329 this->MCountName = "__mcount";
330 break;
Duncan Sands9cb27e92009-07-08 13:55:08 +0000331 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000332 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000333};
334
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000335// GNU/kFreeBSD Target
336template<typename Target>
337class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
338protected:
Craig Topper3164f332014-03-11 03:39:26 +0000339 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
340 MacroBuilder &Builder) const override {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000341 // GNU/kFreeBSD defines; list based off of gcc output
342
343 DefineStd(Builder, "unix", Opts);
344 Builder.defineMacro("__FreeBSD_kernel__");
345 Builder.defineMacro("__GLIBC__");
346 Builder.defineMacro("__ELF__");
347 if (Opts.POSIXThreads)
348 Builder.defineMacro("_REENTRANT");
349 if (Opts.CPlusPlus)
350 Builder.defineMacro("_GNU_SOURCE");
351 }
352public:
Eric Christopher917e9522014-11-18 22:36:15 +0000353 KFreeBSDTargetInfo(const llvm::Triple &Triple)
354 : OSTargetInfo<Target>(Triple) {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000355 this->UserLabelPrefix = "";
356 }
357};
358
Chris Lattner3e2ee142010-07-07 16:01:42 +0000359// Minix Target
360template<typename Target>
361class MinixTargetInfo : public OSTargetInfo<Target> {
362protected:
Craig Topper3164f332014-03-11 03:39:26 +0000363 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
364 MacroBuilder &Builder) const override {
Chris Lattner3e2ee142010-07-07 16:01:42 +0000365 // Minix defines
366
367 Builder.defineMacro("__minix", "3");
368 Builder.defineMacro("_EM_WSIZE", "4");
369 Builder.defineMacro("_EM_PSIZE", "4");
370 Builder.defineMacro("_EM_SSIZE", "2");
371 Builder.defineMacro("_EM_LSIZE", "4");
372 Builder.defineMacro("_EM_FSIZE", "4");
373 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000374 Builder.defineMacro("__ELF__");
Chris Lattner3e2ee142010-07-07 16:01:42 +0000375 DefineStd(Builder, "unix", Opts);
376 }
377public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000378 MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
379 this->UserLabelPrefix = "";
380 }
Chris Lattner3e2ee142010-07-07 16:01:42 +0000381};
382
Torok Edwinb2b37c62009-06-30 17:10:35 +0000383// Linux target
384template<typename Target>
385class LinuxTargetInfo : public OSTargetInfo<Target> {
386protected:
Craig Topper3164f332014-03-11 03:39:26 +0000387 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
388 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000389 // Linux defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000390 DefineStd(Builder, "unix", Opts);
391 DefineStd(Builder, "linux", Opts);
392 Builder.defineMacro("__gnu_linux__");
393 Builder.defineMacro("__ELF__");
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +0000394 if (Triple.isAndroid()) {
Evgeniy Stepanov94dc4c92012-04-26 12:08:09 +0000395 Builder.defineMacro("__ANDROID__", "1");
Dan Albert84aee012015-03-03 18:28:38 +0000396 unsigned Maj, Min, Rev;
David Majnemer5c2589a2015-06-01 23:38:25 +0000397 Triple.getEnvironmentVersion(Maj, Min, Rev);
Dan Albert84aee012015-03-03 18:28:38 +0000398 this->PlatformName = "android";
399 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
400 }
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000401 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000402 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000403 if (Opts.CPlusPlus)
404 Builder.defineMacro("_GNU_SOURCE");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000405 }
406public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000407 LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000408 this->UserLabelPrefix = "";
Douglas Gregore6d6e512011-01-12 21:19:25 +0000409 this->WIntType = TargetInfo::UnsignedInt;
Hal Finkelecdb4542014-03-30 13:00:06 +0000410
411 switch (Triple.getArch()) {
412 default:
413 break;
414 case llvm::Triple::ppc:
415 case llvm::Triple::ppc64:
416 case llvm::Triple::ppc64le:
417 this->MCountName = "_mcount";
418 break;
419 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000420 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000421
Craig Topper3164f332014-03-11 03:39:26 +0000422 const char *getStaticInitSectionSpecifier() const override {
Benjamin Kramera518b222011-10-15 17:53:33 +0000423 return ".text.startup";
424 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000425};
426
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000427// NetBSD Target
428template<typename Target>
429class NetBSDTargetInfo : public OSTargetInfo<Target> {
430protected:
Craig Topper3164f332014-03-11 03:39:26 +0000431 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
432 MacroBuilder &Builder) const override {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000433 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000434 Builder.defineMacro("__NetBSD__");
435 Builder.defineMacro("__unix__");
436 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000437 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000438 Builder.defineMacro("_POSIX_THREADS");
Joerg Sonnenbergercc1edb52014-05-13 18:58:36 +0000439
440 switch (Triple.getArch()) {
441 default:
442 break;
443 case llvm::Triple::arm:
444 case llvm::Triple::armeb:
445 case llvm::Triple::thumb:
446 case llvm::Triple::thumbeb:
447 Builder.defineMacro("__ARM_DWARF_EH__");
448 break;
449 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000450 }
451public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000452 NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
453 this->UserLabelPrefix = "";
Joerg Sonnenberger740f3f42015-04-10 21:02:53 +0000454 this->MCountName = "_mcount";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000455 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000456};
457
Torok Edwinb2b37c62009-06-30 17:10:35 +0000458// OpenBSD Target
459template<typename Target>
460class OpenBSDTargetInfo : public OSTargetInfo<Target> {
461protected:
Craig Topper3164f332014-03-11 03:39:26 +0000462 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
463 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000464 // OpenBSD defines; list based off of gcc output
465
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000466 Builder.defineMacro("__OpenBSD__");
467 DefineStd(Builder, "unix", Opts);
468 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000469 if (Opts.POSIXThreads)
Chris Lattner024e12d2012-04-25 06:12:24 +0000470 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000471 }
472public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000473 OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
474 this->UserLabelPrefix = "";
475 this->TLSSupported = false;
Eli Friedman3715d1f2011-12-15 02:15:56 +0000476
Eli Friedman3715d1f2011-12-15 02:15:56 +0000477 switch (Triple.getArch()) {
478 default:
479 case llvm::Triple::x86:
480 case llvm::Triple::x86_64:
481 case llvm::Triple::arm:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000482 case llvm::Triple::sparc:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000483 this->MCountName = "__mcount";
484 break;
485 case llvm::Triple::mips64:
486 case llvm::Triple::mips64el:
487 case llvm::Triple::ppc:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000488 case llvm::Triple::sparcv9:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000489 this->MCountName = "_mcount";
490 break;
491 }
492 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000493};
494
Eli Friedman9fa28852012-08-08 23:57:20 +0000495// Bitrig Target
496template<typename Target>
497class BitrigTargetInfo : public OSTargetInfo<Target> {
498protected:
Craig Topper3164f332014-03-11 03:39:26 +0000499 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
500 MacroBuilder &Builder) const override {
Eli Friedman9fa28852012-08-08 23:57:20 +0000501 // Bitrig defines; list based off of gcc output
502
503 Builder.defineMacro("__Bitrig__");
504 DefineStd(Builder, "unix", Opts);
505 Builder.defineMacro("__ELF__");
506 if (Opts.POSIXThreads)
507 Builder.defineMacro("_REENTRANT");
Renato Golin9ba39232015-02-27 16:35:48 +0000508
509 switch (Triple.getArch()) {
510 default:
511 break;
512 case llvm::Triple::arm:
513 case llvm::Triple::armeb:
514 case llvm::Triple::thumb:
515 case llvm::Triple::thumbeb:
516 Builder.defineMacro("__ARM_DWARF_EH__");
517 break;
518 }
Eli Friedman9fa28852012-08-08 23:57:20 +0000519 }
520public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000521 BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
522 this->UserLabelPrefix = "";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000523 this->MCountName = "__mcount";
Eli Friedman9fa28852012-08-08 23:57:20 +0000524 }
525};
526
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000527// PSP Target
528template<typename Target>
529class PSPTargetInfo : public OSTargetInfo<Target> {
530protected:
Craig Topper3164f332014-03-11 03:39:26 +0000531 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
532 MacroBuilder &Builder) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000533 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000534 Builder.defineMacro("PSP");
535 Builder.defineMacro("_PSP");
536 Builder.defineMacro("__psp__");
537 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000538 }
539public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000540 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000541 this->UserLabelPrefix = "";
542 }
543};
544
John Thompsone467e192009-11-19 17:18:50 +0000545// PS3 PPU Target
546template<typename Target>
547class PS3PPUTargetInfo : public OSTargetInfo<Target> {
548protected:
Craig Topper3164f332014-03-11 03:39:26 +0000549 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
550 MacroBuilder &Builder) const override {
John Thompsone467e192009-11-19 17:18:50 +0000551 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000552 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000553 Builder.defineMacro("__PPU__");
554 Builder.defineMacro("__CELLOS_LV2__");
555 Builder.defineMacro("__ELF__");
556 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000557 Builder.defineMacro("_ARCH_PPC64");
558 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000559 }
560public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000561 PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
John Thompsone467e192009-11-19 17:18:50 +0000562 this->UserLabelPrefix = "";
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000563 this->LongWidth = this->LongAlign = 32;
564 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000565 this->IntMaxType = TargetInfo::SignedLongLong;
John Thompson07a61a42010-06-24 22:44:13 +0000566 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000567 this->SizeType = TargetInfo::UnsignedInt;
Eric Christopher964a5f32015-08-05 23:48:05 +0000568 this->DataLayoutString = "E-m:e-p:32:32-i64:64-n32:64";
John Thompsone467e192009-11-19 17:18:50 +0000569 }
570};
571
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000572template <typename Target>
573class PS4OSTargetInfo : public OSTargetInfo<Target> {
574protected:
575 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
576 MacroBuilder &Builder) const override {
577 Builder.defineMacro("__FreeBSD__", "9");
578 Builder.defineMacro("__FreeBSD_cc_version", "900001");
579 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
580 DefineStd(Builder, "unix", Opts);
581 Builder.defineMacro("__ELF__");
582 Builder.defineMacro("__PS4__");
583 }
584public:
585 PS4OSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
586 this->WCharType = this->UnsignedShort;
587
Paul Robinsond30e2ee2015-07-14 20:52:32 +0000588 // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
589 this->MaxTLSAlign = 256;
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000590 this->UserLabelPrefix = "";
591
592 switch (Triple.getArch()) {
593 default:
594 case llvm::Triple::x86_64:
595 this->MCountName = ".mcount";
596 break;
597 }
598 }
599};
600
Torok Edwinb2b37c62009-06-30 17:10:35 +0000601// Solaris target
602template<typename Target>
603class SolarisTargetInfo : public OSTargetInfo<Target> {
604protected:
Craig Topper3164f332014-03-11 03:39:26 +0000605 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
606 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000607 DefineStd(Builder, "sun", Opts);
608 DefineStd(Builder, "unix", Opts);
609 Builder.defineMacro("__ELF__");
610 Builder.defineMacro("__svr4__");
611 Builder.defineMacro("__SVR4");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000612 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
613 // newer, but to 500 for everything else. feature_test.h has a check to
614 // ensure that you are not using C99 with an old version of X/Open or C89
Richard Smithab506ad2014-10-20 23:26:58 +0000615 // with a new version.
616 if (Opts.C99)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000617 Builder.defineMacro("_XOPEN_SOURCE", "600");
618 else
619 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnalle04307e2012-03-02 10:49:52 +0000620 if (Opts.CPlusPlus)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000621 Builder.defineMacro("__C99FEATURES__");
David Chisnall0c1941cb2012-02-17 18:35:11 +0000622 Builder.defineMacro("_LARGEFILE_SOURCE");
623 Builder.defineMacro("_LARGEFILE64_SOURCE");
624 Builder.defineMacro("__EXTENSIONS__");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000625 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000626 }
627public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000628 SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000629 this->UserLabelPrefix = "";
David Chisnallb526e932012-03-28 18:04:14 +0000630 this->WCharType = this->SignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000631 // FIXME: WIntType should be SignedLong
632 }
633};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000634
635// Windows target
636template<typename Target>
637class WindowsTargetInfo : public OSTargetInfo<Target> {
638protected:
Craig Topper3164f332014-03-11 03:39:26 +0000639 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
640 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000641 Builder.defineMacro("_WIN32");
642 }
643 void getVisualStudioDefines(const LangOptions &Opts,
644 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000645 if (Opts.CPlusPlus) {
David Majnemerf6072342014-07-01 22:24:56 +0000646 if (Opts.RTTIData)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000647 Builder.defineMacro("_CPPRTTI");
648
Reid Kleckner16514352015-01-30 21:42:55 +0000649 if (Opts.CXXExceptions)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000650 Builder.defineMacro("_CPPUNWIND");
651 }
652
David Majnemer6a658902015-07-22 22:36:26 +0000653 if (Opts.Bool)
654 Builder.defineMacro("__BOOL_DEFINED");
655
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000656 if (!Opts.CharIsSigned)
657 Builder.defineMacro("_CHAR_UNSIGNED");
658
659 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
660 // but it works for now.
661 if (Opts.POSIXThreads)
662 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000663
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +0000664 if (Opts.MSCompatibilityVersion) {
665 Builder.defineMacro("_MSC_VER",
666 Twine(Opts.MSCompatibilityVersion / 100000));
667 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000668 // FIXME We cannot encode the revision information into 32-bits
669 Builder.defineMacro("_MSC_BUILD", Twine(1));
David Majnemeraaf2b842015-03-18 07:53:18 +0000670
David Majnemerb710a932015-05-11 03:57:49 +0000671 if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
David Majnemeraaf2b842015-03-18 07:53:18 +0000672 Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000673 }
Reid Kleckner6f6e76d2014-04-16 20:10:16 +0000674
675 if (Opts.MicrosoftExt) {
676 Builder.defineMacro("_MSC_EXTENSIONS");
677
678 if (Opts.CPlusPlus11) {
679 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
680 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
681 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
682 }
683 }
684
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000685 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000686 }
687
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000688public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000689 WindowsTargetInfo(const llvm::Triple &Triple)
690 : OSTargetInfo<Target>(Triple) {}
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000691};
692
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000693template <typename Target>
694class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000695protected:
Craig Topper3164f332014-03-11 03:39:26 +0000696 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
697 MacroBuilder &Builder) const override {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000698 if (Opts.POSIXThreads)
699 Builder.defineMacro("_REENTRANT");
700 if (Opts.CPlusPlus)
701 Builder.defineMacro("_GNU_SOURCE");
702
703 DefineStd(Builder, "unix", Opts);
704 Builder.defineMacro("__ELF__");
705 Builder.defineMacro("__native_client__");
706 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000707
708public:
709 NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000710 this->UserLabelPrefix = "";
711 this->LongAlign = 32;
712 this->LongWidth = 32;
713 this->PointerAlign = 32;
714 this->PointerWidth = 32;
715 this->IntMaxType = TargetInfo::SignedLongLong;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000716 this->Int64Type = TargetInfo::SignedLongLong;
717 this->DoubleAlign = 64;
718 this->LongDoubleWidth = 64;
719 this->LongDoubleAlign = 64;
Jan Wen Voung1f9c4ee2014-01-15 21:42:41 +0000720 this->LongLongWidth = 64;
721 this->LongLongAlign = 64;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000722 this->SizeType = TargetInfo::UnsignedInt;
723 this->PtrDiffType = TargetInfo::SignedInt;
724 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +0000725 // RegParmMax is inherited from the underlying architecture
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000726 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Rafael Espindola1c09b262013-12-18 23:41:04 +0000727 if (Triple.getArch() == llvm::Triple::arm) {
Derek Schuff6ab52fa2015-03-30 20:31:33 +0000728 // Handled in ARM's setABI().
Rafael Espindola1c09b262013-12-18 23:41:04 +0000729 } else if (Triple.getArch() == llvm::Triple::x86) {
Eric Christopher964a5f32015-08-05 23:48:05 +0000730 this->DataLayoutString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000731 } else if (Triple.getArch() == llvm::Triple::x86_64) {
Eric Christopher964a5f32015-08-05 23:48:05 +0000732 this->DataLayoutString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000733 } else if (Triple.getArch() == llvm::Triple::mipsel) {
Eric Christopher964a5f32015-08-05 23:48:05 +0000734 // Handled on mips' setDataLayoutString.
Rafael Espindola1c09b262013-12-18 23:41:04 +0000735 } else {
736 assert(Triple.getArch() == llvm::Triple::le32);
Eric Christopher964a5f32015-08-05 23:48:05 +0000737 this->DataLayoutString = "e-p:32:32-i64:64";
Rafael Espindola1c09b262013-12-18 23:41:04 +0000738 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000739 }
740};
Torok Edwinb2b37c62009-06-30 17:10:35 +0000741
Dan Gohmanc2853072015-09-03 22:51:53 +0000742// WebAssembly target
743template <typename Target>
744class WebAssemblyOSTargetInfo : public OSTargetInfo<Target> {
745 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Hans Wennborg7eb54642015-09-10 17:07:54 +0000746 MacroBuilder &Builder) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +0000747 // A common platform macro.
748 if (Opts.POSIXThreads)
749 Builder.defineMacro("_REENTRANT");
750 // Follow g++ convention and predefine _GNU_SOURCE for C++.
751 if (Opts.CPlusPlus)
752 Builder.defineMacro("_GNU_SOURCE");
753 }
754
755 // As an optimization, group static init code together in a section.
Hans Wennborg7eb54642015-09-10 17:07:54 +0000756 const char *getStaticInitSectionSpecifier() const final {
Dan Gohmanc2853072015-09-03 22:51:53 +0000757 return ".text.__startup";
758 }
759
760public:
761 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple)
762 : OSTargetInfo<Target>(Triple) {
763 this->MCountName = "__mcount";
764 this->UserLabelPrefix = "";
765 this->TheCXXABI.set(TargetCXXABI::WebAssembly);
766 }
767};
Dan Gohmanc2853072015-09-03 22:51:53 +0000768
Chris Lattner09d98f52008-10-05 21:50:58 +0000769//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000770// Specific target implementations.
771//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000772
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000773// PPC abstract base class
774class PPCTargetInfo : public TargetInfo {
775 static const Builtin::Info BuiltinInfo[];
776 static const char * const GCCRegNames[];
777 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel8eb59282012-06-11 22:35:19 +0000778 std::string CPU;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000779
780 // Target cpu features.
781 bool HasVSX;
Bill Schmidt8c184e32014-10-10 17:21:23 +0000782 bool HasP8Vector;
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +0000783 bool HasP8Crypto;
Nemanja Ivanovic35458c22015-04-11 10:43:36 +0000784 bool HasDirectMove;
Hal Finkel0d0a1a52015-03-11 19:14:15 +0000785 bool HasQPX;
Kit Barton8246f282015-03-25 19:41:41 +0000786 bool HasHTM;
Nemanja Ivanovic239eec72015-04-09 23:58:16 +0000787 bool HasBPERMD;
788 bool HasExtDiv;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000789
Ulrich Weigand8afad612014-07-28 13:17:52 +0000790protected:
791 std::string ABI;
792
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000793public:
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000794 PPCTargetInfo(const llvm::Triple &Triple)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +0000795 : TargetInfo(Triple), HasVSX(false), HasP8Vector(false),
Nemanja Ivanovic35458c22015-04-11 10:43:36 +0000796 HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false),
Nemanja Ivanovic239eec72015-04-09 23:58:16 +0000797 HasBPERMD(false), HasExtDiv(false) {
Bill Schmidt778d3872013-07-26 01:36:11 +0000798 BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
Alexey Bataev00396512015-07-02 03:40:19 +0000799 SimdDefaultAlign = 128;
Nico Weber3435ede2012-01-31 02:07:33 +0000800 LongDoubleWidth = LongDoubleAlign = 128;
801 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
802 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000803
Hal Finkel6b984f02012-07-03 16:51:04 +0000804 /// \brief Flags for architecture specific defines.
805 typedef enum {
806 ArchDefineNone = 0,
807 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
808 ArchDefinePpcgr = 1 << 1,
809 ArchDefinePpcsq = 1 << 2,
810 ArchDefine440 = 1 << 3,
811 ArchDefine603 = 1 << 4,
812 ArchDefine604 = 1 << 5,
813 ArchDefinePwr4 = 1 << 6,
Bill Schmidt38378a02013-02-01 20:23:10 +0000814 ArchDefinePwr5 = 1 << 7,
815 ArchDefinePwr5x = 1 << 8,
816 ArchDefinePwr6 = 1 << 9,
817 ArchDefinePwr6x = 1 << 10,
818 ArchDefinePwr7 = 1 << 11,
Will Schmidtf0487512014-06-26 13:34:10 +0000819 ArchDefinePwr8 = 1 << 12,
820 ArchDefineA2 = 1 << 13,
821 ArchDefineA2q = 1 << 14
Hal Finkel6b984f02012-07-03 16:51:04 +0000822 } ArchDefineTypes;
823
Bill Schmidt38378a02013-02-01 20:23:10 +0000824 // Note: GCC recognizes the following additional cpus:
825 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
826 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
827 // titan, rs64.
Craig Topper3164f332014-03-11 03:39:26 +0000828 bool setCPU(const std::string &Name) override {
Hal Finkel8eb59282012-06-11 22:35:19 +0000829 bool CPUKnown = llvm::StringSwitch<bool>(Name)
830 .Case("generic", true)
831 .Case("440", true)
832 .Case("450", true)
833 .Case("601", true)
834 .Case("602", true)
835 .Case("603", true)
836 .Case("603e", true)
837 .Case("603ev", true)
838 .Case("604", true)
839 .Case("604e", true)
840 .Case("620", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000841 .Case("630", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000842 .Case("g3", true)
843 .Case("7400", true)
844 .Case("g4", true)
845 .Case("7450", true)
846 .Case("g4+", true)
847 .Case("750", true)
848 .Case("970", true)
849 .Case("g5", true)
850 .Case("a2", true)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +0000851 .Case("a2q", true)
Hal Finkelf6d6cb02012-09-18 22:25:03 +0000852 .Case("e500mc", true)
853 .Case("e5500", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000854 .Case("power3", true)
855 .Case("pwr3", true)
856 .Case("power4", true)
857 .Case("pwr4", true)
858 .Case("power5", true)
859 .Case("pwr5", true)
860 .Case("power5x", true)
861 .Case("pwr5x", true)
862 .Case("power6", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000863 .Case("pwr6", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000864 .Case("power6x", true)
865 .Case("pwr6x", true)
866 .Case("power7", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000867 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +0000868 .Case("power8", true)
869 .Case("pwr8", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000870 .Case("powerpc", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000871 .Case("ppc", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000872 .Case("powerpc64", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000873 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +0000874 .Case("powerpc64le", true)
875 .Case("ppc64le", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000876 .Default(false);
877
878 if (CPUKnown)
879 CPU = Name;
880
881 return CPUKnown;
882 }
883
Ulrich Weigand8afad612014-07-28 13:17:52 +0000884
885 StringRef getABI() const override { return ABI; }
886
Craig Topper6c03a542015-10-19 04:51:35 +0000887 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
888 return llvm::makeArrayRef(BuiltinInfo,
889 clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin);
Chris Lattner10a5b382007-01-29 05:24:35 +0000890 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000891
Craig Topper3164f332014-03-11 03:39:26 +0000892 bool isCLZForZeroUndef() const override { return false; }
Bob Wilson19a2f2b2012-01-28 18:02:29 +0000893
Craig Topper3164f332014-03-11 03:39:26 +0000894 void getTargetDefines(const LangOptions &Opts,
895 MacroBuilder &Builder) const override;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000896
Eric Christopher8c47b422015-10-09 18:39:55 +0000897 bool
898 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
899 StringRef CPU,
900 const std::vector<std::string> &FeaturesVec) const override;
Bill Schmidt2fe4c672013-02-01 02:14:03 +0000901
Craig Topper3164f332014-03-11 03:39:26 +0000902 bool handleTargetFeatures(std::vector<std::string> &Features,
903 DiagnosticsEngine &Diags) override;
904 bool hasFeature(StringRef Feature) const override;
Nemanja Ivanovic26c35342015-07-10 13:11:34 +0000905 void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
906 bool Enabled) const override;
Craig Topper3164f332014-03-11 03:39:26 +0000907
Craig Topperf054e3a2015-10-19 03:52:27 +0000908 ArrayRef<const char *> getGCCRegNames() const override;
909 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +0000910 bool validateAsmConstraint(const char *&Name,
911 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +0000912 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +0000913 default: return false;
914 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +0000915 break;
Anders Carlssonf511f642007-11-27 04:11:28 +0000916 case 'b': // Base register
917 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +0000918 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +0000919 break;
920 // FIXME: The following are added to allow parsing.
921 // I just took a guess at what the actions should be.
922 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000923 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +0000924 case 'v': // Altivec vector register
925 Info.setAllowsRegister();
926 break;
927 case 'w':
928 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000929 case 'd':// VSX vector register to hold vector double data
930 case 'f':// VSX vector register to hold vector float data
931 case 's':// VSX vector register to hold scalar float data
932 case 'a':// Any VSX register
Hal Finkelf7a07a52014-03-02 18:24:18 +0000933 case 'c':// An individual CR bit
John Thompson07a61a42010-06-24 22:44:13 +0000934 break;
935 default:
936 return false;
937 }
938 Info.setAllowsRegister();
939 Name++; // Skip over 'w'.
940 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000941 case 'h': // `MQ', `CTR', or `LINK' register
942 case 'q': // `MQ' register
943 case 'c': // `CTR' register
944 case 'l': // `LINK' register
945 case 'x': // `CR' register (condition register) number 0
946 case 'y': // `CR' register (condition register)
947 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +0000948 Info.setAllowsRegister();
949 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000950 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000951 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000952 // (use `L' instead for SImode constants)
953 case 'K': // Unsigned 16-bit constant
954 case 'L': // Signed 16-bit constant shifted left 16 bits
955 case 'M': // Constant larger than 31
956 case 'N': // Exact power of 2
957 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +0000958 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000959 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +0000960 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000961 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +0000962 break;
963 case 'm': // Memory operand. Note that on PowerPC targets, m can
964 // include addresses that update the base register. It
965 // is therefore only safe to use `m' in an asm statement
966 // if that asm statement accesses the operand exactly once.
967 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +0000968 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000969 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +0000970 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000971 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +0000972 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
973 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000974 // register to be updated.
975 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +0000976 if (Name[1] != 's')
977 return false;
Sebastian Redldd008712010-08-17 22:42:34 +0000978 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +0000979 // include any automodification of the base register. Unlike
980 // `m', this constraint can be used in asm statements that
981 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +0000982 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +0000983 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +0000984 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +0000985 break;
986 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000987 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000988 case 'Z': // Memory operand that is an indexed or indirect from a
989 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000990 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +0000991 Info.setAllowsMemory();
992 Info.setAllowsRegister();
993 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000994 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +0000995 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000996 // register (`p' is preferable for asm statements)
997 case 'S': // Constant suitable as a 64-bit mask operand
998 case 'T': // Constant suitable as a 32-bit mask operand
999 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +00001000 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001001 // instructions
1002 case 'W': // Vector constant that does not require memory
1003 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +00001004 break;
1005 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +00001006 }
John Thompson07a61a42010-06-24 22:44:13 +00001007 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +00001008 }
Craig Topper3164f332014-03-11 03:39:26 +00001009 std::string convertConstraint(const char *&Constraint) const override {
Hal Finkelf7a07a52014-03-02 18:24:18 +00001010 std::string R;
1011 switch (*Constraint) {
1012 case 'e':
1013 case 'w':
1014 // Two-character constraint; add "^" hint for later parsing.
1015 R = std::string("^") + std::string(Constraint, 2);
1016 Constraint++;
1017 break;
1018 default:
1019 return TargetInfo::convertConstraint(Constraint);
1020 }
1021 return R;
1022 }
Craig Topper3164f332014-03-11 03:39:26 +00001023 const char *getClobbers() const override {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001024 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +00001025 }
Craig Topper3164f332014-03-11 03:39:26 +00001026 int getEHDataRegisterNumber(unsigned RegNo) const override {
Adhemerval Zanella5d874ae2013-01-22 20:02:45 +00001027 if (RegNo == 0) return 3;
1028 if (RegNo == 1) return 4;
1029 return -1;
1030 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +00001031
1032 bool hasSjLjLowering() const override {
1033 return true;
1034 }
David Majnemer2617ea62015-06-09 18:05:33 +00001035
1036 bool useFloat128ManglingForLongDouble() const override {
1037 return LongDoubleWidth == 128 &&
1038 LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble &&
1039 getTriple().isOSBinFormatELF();
1040 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001041};
Anders Carlssonf511f642007-11-27 04:11:28 +00001042
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001043const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00001044#define BUILTIN(ID, TYPE, ATTRS) \
1045 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1046#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1047 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Chris Lattner5abdec72009-06-14 01:05:48 +00001048#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001049};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001050
Eric Christopher917e9522014-11-18 22:36:15 +00001051/// handleTargetFeatures - Perform initialization based on the user
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001052/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00001053bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001054 DiagnosticsEngine &Diags) {
Eric Christopher610fe112015-08-26 08:21:55 +00001055 for (const auto &Feature : Features) {
1056 if (Feature == "+vsx") {
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001057 HasVSX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001058 } else if (Feature == "+bpermd") {
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001059 HasBPERMD = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001060 } else if (Feature == "+extdiv") {
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001061 HasExtDiv = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001062 } else if (Feature == "+power8-vector") {
Bill Schmidt8c184e32014-10-10 17:21:23 +00001063 HasP8Vector = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001064 } else if (Feature == "+crypto") {
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001065 HasP8Crypto = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001066 } else if (Feature == "+direct-move") {
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001067 HasDirectMove = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001068 } else if (Feature == "+qpx") {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001069 HasQPX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001070 } else if (Feature == "+htm") {
Kit Barton8246f282015-03-25 19:41:41 +00001071 HasHTM = true;
Kit Barton8246f282015-03-25 19:41:41 +00001072 }
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001073 // TODO: Finish this list and add an assert that we've handled them
1074 // all.
1075 }
Eric Christopher02c33352015-08-25 00:59:11 +00001076
Eric Christopherf0c2dd02015-08-25 13:45:28 +00001077 return true;
1078}
1079
Chris Lattnerecd49032009-03-02 22:27:17 +00001080/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
1081/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001082void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001083 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001084 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001085 Builder.defineMacro("__ppc__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001086 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001087 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001088 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001089 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001090 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001091 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001092 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001093 Builder.defineMacro("__ppc64__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001094 Builder.defineMacro("__PPC64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001095 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001096
Chris Lattnerecd49032009-03-02 22:27:17 +00001097 // Target properties.
Bill Schmidt778d3872013-07-26 01:36:11 +00001098 if (getTriple().getArch() == llvm::Triple::ppc64le) {
1099 Builder.defineMacro("_LITTLE_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001100 } else {
1101 if (getTriple().getOS() != llvm::Triple::NetBSD &&
1102 getTriple().getOS() != llvm::Triple::OpenBSD)
1103 Builder.defineMacro("_BIG_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001104 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001105
Ulrich Weigand8afad612014-07-28 13:17:52 +00001106 // ABI options.
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001107 if (ABI == "elfv1" || ABI == "elfv1-qpx")
Ulrich Weigand8afad612014-07-28 13:17:52 +00001108 Builder.defineMacro("_CALL_ELF", "1");
1109 if (ABI == "elfv2")
1110 Builder.defineMacro("_CALL_ELF", "2");
1111
Chris Lattnerecd49032009-03-02 22:27:17 +00001112 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001113 Builder.defineMacro("__NATURAL_ALIGNMENT__");
1114 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001115
Chris Lattnerecd49032009-03-02 22:27:17 +00001116 // FIXME: Should be controlled by command line option.
Roman Divacky13b586f2013-07-03 19:45:54 +00001117 if (LongDoubleWidth == 128)
1118 Builder.defineMacro("__LONG_DOUBLE_128__");
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001119
John Thompsone467e192009-11-19 17:18:50 +00001120 if (Opts.AltiVec) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001121 Builder.defineMacro("__VEC__", "10206");
1122 Builder.defineMacro("__ALTIVEC__");
John Thompsone467e192009-11-19 17:18:50 +00001123 }
Hal Finkel8eb59282012-06-11 22:35:19 +00001124
1125 // CPU identification.
Hal Finkel6b984f02012-07-03 16:51:04 +00001126 ArchDefineTypes defs = (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1127 .Case("440", ArchDefineName)
1128 .Case("450", ArchDefineName | ArchDefine440)
1129 .Case("601", ArchDefineName)
1130 .Case("602", ArchDefineName | ArchDefinePpcgr)
1131 .Case("603", ArchDefineName | ArchDefinePpcgr)
1132 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1133 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1134 .Case("604", ArchDefineName | ArchDefinePpcgr)
1135 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1136 .Case("620", ArchDefineName | ArchDefinePpcgr)
Bill Schmidt38378a02013-02-01 20:23:10 +00001137 .Case("630", ArchDefineName | ArchDefinePpcgr)
Hal Finkel6b984f02012-07-03 16:51:04 +00001138 .Case("7400", ArchDefineName | ArchDefinePpcgr)
1139 .Case("7450", ArchDefineName | ArchDefinePpcgr)
1140 .Case("750", ArchDefineName | ArchDefinePpcgr)
1141 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1142 | ArchDefinePpcsq)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001143 .Case("a2", ArchDefineA2)
1144 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
Bill Schmidt38378a02013-02-01 20:23:10 +00001145 .Case("pwr3", ArchDefinePpcgr)
1146 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1147 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr
1148 | ArchDefinePpcsq)
1149 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4
1150 | ArchDefinePpcgr | ArchDefinePpcsq)
1151 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5
1152 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1153 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x
1154 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1155 | ArchDefinePpcsq)
1156 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6
1157 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001158 | ArchDefinePpcgr | ArchDefinePpcsq)
1159 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x
1160 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1161 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Bill Schmidt38378a02013-02-01 20:23:10 +00001162 .Case("power3", ArchDefinePpcgr)
1163 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1164 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1165 | ArchDefinePpcsq)
1166 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
1167 | ArchDefinePpcgr | ArchDefinePpcsq)
1168 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1169 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1170 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x
1171 | ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr
1172 | ArchDefinePpcsq)
1173 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6
1174 | ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4
Will Schmidtf0487512014-06-26 13:34:10 +00001175 | ArchDefinePpcgr | ArchDefinePpcsq)
1176 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x
1177 | ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5
1178 | ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
Hal Finkel6b984f02012-07-03 16:51:04 +00001179 .Default(ArchDefineNone);
1180
1181 if (defs & ArchDefineName)
1182 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1183 if (defs & ArchDefinePpcgr)
1184 Builder.defineMacro("_ARCH_PPCGR");
1185 if (defs & ArchDefinePpcsq)
1186 Builder.defineMacro("_ARCH_PPCSQ");
1187 if (defs & ArchDefine440)
Hal Finkel8eb59282012-06-11 22:35:19 +00001188 Builder.defineMacro("_ARCH_440");
Hal Finkel6b984f02012-07-03 16:51:04 +00001189 if (defs & ArchDefine603)
1190 Builder.defineMacro("_ARCH_603");
1191 if (defs & ArchDefine604)
1192 Builder.defineMacro("_ARCH_604");
Bill Schmidt38378a02013-02-01 20:23:10 +00001193 if (defs & ArchDefinePwr4)
Hal Finkel6b984f02012-07-03 16:51:04 +00001194 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt38378a02013-02-01 20:23:10 +00001195 if (defs & ArchDefinePwr5)
Hal Finkel6b984f02012-07-03 16:51:04 +00001196 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt38378a02013-02-01 20:23:10 +00001197 if (defs & ArchDefinePwr5x)
1198 Builder.defineMacro("_ARCH_PWR5X");
1199 if (defs & ArchDefinePwr6)
Hal Finkel8eb59282012-06-11 22:35:19 +00001200 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt38378a02013-02-01 20:23:10 +00001201 if (defs & ArchDefinePwr6x)
1202 Builder.defineMacro("_ARCH_PWR6X");
1203 if (defs & ArchDefinePwr7)
1204 Builder.defineMacro("_ARCH_PWR7");
Will Schmidtf0487512014-06-26 13:34:10 +00001205 if (defs & ArchDefinePwr8)
1206 Builder.defineMacro("_ARCH_PWR8");
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001207 if (defs & ArchDefineA2)
1208 Builder.defineMacro("_ARCH_A2");
1209 if (defs & ArchDefineA2q) {
1210 Builder.defineMacro("_ARCH_A2Q");
1211 Builder.defineMacro("_ARCH_QP");
1212 }
1213
1214 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1215 Builder.defineMacro("__bg__");
1216 Builder.defineMacro("__THW_BLUEGENE__");
1217 Builder.defineMacro("__bgq__");
1218 Builder.defineMacro("__TOS_BGQ__");
1219 }
Bill Schmidt38378a02013-02-01 20:23:10 +00001220
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001221 if (HasVSX)
1222 Builder.defineMacro("__VSX__");
Bill Schmidt8c184e32014-10-10 17:21:23 +00001223 if (HasP8Vector)
Bill Schmidt59eb7672014-10-10 15:09:43 +00001224 Builder.defineMacro("__POWER8_VECTOR__");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001225 if (HasP8Crypto)
1226 Builder.defineMacro("__CRYPTO__");
Kit Barton8246f282015-03-25 19:41:41 +00001227 if (HasHTM)
1228 Builder.defineMacro("__HTM__");
Hal Finkela57b8902015-10-01 13:39:49 +00001229
1230 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
1231 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
1232 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
1233 if (PointerWidth == 64)
1234 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001235
Bill Schmidt38378a02013-02-01 20:23:10 +00001236 // FIXME: The following are not yet generated here by Clang, but are
1237 // generated by GCC:
1238 //
1239 // _SOFT_FLOAT_
1240 // __RECIP_PRECISION__
1241 // __APPLE_ALTIVEC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001242 // __RECIP__
1243 // __RECIPF__
1244 // __RSQRTE__
1245 // __RSQRTEF__
1246 // _SOFT_DOUBLE_
1247 // __NO_LWSYNC__
1248 // __HAVE_BSWAP__
1249 // __LONGDOUBLE128
1250 // __CMODEL_MEDIUM__
1251 // __CMODEL_LARGE__
1252 // _CALL_SYSV
1253 // _CALL_DARWIN
1254 // __NO_FPRS__
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001255}
1256
Eric Christophera8a14c32015-08-31 18:39:16 +00001257// Handle explicit options being passed to the compiler here: if we've
1258// explicitly turned off vsx and turned on power8-vector or direct-move then
1259// go ahead and error since the customer has expressed a somewhat incompatible
1260// set of options.
1261static bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags,
Eric Christopher8c47b422015-10-09 18:39:55 +00001262 const std::vector<std::string> &FeaturesVec) {
Eric Christophera8a14c32015-08-31 18:39:16 +00001263
1264 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "-vsx") !=
1265 FeaturesVec.end()) {
1266 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+power8-vector") !=
1267 FeaturesVec.end()) {
1268 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower8-vector"
1269 << "-mno-vsx";
1270 return false;
1271 }
1272
1273 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+direct-move") !=
1274 FeaturesVec.end()) {
1275 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mdirect-move"
1276 << "-mno-vsx";
1277 return false;
1278 }
1279 }
1280
1281 return true;
1282}
1283
Eric Christopher8c47b422015-10-09 18:39:55 +00001284bool PPCTargetInfo::initFeatureMap(
1285 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
1286 const std::vector<std::string> &FeaturesVec) const {
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001287 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1288 .Case("7400", true)
1289 .Case("g4", true)
1290 .Case("7450", true)
1291 .Case("g4+", true)
1292 .Case("970", true)
1293 .Case("g5", true)
1294 .Case("pwr6", true)
1295 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +00001296 .Case("pwr8", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001297 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +00001298 .Case("ppc64le", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001299 .Default(false);
Hal Finkelb58ce852013-02-01 18:44:19 +00001300
1301 Features["qpx"] = (CPU == "a2q");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001302 Features["crypto"] = llvm::StringSwitch<bool>(CPU)
1303 .Case("ppc64le", true)
1304 .Case("pwr8", true)
1305 .Default(false);
1306 Features["power8-vector"] = llvm::StringSwitch<bool>(CPU)
1307 .Case("ppc64le", true)
1308 .Case("pwr8", true)
1309 .Default(false);
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001310 Features["bpermd"] = llvm::StringSwitch<bool>(CPU)
1311 .Case("ppc64le", true)
1312 .Case("pwr8", true)
1313 .Case("pwr7", true)
1314 .Default(false);
1315 Features["extdiv"] = llvm::StringSwitch<bool>(CPU)
1316 .Case("ppc64le", true)
1317 .Case("pwr8", true)
1318 .Case("pwr7", true)
1319 .Default(false);
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001320 Features["direct-move"] = llvm::StringSwitch<bool>(CPU)
1321 .Case("ppc64le", true)
1322 .Case("pwr8", true)
1323 .Default(false);
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001324 Features["vsx"] = llvm::StringSwitch<bool>(CPU)
1325 .Case("ppc64le", true)
1326 .Case("pwr8", true)
1327 .Case("pwr7", true)
1328 .Default(false);
Eric Christopheref1e2952015-08-28 02:13:58 +00001329
Eric Christophera8a14c32015-08-31 18:39:16 +00001330 if (!ppcUserFeaturesCheck(Diags, FeaturesVec))
1331 return false;
Eric Christopher007b0a02015-08-28 22:32:01 +00001332
Eric Christopher007b0a02015-08-28 22:32:01 +00001333 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001334}
1335
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001336bool PPCTargetInfo::hasFeature(StringRef Feature) const {
Bill Schmidte6e9d152014-11-02 14:56:41 +00001337 return llvm::StringSwitch<bool>(Feature)
1338 .Case("powerpc", true)
1339 .Case("vsx", HasVSX)
1340 .Case("power8-vector", HasP8Vector)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001341 .Case("crypto", HasP8Crypto)
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001342 .Case("direct-move", HasDirectMove)
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001343 .Case("qpx", HasQPX)
Kit Barton8246f282015-03-25 19:41:41 +00001344 .Case("htm", HasHTM)
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001345 .Case("bpermd", HasBPERMD)
1346 .Case("extdiv", HasExtDiv)
Bill Schmidte6e9d152014-11-02 14:56:41 +00001347 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001348}
Chris Lattner17df24e2008-04-21 18:56:49 +00001349
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001350void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1351 StringRef Name, bool Enabled) const {
Eric Christopherf0c2dd02015-08-25 13:45:28 +00001352 // If we're enabling direct-move or power8-vector go ahead and enable vsx
1353 // as well. Do the inverse if we're disabling vsx. We'll diagnose any user
1354 // incompatible options.
1355 if (Enabled) {
1356 if (Name == "vsx") {
1357 Features[Name] = true;
1358 } else if (Name == "direct-move") {
1359 Features[Name] = Features["vsx"] = true;
1360 } else if (Name == "power8-vector") {
1361 Features[Name] = Features["vsx"] = true;
1362 } else {
1363 Features[Name] = true;
1364 }
1365 } else {
1366 if (Name == "vsx") {
1367 Features[Name] = Features["direct-move"] = Features["power8-vector"] =
1368 false;
1369 } else {
1370 Features[Name] = false;
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001371 }
1372 }
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001373}
1374
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001375const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001376 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1377 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1378 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1379 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1380 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1381 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1382 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1383 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001384 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001385 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001386 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001387 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1388 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1389 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1390 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001391 "vrsave", "vscr",
1392 "spe_acc", "spefscr",
1393 "sfp"
1394};
Chris Lattner10a5b382007-01-29 05:24:35 +00001395
Craig Topperf054e3a2015-10-19 03:52:27 +00001396ArrayRef<const char*> PPCTargetInfo::getGCCRegNames() const {
1397 return llvm::makeArrayRef(GCCRegNames);
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001398}
Chris Lattner5ba61f02006-10-14 07:39:34 +00001399
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001400const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1401 // While some of these aliases do map to different registers
1402 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001403 { { "0" }, "r0" },
1404 { { "1"}, "r1" },
1405 { { "2" }, "r2" },
1406 { { "3" }, "r3" },
1407 { { "4" }, "r4" },
1408 { { "5" }, "r5" },
1409 { { "6" }, "r6" },
1410 { { "7" }, "r7" },
1411 { { "8" }, "r8" },
1412 { { "9" }, "r9" },
1413 { { "10" }, "r10" },
1414 { { "11" }, "r11" },
1415 { { "12" }, "r12" },
1416 { { "13" }, "r13" },
1417 { { "14" }, "r14" },
1418 { { "15" }, "r15" },
1419 { { "16" }, "r16" },
1420 { { "17" }, "r17" },
1421 { { "18" }, "r18" },
1422 { { "19" }, "r19" },
1423 { { "20" }, "r20" },
1424 { { "21" }, "r21" },
1425 { { "22" }, "r22" },
1426 { { "23" }, "r23" },
1427 { { "24" }, "r24" },
1428 { { "25" }, "r25" },
1429 { { "26" }, "r26" },
1430 { { "27" }, "r27" },
1431 { { "28" }, "r28" },
1432 { { "29" }, "r29" },
1433 { { "30" }, "r30" },
1434 { { "31" }, "r31" },
1435 { { "fr0" }, "f0" },
1436 { { "fr1" }, "f1" },
1437 { { "fr2" }, "f2" },
1438 { { "fr3" }, "f3" },
1439 { { "fr4" }, "f4" },
1440 { { "fr5" }, "f5" },
1441 { { "fr6" }, "f6" },
1442 { { "fr7" }, "f7" },
1443 { { "fr8" }, "f8" },
1444 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +00001445 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001446 { { "fr11" }, "f11" },
1447 { { "fr12" }, "f12" },
1448 { { "fr13" }, "f13" },
1449 { { "fr14" }, "f14" },
1450 { { "fr15" }, "f15" },
1451 { { "fr16" }, "f16" },
1452 { { "fr17" }, "f17" },
1453 { { "fr18" }, "f18" },
1454 { { "fr19" }, "f19" },
1455 { { "fr20" }, "f20" },
1456 { { "fr21" }, "f21" },
1457 { { "fr22" }, "f22" },
1458 { { "fr23" }, "f23" },
1459 { { "fr24" }, "f24" },
1460 { { "fr25" }, "f25" },
1461 { { "fr26" }, "f26" },
1462 { { "fr27" }, "f27" },
1463 { { "fr28" }, "f28" },
1464 { { "fr29" }, "f29" },
1465 { { "fr30" }, "f30" },
1466 { { "fr31" }, "f31" },
1467 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001468};
1469
Craig Topperf054e3a2015-10-19 03:52:27 +00001470ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const {
1471 return llvm::makeArrayRef(GCCRegAliases);
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001472}
Chris Lattner02dffbd2006-10-14 07:50:21 +00001473
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001474class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001475public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001476 PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Eric Christopher964a5f32015-08-05 23:48:05 +00001477 DataLayoutString = "E-m:e-p:32:32-i64:64-n32";
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001478
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001479 switch (getTriple().getOS()) {
Nico Weber3435ede2012-01-31 02:07:33 +00001480 case llvm::Triple::Linux:
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001481 case llvm::Triple::FreeBSD:
1482 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001483 SizeType = UnsignedInt;
Hal Finkel26908382012-03-02 20:54:36 +00001484 PtrDiffType = SignedInt;
1485 IntPtrType = SignedInt;
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001486 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +00001487 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001488 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001489 }
Roman Divacky816dcd12012-03-13 16:53:54 +00001490
Roman Divacky3ffe7462012-03-13 19:20:17 +00001491 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1492 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001493 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Roman Divacky3ffe7462012-03-13 19:20:17 +00001494 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001495
1496 // PPC32 supports atomics up to 4 bytes.
1497 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divacky965b0b72011-01-06 08:27:10 +00001498 }
1499
Craig Topper3164f332014-03-11 03:39:26 +00001500 BuiltinVaListKind getBuiltinVaListKind() const override {
Roman Divacky965b0b72011-01-06 08:27:10 +00001501 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Inge5d3fb222012-06-16 03:34:49 +00001502 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedman873f65a2008-08-21 00:13:15 +00001503 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001504};
Chris Lattner5ba61f02006-10-14 07:39:34 +00001505
Bill Schmidt778d3872013-07-26 01:36:11 +00001506// Note: ABI differences may eventually require us to have a separate
1507// TargetInfo for little endian.
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001508class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001509public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001510 PPC64TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001511 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001512 IntMaxType = SignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001513 Int64Type = SignedLong;
Roman Divacky816dcd12012-03-13 16:53:54 +00001514
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001515 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
Eric Christopher964a5f32015-08-05 23:48:05 +00001516 DataLayoutString = "e-m:e-i64:64-n32:64";
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001517 ABI = "elfv2";
1518 } else {
Eric Christopher964a5f32015-08-05 23:48:05 +00001519 DataLayoutString = "E-m:e-i64:64-n32:64";
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001520 ABI = "elfv1";
1521 }
1522
1523 switch (getTriple().getOS()) {
1524 case llvm::Triple::FreeBSD:
Roman Divacky3ffe7462012-03-13 19:20:17 +00001525 LongDoubleWidth = LongDoubleAlign = 64;
Roman Divacky816dcd12012-03-13 16:53:54 +00001526 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001527 break;
Joerg Sonnenbergeraac82c42014-10-15 19:52:03 +00001528 case llvm::Triple::NetBSD:
1529 IntMaxType = SignedLongLong;
1530 Int64Type = SignedLongLong;
1531 break;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001532 default:
1533 break;
Ulrich Weigand8afad612014-07-28 13:17:52 +00001534 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001535
1536 // PPC64 supports atomics up to 8 bytes.
1537 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001538 }
Craig Topper3164f332014-03-11 03:39:26 +00001539 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001540 return TargetInfo::CharPtrBuiltinVaList;
Roman Divacky965b0b72011-01-06 08:27:10 +00001541 }
Eric Christophere6b7cf42015-07-10 18:25:52 +00001542 // PPC64 Linux-specific ABI options.
Ulrich Weigand8afad612014-07-28 13:17:52 +00001543 bool setABI(const std::string &Name) override {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001544 if (Name == "elfv1" || Name == "elfv1-qpx" || Name == "elfv2") {
Ulrich Weigand8afad612014-07-28 13:17:52 +00001545 ABI = Name;
1546 return true;
1547 }
1548 return false;
1549 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001550};
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001551
Roman Divacky965b0b72011-01-06 08:27:10 +00001552class DarwinPPC32TargetInfo :
1553 public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001554public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001555 DarwinPPC32TargetInfo(const llvm::Triple &Triple)
1556 : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001557 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +00001558 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopher917e9522014-11-18 22:36:15 +00001559 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev68d773c2012-01-17 22:40:00 +00001560 LongLongAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001561 SuitableAlign = 128;
Eric Christopher964a5f32015-08-05 23:48:05 +00001562 DataLayoutString = "E-m:o-p:32:32-f64:32:64-n32";
Roman Divacky965b0b72011-01-06 08:27:10 +00001563 }
Craig Topper3164f332014-03-11 03:39:26 +00001564 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001565 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001566 }
1567};
1568
1569class DarwinPPC64TargetInfo :
1570 public DarwinTargetInfo<PPC64TargetInfo> {
1571public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00001572 DarwinPPC64TargetInfo(const llvm::Triple &Triple)
1573 : DarwinTargetInfo<PPC64TargetInfo>(Triple) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001574 HasAlignMac68kSupport = true;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00001575 SuitableAlign = 128;
Eric Christopher964a5f32015-08-05 23:48:05 +00001576 DataLayoutString = "E-m:o-i64:64-n32:64";
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001577 }
1578};
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001579
Eric Christopherc48497a2015-09-18 21:26:24 +00001580static const unsigned NVPTXAddrSpaceMap[] = {
1581 1, // opencl_global
1582 3, // opencl_local
1583 4, // opencl_constant
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +00001584 // FIXME: generic has to be added to the target
Eric Christopherc48497a2015-09-18 21:26:24 +00001585 0, // opencl_generic
1586 1, // cuda_device
1587 4, // cuda_constant
1588 3, // cuda_shared
1589};
1590
1591class NVPTXTargetInfo : public TargetInfo {
1592 static const char *const GCCRegNames[];
1593 static const Builtin::Info BuiltinInfo[];
Reid Klecknerbbc01782014-12-03 21:53:36 +00001594
1595 // The GPU profiles supported by the NVPTX backend
1596 enum GPUKind {
1597 GK_NONE,
1598 GK_SM20,
1599 GK_SM21,
1600 GK_SM30,
1601 GK_SM35,
Eli Bendersky7a0d8912015-03-31 17:03:16 +00001602 GK_SM37,
Reid Klecknerbbc01782014-12-03 21:53:36 +00001603 } GPU;
1604
Eric Christopherc48497a2015-09-18 21:26:24 +00001605public:
1606 NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
1607 BigEndian = false;
1608 TLSSupported = false;
1609 LongWidth = LongAlign = 64;
1610 AddrSpaceMap = &NVPTXAddrSpaceMap;
1611 UseAddrSpaceMapMangling = true;
1612 // Define available target features
1613 // These must be defined in sorted order!
1614 NoAsmVariants = true;
1615 // Set the default GPU to sm20
1616 GPU = GK_SM20;
1617 }
1618 void getTargetDefines(const LangOptions &Opts,
1619 MacroBuilder &Builder) const override {
1620 Builder.defineMacro("__PTX__");
1621 Builder.defineMacro("__NVPTX__");
1622 if (Opts.CUDAIsDevice) {
1623 // Set __CUDA_ARCH__ for the GPU specified.
1624 std::string CUDAArchCode;
1625 switch (GPU) {
1626 case GK_SM20:
1627 CUDAArchCode = "200";
1628 break;
1629 case GK_SM21:
1630 CUDAArchCode = "210";
1631 break;
1632 case GK_SM30:
1633 CUDAArchCode = "300";
1634 break;
1635 case GK_SM35:
1636 CUDAArchCode = "350";
1637 break;
1638 case GK_SM37:
1639 CUDAArchCode = "370";
1640 break;
1641 default:
1642 llvm_unreachable("Unhandled target CPU");
Reid Klecknerbbc01782014-12-03 21:53:36 +00001643 }
Eric Christopherc48497a2015-09-18 21:26:24 +00001644 Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
Peter Collingbournec947aae2012-05-20 23:28:41 +00001645 }
Eric Christopherc48497a2015-09-18 21:26:24 +00001646 }
Craig Topper6c03a542015-10-19 04:51:35 +00001647 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
1648 return llvm::makeArrayRef(BuiltinInfo,
1649 clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
Eric Christopherc48497a2015-09-18 21:26:24 +00001650 }
1651 bool hasFeature(StringRef Feature) const override {
1652 return Feature == "ptx" || Feature == "nvptx";
Peter Collingbournec947aae2012-05-20 23:28:41 +00001653 }
1654
Craig Topperf054e3a2015-10-19 03:52:27 +00001655 ArrayRef<const char *> getGCCRegNames() const override;
1656 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00001657 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00001658 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00001659 }
1660 bool validateAsmConstraint(const char *&Name,
1661 TargetInfo::ConstraintInfo &Info) const override {
1662 switch (*Name) {
1663 default:
1664 return false;
1665 case 'c':
1666 case 'h':
1667 case 'r':
1668 case 'l':
1669 case 'f':
1670 case 'd':
1671 Info.setAllowsRegister();
1672 return true;
Eli Bendersky13467172015-04-01 20:29:18 +00001673 }
Eric Christopherc48497a2015-09-18 21:26:24 +00001674 }
1675 const char *getClobbers() const override {
1676 // FIXME: Is this really right?
1677 return "";
1678 }
1679 BuiltinVaListKind getBuiltinVaListKind() const override {
1680 // FIXME: implement
1681 return TargetInfo::CharPtrBuiltinVaList;
1682 }
1683 bool setCPU(const std::string &Name) override {
1684 GPU = llvm::StringSwitch<GPUKind>(Name)
1685 .Case("sm_20", GK_SM20)
1686 .Case("sm_21", GK_SM21)
1687 .Case("sm_30", GK_SM30)
1688 .Case("sm_35", GK_SM35)
1689 .Case("sm_37", GK_SM37)
1690 .Default(GK_NONE);
Peter Collingbournec947aae2012-05-20 23:28:41 +00001691
Eric Christopherc48497a2015-09-18 21:26:24 +00001692 return GPU != GK_NONE;
1693 }
1694};
1695
1696const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
1697#define BUILTIN(ID, TYPE, ATTRS) \
1698 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1699#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1700 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
1701#include "clang/Basic/BuiltinsNVPTX.def"
1702};
1703
1704const char *const NVPTXTargetInfo::GCCRegNames[] = {"r0"};
1705
Craig Topperf054e3a2015-10-19 03:52:27 +00001706ArrayRef<const char *> NVPTXTargetInfo::getGCCRegNames() const {
1707 return llvm::makeArrayRef(GCCRegNames);
Eric Christopherc48497a2015-09-18 21:26:24 +00001708}
1709
1710class NVPTX32TargetInfo : public NVPTXTargetInfo {
1711public:
1712 NVPTX32TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
Artem Belevich236cfdc2015-09-28 22:54:08 +00001713 LongWidth = LongAlign = 32;
Eric Christopherc48497a2015-09-18 21:26:24 +00001714 PointerWidth = PointerAlign = 32;
1715 SizeType = TargetInfo::UnsignedInt;
1716 PtrDiffType = TargetInfo::SignedInt;
1717 IntPtrType = TargetInfo::SignedInt;
1718 DataLayoutString = "e-p:32:32-i64:64-v16:16-v32:32-n16:32:64";
1719 }
1720};
1721
1722class NVPTX64TargetInfo : public NVPTXTargetInfo {
1723public:
1724 NVPTX64TargetInfo(const llvm::Triple &Triple) : NVPTXTargetInfo(Triple) {
1725 PointerWidth = PointerAlign = 64;
1726 SizeType = TargetInfo::UnsignedLong;
1727 PtrDiffType = TargetInfo::SignedLong;
1728 IntPtrType = TargetInfo::SignedLong;
1729 DataLayoutString = "e-i64:64-v16:16-v32:32-n16:32:64";
1730 }
1731};
Eli Friedmand13b41e2012-10-12 23:32:00 +00001732
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001733static const unsigned AMDGPUAddrSpaceMap[] = {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001734 1, // opencl_global
1735 3, // opencl_local
1736 2, // opencl_constant
Matt Arsenaultbfe25b22014-12-01 16:46:03 +00001737 4, // opencl_generic
Eli Friedmand13b41e2012-10-12 23:32:00 +00001738 1, // cuda_device
1739 2, // cuda_constant
1740 3 // cuda_shared
1741};
1742
Tom Stellarda96344b2014-08-21 13:58:40 +00001743// If you edit the description strings, make sure you update
1744// getPointerWidthV().
1745
Craig Topper273dbc62015-10-18 05:29:26 +00001746static const char *const DataLayoutStringR600 =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001747 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1748 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001749
Craig Topper273dbc62015-10-18 05:29:26 +00001750static const char *const DataLayoutStringR600DoubleOps =
Rafael Espindola29db13a2014-01-03 18:13:17 +00001751 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1752 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001753
Craig Topper273dbc62015-10-18 05:29:26 +00001754static const char *const DataLayoutStringSI =
Matt Arsenault23e7b082014-05-22 18:33:55 +00001755 "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 +00001756 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
1757 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00001758
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001759class AMDGPUTargetInfo : public TargetInfo {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001760 static const Builtin::Info BuiltinInfo[];
Tom Stellard7b1059b2015-04-14 14:36:56 +00001761 static const char * const GCCRegNames[];
Matt Arsenault56f008d2014-06-24 20:45:01 +00001762
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001763 /// \brief The GPU profiles supported by the AMDGPU target.
Tom Stellardc74b1e02013-03-04 17:40:53 +00001764 enum GPUKind {
1765 GK_NONE,
1766 GK_R600,
1767 GK_R600_DOUBLE_OPS,
1768 GK_R700,
1769 GK_R700_DOUBLE_OPS,
1770 GK_EVERGREEN,
1771 GK_EVERGREEN_DOUBLE_OPS,
1772 GK_NORTHERN_ISLANDS,
1773 GK_CAYMAN,
Tom Stellard08ded122013-10-29 16:38:29 +00001774 GK_SOUTHERN_ISLANDS,
Tom Stellard5c384402015-06-18 19:14:15 +00001775 GK_SEA_ISLANDS,
1776 GK_VOLCANIC_ISLANDS
Tom Stellardc74b1e02013-03-04 17:40:53 +00001777 } GPU;
1778
Jan Veselyeebeaea2015-05-04 19:53:36 +00001779 bool hasFP64:1;
1780 bool hasFMAF:1;
1781 bool hasLDEXPF:1;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001782
Eli Friedmand13b41e2012-10-12 23:32:00 +00001783public:
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001784 AMDGPUTargetInfo(const llvm::Triple &Triple)
1785 : TargetInfo(Triple) {
Tom Stellardd99fb952015-01-28 15:38:44 +00001786
1787 if (Triple.getArch() == llvm::Triple::amdgcn) {
Eric Christopher964a5f32015-08-05 23:48:05 +00001788 DataLayoutString = DataLayoutStringSI;
Tom Stellardd99fb952015-01-28 15:38:44 +00001789 GPU = GK_SOUTHERN_ISLANDS;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001790 hasFP64 = true;
Jan Veselyeebeaea2015-05-04 19:53:36 +00001791 hasFMAF = true;
1792 hasLDEXPF = true;
Tom Stellardd99fb952015-01-28 15:38:44 +00001793 } else {
Eric Christopher964a5f32015-08-05 23:48:05 +00001794 DataLayoutString = DataLayoutStringR600;
Tom Stellardd99fb952015-01-28 15:38:44 +00001795 GPU = GK_R600;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001796 hasFP64 = false;
Jan Veselyeebeaea2015-05-04 19:53:36 +00001797 hasFMAF = false;
1798 hasLDEXPF = false;
Tom Stellardd99fb952015-01-28 15:38:44 +00001799 }
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001800 AddrSpaceMap = &AMDGPUAddrSpaceMap;
David Tweed31d09b02013-09-13 12:04:22 +00001801 UseAddrSpaceMapMangling = true;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001802 }
1803
Tom Stellarda96344b2014-08-21 13:58:40 +00001804 uint64_t getPointerWidthV(unsigned AddrSpace) const override {
1805 if (GPU <= GK_CAYMAN)
1806 return 32;
1807
1808 switch(AddrSpace) {
1809 default:
1810 return 64;
1811 case 0:
1812 case 3:
1813 case 5:
1814 return 32;
1815 }
1816 }
1817
Craig Topper3164f332014-03-11 03:39:26 +00001818 const char * getClobbers() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001819 return "";
1820 }
1821
Craig Topperf054e3a2015-10-19 03:52:27 +00001822 ArrayRef<const char *> getGCCRegNames() const override;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001823
Craig Topperf054e3a2015-10-19 03:52:27 +00001824 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
1825 return None;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001826 }
1827
Craig Topper3164f332014-03-11 03:39:26 +00001828 bool validateAsmConstraint(const char *&Name,
Tom Stellardd097e942015-11-19 22:11:58 +00001829 TargetInfo::ConstraintInfo &Info) const override {
1830 switch (*Name) {
1831 default: break;
1832 case 'v': // vgpr
1833 case 's': // sgpr
1834 Info.setAllowsRegister();
1835 return true;
1836 }
1837 return false;
Eli Friedmand13b41e2012-10-12 23:32:00 +00001838 }
1839
Craig Topper6c03a542015-10-19 04:51:35 +00001840 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
1841 return llvm::makeArrayRef(BuiltinInfo,
1842 clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin);
Eli Friedmand13b41e2012-10-12 23:32:00 +00001843 }
1844
Craig Topper3164f332014-03-11 03:39:26 +00001845 void getTargetDefines(const LangOptions &Opts,
1846 MacroBuilder &Builder) const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001847 Builder.defineMacro("__R600__");
Jan Veselyeebeaea2015-05-04 19:53:36 +00001848 if (hasFMAF)
1849 Builder.defineMacro("__HAS_FMAF__");
1850 if (hasLDEXPF)
1851 Builder.defineMacro("__HAS_LDEXPF__");
Tom Stellard22041372015-07-17 13:16:52 +00001852 if (hasFP64 && Opts.OpenCL)
Tom Stellardfded50f2015-02-27 15:10:19 +00001853 Builder.defineMacro("cl_khr_fp64");
Tom Stellard22041372015-07-17 13:16:52 +00001854 if (Opts.OpenCL) {
1855 if (GPU >= GK_NORTHERN_ISLANDS) {
1856 Builder.defineMacro("cl_khr_byte_addressable_store");
1857 Builder.defineMacro("cl_khr_global_int32_base_atomics");
1858 Builder.defineMacro("cl_khr_global_int32_extended_atomics");
1859 Builder.defineMacro("cl_khr_local_int32_base_atomics");
1860 Builder.defineMacro("cl_khr_local_int32_extended_atomics");
1861 }
Jan Veselya3abd6d2015-05-01 17:38:13 +00001862 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001863 }
1864
Craig Topper3164f332014-03-11 03:39:26 +00001865 BuiltinVaListKind getBuiltinVaListKind() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00001866 return TargetInfo::CharPtrBuiltinVaList;
1867 }
1868
Craig Topper3164f332014-03-11 03:39:26 +00001869 bool setCPU(const std::string &Name) override {
Tom Stellardc74b1e02013-03-04 17:40:53 +00001870 GPU = llvm::StringSwitch<GPUKind>(Name)
1871 .Case("r600" , GK_R600)
1872 .Case("rv610", GK_R600)
1873 .Case("rv620", GK_R600)
1874 .Case("rv630", GK_R600)
1875 .Case("rv635", GK_R600)
1876 .Case("rs780", GK_R600)
1877 .Case("rs880", GK_R600)
1878 .Case("rv670", GK_R600_DOUBLE_OPS)
1879 .Case("rv710", GK_R700)
1880 .Case("rv730", GK_R700)
1881 .Case("rv740", GK_R700_DOUBLE_OPS)
1882 .Case("rv770", GK_R700_DOUBLE_OPS)
1883 .Case("palm", GK_EVERGREEN)
1884 .Case("cedar", GK_EVERGREEN)
1885 .Case("sumo", GK_EVERGREEN)
1886 .Case("sumo2", GK_EVERGREEN)
1887 .Case("redwood", GK_EVERGREEN)
1888 .Case("juniper", GK_EVERGREEN)
1889 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
1890 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
1891 .Case("barts", GK_NORTHERN_ISLANDS)
1892 .Case("turks", GK_NORTHERN_ISLANDS)
1893 .Case("caicos", GK_NORTHERN_ISLANDS)
1894 .Case("cayman", GK_CAYMAN)
1895 .Case("aruba", GK_CAYMAN)
Tom Stellard785699322013-04-01 20:56:49 +00001896 .Case("tahiti", GK_SOUTHERN_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001897 .Case("pitcairn", GK_SOUTHERN_ISLANDS)
1898 .Case("verde", GK_SOUTHERN_ISLANDS)
1899 .Case("oland", GK_SOUTHERN_ISLANDS)
Tom Stellard9affba42014-08-21 13:58:38 +00001900 .Case("hainan", GK_SOUTHERN_ISLANDS)
Tom Stellard08ded122013-10-29 16:38:29 +00001901 .Case("bonaire", GK_SEA_ISLANDS)
1902 .Case("kabini", GK_SEA_ISLANDS)
1903 .Case("kaveri", GK_SEA_ISLANDS)
Tom Stellard55583042013-11-14 23:45:53 +00001904 .Case("hawaii", GK_SEA_ISLANDS)
Tom Stellard14e03962014-07-26 01:05:20 +00001905 .Case("mullins", GK_SEA_ISLANDS)
Tom Stellard5c384402015-06-18 19:14:15 +00001906 .Case("tonga", GK_VOLCANIC_ISLANDS)
1907 .Case("iceland", GK_VOLCANIC_ISLANDS)
1908 .Case("carrizo", GK_VOLCANIC_ISLANDS)
Tom Stellardc74b1e02013-03-04 17:40:53 +00001909 .Default(GK_NONE);
1910
1911 if (GPU == GK_NONE) {
1912 return false;
1913 }
1914
1915 // Set the correct data layout
1916 switch (GPU) {
1917 case GK_NONE:
1918 case GK_R600:
1919 case GK_R700:
1920 case GK_EVERGREEN:
1921 case GK_NORTHERN_ISLANDS:
Eric Christopher964a5f32015-08-05 23:48:05 +00001922 DataLayoutString = DataLayoutStringR600;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001923 hasFP64 = false;
Jan Veselyeebeaea2015-05-04 19:53:36 +00001924 hasFMAF = false;
1925 hasLDEXPF = false;
Tom Stellardc74b1e02013-03-04 17:40:53 +00001926 break;
1927 case GK_R600_DOUBLE_OPS:
1928 case GK_R700_DOUBLE_OPS:
1929 case GK_EVERGREEN_DOUBLE_OPS:
1930 case GK_CAYMAN:
Eric Christopher964a5f32015-08-05 23:48:05 +00001931 DataLayoutString = DataLayoutStringR600DoubleOps;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001932 hasFP64 = true;
Jan Veselyeebeaea2015-05-04 19:53:36 +00001933 hasFMAF = true;
1934 hasLDEXPF = false;
Tom Stellardc74b1e02013-03-04 17:40:53 +00001935 break;
1936 case GK_SOUTHERN_ISLANDS:
Tom Stellard08ded122013-10-29 16:38:29 +00001937 case GK_SEA_ISLANDS:
Tom Stellard64e0dd02015-06-18 21:13:29 +00001938 case GK_VOLCANIC_ISLANDS:
Eric Christopher964a5f32015-08-05 23:48:05 +00001939 DataLayoutString = DataLayoutStringSI;
Jan Veselya3abd6d2015-05-01 17:38:13 +00001940 hasFP64 = true;
Jan Veselyeebeaea2015-05-04 19:53:36 +00001941 hasFMAF = true;
1942 hasLDEXPF = true;
Tom Stellardc74b1e02013-03-04 17:40:53 +00001943 break;
1944 }
1945
1946 return true;
1947 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00001948};
1949
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001950const Builtin::Info AMDGPUTargetInfo::BuiltinInfo[] = {
Matt Arsenault56f008d2014-06-24 20:45:01 +00001951#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00001952 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001953#include "clang/Basic/BuiltinsAMDGPU.def"
Matt Arsenault56f008d2014-06-24 20:45:01 +00001954};
Matt Arsenault3ea39f92015-06-19 17:54:10 +00001955const char * const AMDGPUTargetInfo::GCCRegNames[] = {
Tom Stellard7b1059b2015-04-14 14:36:56 +00001956 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1957 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1958 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1959 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
1960 "v32", "v33", "v34", "v35", "v36", "v37", "v38", "v39",
1961 "v40", "v41", "v42", "v43", "v44", "v45", "v46", "v47",
1962 "v48", "v49", "v50", "v51", "v52", "v53", "v54", "v55",
1963 "v56", "v57", "v58", "v59", "v60", "v61", "v62", "v63",
1964 "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71",
1965 "v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79",
1966 "v80", "v81", "v82", "v83", "v84", "v85", "v86", "v87",
1967 "v88", "v89", "v90", "v91", "v92", "v93", "v94", "v95",
1968 "v96", "v97", "v98", "v99", "v100", "v101", "v102", "v103",
1969 "v104", "v105", "v106", "v107", "v108", "v109", "v110", "v111",
1970 "v112", "v113", "v114", "v115", "v116", "v117", "v118", "v119",
1971 "v120", "v121", "v122", "v123", "v124", "v125", "v126", "v127",
1972 "v128", "v129", "v130", "v131", "v132", "v133", "v134", "v135",
1973 "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143",
1974 "v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151",
1975 "v152", "v153", "v154", "v155", "v156", "v157", "v158", "v159",
1976 "v160", "v161", "v162", "v163", "v164", "v165", "v166", "v167",
1977 "v168", "v169", "v170", "v171", "v172", "v173", "v174", "v175",
1978 "v176", "v177", "v178", "v179", "v180", "v181", "v182", "v183",
1979 "v184", "v185", "v186", "v187", "v188", "v189", "v190", "v191",
1980 "v192", "v193", "v194", "v195", "v196", "v197", "v198", "v199",
1981 "v200", "v201", "v202", "v203", "v204", "v205", "v206", "v207",
1982 "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215",
1983 "v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223",
1984 "v224", "v225", "v226", "v227", "v228", "v229", "v230", "v231",
1985 "v232", "v233", "v234", "v235", "v236", "v237", "v238", "v239",
1986 "v240", "v241", "v242", "v243", "v244", "v245", "v246", "v247",
1987 "v248", "v249", "v250", "v251", "v252", "v253", "v254", "v255",
1988 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
1989 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
1990 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
1991 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
1992 "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
1993 "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
1994 "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
1995 "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
1996 "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
1997 "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
1998 "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
1999 "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
2000 "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
2001 "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
2002 "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
2003 "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127"
2004 "exec", "vcc", "scc", "m0", "flat_scr", "exec_lo", "exec_hi",
2005 "vcc_lo", "vcc_hi", "flat_scr_lo", "flat_scr_hi"
2006};
2007
Craig Topperf054e3a2015-10-19 03:52:27 +00002008ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const {
2009 return llvm::makeArrayRef(GCCRegNames);
Tom Stellard7b1059b2015-04-14 14:36:56 +00002010}
Matt Arsenault56f008d2014-06-24 20:45:01 +00002011
Eli Friedman3fd920a2008-08-20 02:34:37 +00002012// Namespace for x86 abstract base class
2013const Builtin::Info BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00002014#define BUILTIN(ID, TYPE, ATTRS) \
2015 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Eric Christopherb6dfd942015-08-06 22:11:54 +00002016#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
Craig Topper07d3b622015-08-07 05:14:44 +00002017 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Eric Christopherb6dfd942015-08-06 22:11:54 +00002018#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
Craig Topper07d3b622015-08-07 05:14:44 +00002019 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Chris Lattner5abdec72009-06-14 01:05:48 +00002020#include "clang/Basic/BuiltinsX86.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00002021};
Eli Friedmanb5366062008-05-20 14:21:01 +00002022
Nuno Lopescfca1f02009-12-23 17:49:57 +00002023static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002024 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
2025 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00002026 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00002027 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
2028 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
2029 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00002030 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00002031 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
2032 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Eli Friedman3fd920a2008-08-20 02:34:37 +00002033};
2034
Eric Christophercdd36352011-06-21 00:05:20 +00002035const TargetInfo::AddlRegName AddlRegNames[] = {
2036 { { "al", "ah", "eax", "rax" }, 0 },
2037 { { "bl", "bh", "ebx", "rbx" }, 3 },
2038 { { "cl", "ch", "ecx", "rcx" }, 2 },
2039 { { "dl", "dh", "edx", "rdx" }, 1 },
2040 { { "esi", "rsi" }, 4 },
2041 { { "edi", "rdi" }, 5 },
2042 { { "esp", "rsp" }, 7 },
2043 { { "ebp", "rbp" }, 6 },
Alexey Bataeva7ab1b42015-09-04 03:42:23 +00002044 { { "r8d", "r8w", "r8b" }, 38 },
2045 { { "r9d", "r9w", "r9b" }, 39 },
2046 { { "r10d", "r10w", "r10b" }, 40 },
2047 { { "r11d", "r11w", "r11b" }, 41 },
2048 { { "r12d", "r12w", "r12b" }, 42 },
2049 { { "r13d", "r13w", "r13b" }, 43 },
2050 { { "r14d", "r14w", "r14b" }, 44 },
2051 { { "r15d", "r15w", "r15b" }, 45 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00002052};
2053
2054// X86 target abstract base class; x86-32 and x86-64 are very close, so
2055// most of the implementation can be shared.
2056class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00002057 enum X86SSEEnum {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002058 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Craig Topper543f3bd2015-10-14 23:47:57 +00002059 } SSELevel = NoSSE;
Eli Friedman33465822011-07-08 23:31:17 +00002060 enum MMX3DNowEnum {
2061 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
Craig Topper543f3bd2015-10-14 23:47:57 +00002062 } MMX3DNowLevel = NoMMX3DNow;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002063 enum XOPEnum {
2064 NoXOP,
2065 SSE4A,
2066 FMA4,
2067 XOP
Craig Topper543f3bd2015-10-14 23:47:57 +00002068 } XOPLevel = NoXOP;
Anders Carlssone437c682010-01-27 03:47:49 +00002069
Craig Topper543f3bd2015-10-14 23:47:57 +00002070 bool HasAES = false;
2071 bool HasPCLMUL = false;
2072 bool HasLZCNT = false;
2073 bool HasRDRND = false;
2074 bool HasFSGSBASE = false;
2075 bool HasBMI = false;
2076 bool HasBMI2 = false;
2077 bool HasPOPCNT = false;
2078 bool HasRTM = false;
2079 bool HasPRFCHW = false;
2080 bool HasRDSEED = false;
2081 bool HasADX = false;
2082 bool HasTBM = false;
2083 bool HasFMA = false;
2084 bool HasF16C = false;
2085 bool HasAVX512CD = false;
2086 bool HasAVX512ER = false;
2087 bool HasAVX512PF = false;
2088 bool HasAVX512DQ = false;
2089 bool HasAVX512BW = false;
2090 bool HasAVX512VL = false;
2091 bool HasSHA = false;
2092 bool HasCX16 = false;
Craig Toppere33f51f2015-10-16 06:22:36 +00002093 bool HasFXSR = false;
Craig Topperda9fe562015-10-15 05:23:38 +00002094 bool HasXSAVE = false;
2095 bool HasXSAVEOPT = false;
2096 bool HasXSAVEC = false;
2097 bool HasXSAVES = false;
Asaf Badouha9d1e182015-12-31 14:14:07 +00002098 bool HasPKU = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00002099
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002100 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
2101 ///
2102 /// Each enumeration represents a particular CPU supported by Clang. These
2103 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
2104 enum CPUKind {
2105 CK_Generic,
2106
2107 /// \name i386
2108 /// i386-generation processors.
2109 //@{
2110 CK_i386,
2111 //@}
2112
2113 /// \name i486
2114 /// i486-generation processors.
2115 //@{
2116 CK_i486,
2117 CK_WinChipC6,
2118 CK_WinChip2,
2119 CK_C3,
2120 //@}
2121
2122 /// \name i586
2123 /// i586-generation processors, P5 microarchitecture based.
2124 //@{
2125 CK_i586,
2126 CK_Pentium,
2127 CK_PentiumMMX,
2128 //@}
2129
2130 /// \name i686
2131 /// i686-generation processors, P6 / Pentium M microarchitecture based.
2132 //@{
2133 CK_i686,
2134 CK_PentiumPro,
2135 CK_Pentium2,
2136 CK_Pentium3,
2137 CK_Pentium3M,
2138 CK_PentiumM,
2139 CK_C3_2,
2140
2141 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
2142 /// Clang however has some logic to suport this.
2143 // FIXME: Warn, deprecate, and potentially remove this.
2144 CK_Yonah,
2145 //@}
2146
2147 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00002148 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002149 //@{
2150 CK_Pentium4,
2151 CK_Pentium4M,
2152 CK_Prescott,
2153 CK_Nocona,
2154 //@}
2155
2156 /// \name Core
2157 /// Core microarchitecture based processors.
2158 //@{
2159 CK_Core2,
2160
2161 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
2162 /// codename which GCC no longer accepts as an option to -march, but Clang
2163 /// has some logic for recognizing it.
2164 // FIXME: Warn, deprecate, and potentially remove this.
2165 CK_Penryn,
2166 //@}
2167
2168 /// \name Atom
2169 /// Atom processors
2170 //@{
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002171 CK_Bonnell,
Preston Gurda3c58c02013-09-13 19:27:17 +00002172 CK_Silvermont,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002173 //@}
2174
2175 /// \name Nehalem
2176 /// Nehalem microarchitecture based processors.
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002177 CK_Nehalem,
2178
2179 /// \name Westmere
2180 /// Westmere microarchitecture based processors.
2181 CK_Westmere,
2182
2183 /// \name Sandy Bridge
2184 /// Sandy Bridge microarchitecture based processors.
2185 CK_SandyBridge,
2186
2187 /// \name Ivy Bridge
2188 /// Ivy Bridge microarchitecture based processors.
2189 CK_IvyBridge,
2190
2191 /// \name Haswell
2192 /// Haswell microarchitecture based processors.
2193 CK_Haswell,
2194
2195 /// \name Broadwell
2196 /// Broadwell microarchitecture based processors.
Robert Khasanov50e6f582014-09-19 09:53:48 +00002197 CK_Broadwell,
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002198
2199 /// \name Skylake
2200 /// Skylake microarchitecture based processors.
2201 CK_Skylake,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002202
Craig Topper449314e2013-08-20 07:09:39 +00002203 /// \name Knights Landing
2204 /// Knights Landing processor.
2205 CK_KNL,
2206
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002207 /// \name K6
2208 /// K6 architecture processors.
2209 //@{
2210 CK_K6,
2211 CK_K6_2,
2212 CK_K6_3,
2213 //@}
2214
2215 /// \name K7
2216 /// K7 architecture processors.
2217 //@{
2218 CK_Athlon,
2219 CK_AthlonThunderbird,
2220 CK_Athlon4,
2221 CK_AthlonXP,
2222 CK_AthlonMP,
2223 //@}
2224
2225 /// \name K8
2226 /// K8 architecture processors.
2227 //@{
2228 CK_Athlon64,
2229 CK_Athlon64SSE3,
2230 CK_AthlonFX,
2231 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00002232 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002233 CK_Opteron,
2234 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00002235 CK_AMDFAM10,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002236 //@}
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002237
Benjamin Kramer569f2152012-01-10 11:50:18 +00002238 /// \name Bobcat
2239 /// Bobcat architecture processors.
2240 //@{
2241 CK_BTVER1,
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002242 CK_BTVER2,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002243 //@}
2244
2245 /// \name Bulldozer
2246 /// Bulldozer architecture processors.
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002247 //@{
2248 CK_BDVER1,
2249 CK_BDVER2,
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002250 CK_BDVER3,
Benjamin Kramer56c58222014-05-02 15:47:51 +00002251 CK_BDVER4,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002252 //@}
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002253
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002254 /// This specification is deprecated and will be removed in the future.
2255 /// Users should prefer \see CK_K8.
2256 // FIXME: Warn on this when the CPU is set to it.
Saleem Abdulrasoolcb29c1a2014-11-17 18:40:15 +00002257 //@{
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002258 CK_x86_64,
2259 //@}
2260
2261 /// \name Geode
2262 /// Geode processors.
2263 //@{
2264 CK_Geode
2265 //@}
Craig Topper543f3bd2015-10-14 23:47:57 +00002266 } CPU = CK_Generic;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002267
Eric Christopherc50738f2015-08-27 00:05:50 +00002268 CPUKind getCPUKind(StringRef CPU) const {
Eric Christopherb39e44b2015-08-26 23:42:18 +00002269 return llvm::StringSwitch<CPUKind>(CPU)
2270 .Case("i386", CK_i386)
2271 .Case("i486", CK_i486)
2272 .Case("winchip-c6", CK_WinChipC6)
2273 .Case("winchip2", CK_WinChip2)
2274 .Case("c3", CK_C3)
2275 .Case("i586", CK_i586)
2276 .Case("pentium", CK_Pentium)
2277 .Case("pentium-mmx", CK_PentiumMMX)
2278 .Case("i686", CK_i686)
2279 .Case("pentiumpro", CK_PentiumPro)
2280 .Case("pentium2", CK_Pentium2)
2281 .Case("pentium3", CK_Pentium3)
2282 .Case("pentium3m", CK_Pentium3M)
2283 .Case("pentium-m", CK_PentiumM)
2284 .Case("c3-2", CK_C3_2)
2285 .Case("yonah", CK_Yonah)
2286 .Case("pentium4", CK_Pentium4)
2287 .Case("pentium4m", CK_Pentium4M)
2288 .Case("prescott", CK_Prescott)
2289 .Case("nocona", CK_Nocona)
2290 .Case("core2", CK_Core2)
2291 .Case("penryn", CK_Penryn)
2292 .Case("bonnell", CK_Bonnell)
2293 .Case("atom", CK_Bonnell) // Legacy name.
2294 .Case("silvermont", CK_Silvermont)
2295 .Case("slm", CK_Silvermont) // Legacy name.
2296 .Case("nehalem", CK_Nehalem)
2297 .Case("corei7", CK_Nehalem) // Legacy name.
2298 .Case("westmere", CK_Westmere)
2299 .Case("sandybridge", CK_SandyBridge)
2300 .Case("corei7-avx", CK_SandyBridge) // Legacy name.
2301 .Case("ivybridge", CK_IvyBridge)
2302 .Case("core-avx-i", CK_IvyBridge) // Legacy name.
2303 .Case("haswell", CK_Haswell)
2304 .Case("core-avx2", CK_Haswell) // Legacy name.
2305 .Case("broadwell", CK_Broadwell)
2306 .Case("skylake", CK_Skylake)
2307 .Case("skx", CK_Skylake) // Legacy name.
2308 .Case("knl", CK_KNL)
2309 .Case("k6", CK_K6)
2310 .Case("k6-2", CK_K6_2)
2311 .Case("k6-3", CK_K6_3)
2312 .Case("athlon", CK_Athlon)
2313 .Case("athlon-tbird", CK_AthlonThunderbird)
2314 .Case("athlon-4", CK_Athlon4)
2315 .Case("athlon-xp", CK_AthlonXP)
2316 .Case("athlon-mp", CK_AthlonMP)
2317 .Case("athlon64", CK_Athlon64)
2318 .Case("athlon64-sse3", CK_Athlon64SSE3)
2319 .Case("athlon-fx", CK_AthlonFX)
2320 .Case("k8", CK_K8)
2321 .Case("k8-sse3", CK_K8SSE3)
2322 .Case("opteron", CK_Opteron)
2323 .Case("opteron-sse3", CK_OpteronSSE3)
2324 .Case("barcelona", CK_AMDFAM10)
2325 .Case("amdfam10", CK_AMDFAM10)
2326 .Case("btver1", CK_BTVER1)
2327 .Case("btver2", CK_BTVER2)
2328 .Case("bdver1", CK_BDVER1)
2329 .Case("bdver2", CK_BDVER2)
2330 .Case("bdver3", CK_BDVER3)
2331 .Case("bdver4", CK_BDVER4)
2332 .Case("x86-64", CK_x86_64)
2333 .Case("geode", CK_Geode)
2334 .Default(CK_Generic);
2335 }
2336
Rafael Espindolaeb265472013-08-21 21:59:03 +00002337 enum FPMathKind {
2338 FP_Default,
2339 FP_SSE,
2340 FP_387
Craig Topper543f3bd2015-10-14 23:47:57 +00002341 } FPMath = FP_Default;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002342
Eli Friedman3fd920a2008-08-20 02:34:37 +00002343public:
Craig Topper543f3bd2015-10-14 23:47:57 +00002344 X86TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00002345 BigEndian = false;
Andrey Bokhanko94e1d582015-11-05 12:43:09 +00002346 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
Chris Lattner1f5ad112006-10-14 18:32:12 +00002347 }
Craig Topper3164f332014-03-11 03:39:26 +00002348 unsigned getFloatEvalMethod() const override {
Benjamin Kramercf501472011-12-28 15:47:06 +00002349 // X87 evaluates with 80 bits "long double" precision.
2350 return SSELevel == NoSSE ? 2 : 0;
2351 }
Craig Topper6c03a542015-10-19 04:51:35 +00002352 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
2353 return llvm::makeArrayRef(BuiltinInfo,
2354 clang::X86::LastTSBuiltin-Builtin::FirstTSBuiltin);
Chris Lattner10a5b382007-01-29 05:24:35 +00002355 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002356 ArrayRef<const char *> getGCCRegNames() const override {
2357 return llvm::makeArrayRef(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00002358 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002359 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
2360 return None;
Eric Christophercdd36352011-06-21 00:05:20 +00002361 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002362 ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override {
2363 return llvm::makeArrayRef(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00002364 }
Eric Christopherd9832702015-06-29 21:00:05 +00002365 bool validateCpuSupports(StringRef Name) const override;
Craig Topper3164f332014-03-11 03:39:26 +00002366 bool validateAsmConstraint(const char *&Name,
Eric Christopher917e9522014-11-18 22:36:15 +00002367 TargetInfo::ConstraintInfo &info) const override;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002368
Akira Hatanaka8c26ea62015-11-18 00:15:28 +00002369 bool validateGlobalRegisterVariable(StringRef RegName,
2370 unsigned RegSize,
2371 bool &HasSizeMismatch) const override {
2372 // esp and ebp are the only 32-bit registers the x86 backend can currently
2373 // handle.
2374 if (RegName.equals("esp") || RegName.equals("ebp")) {
2375 // Check that the register size is 32-bit.
2376 HasSizeMismatch = RegSize != 32;
2377 return true;
2378 }
2379
2380 return false;
2381 }
2382
Akira Hatanaka974131e2014-09-18 18:17:18 +00002383 bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
2384
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002385 bool validateInputSize(StringRef Constraint, unsigned Size) const override;
2386
Akira Hatanaka974131e2014-09-18 18:17:18 +00002387 virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
2388
Craig Topper3164f332014-03-11 03:39:26 +00002389 std::string convertConstraint(const char *&Constraint) const override;
2390 const char *getClobbers() const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002391 return "~{dirflag},~{fpsr},~{flags}";
2392 }
Craig Topper3164f332014-03-11 03:39:26 +00002393 void getTargetDefines(const LangOptions &Opts,
2394 MacroBuilder &Builder) const override;
Craig Topper13f61a62013-09-17 04:12:55 +00002395 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
2396 bool Enabled);
2397 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
2398 bool Enabled);
2399 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
2400 bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00002401 void setFeatureEnabled(llvm::StringMap<bool> &Features,
2402 StringRef Name, bool Enabled) const override {
Craig Topper86d79ef2013-09-17 04:51:29 +00002403 setFeatureEnabledImpl(Features, Name, Enabled);
2404 }
2405 // This exists purely to cut down on the number of virtual calls in
Eric Christopheref1e2952015-08-28 02:13:58 +00002406 // initFeatureMap which calls this repeatedly.
Craig Topper86d79ef2013-09-17 04:51:29 +00002407 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2408 StringRef Name, bool Enabled);
Eric Christopher8c47b422015-10-09 18:39:55 +00002409 bool
2410 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
2411 StringRef CPU,
2412 const std::vector<std::string> &FeaturesVec) const override;
Craig Topper3164f332014-03-11 03:39:26 +00002413 bool hasFeature(StringRef Feature) const override;
2414 bool handleTargetFeatures(std::vector<std::string> &Features,
2415 DiagnosticsEngine &Diags) override;
Alp Toker4925ba72014-06-07 23:30:42 +00002416 StringRef getABI() const override {
Ahmed Bougacha0b938282015-06-22 21:31:43 +00002417 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX512F)
2418 return "avx512";
Craig Topperd945d502015-10-20 00:00:17 +00002419 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00002420 return "avx";
Craig Topperd945d502015-10-20 00:00:17 +00002421 if (getTriple().getArch() == llvm::Triple::x86 &&
Derek Schuffc7dd7222012-10-11 15:52:22 +00002422 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00002423 return "no-mmx";
2424 return "";
Eli Friedman33465822011-07-08 23:31:17 +00002425 }
Craig Topper3164f332014-03-11 03:39:26 +00002426 bool setCPU(const std::string &Name) override {
Eric Christopherb39e44b2015-08-26 23:42:18 +00002427 CPU = getCPUKind(Name);
Chandler Carruth212334f2011-09-28 08:55:37 +00002428
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002429 // Perform any per-CPU checks necessary to determine if this CPU is
2430 // acceptable.
2431 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
2432 // invalid without explaining *why*.
2433 switch (CPU) {
2434 case CK_Generic:
2435 // No processor selected!
2436 return false;
2437
2438 case CK_i386:
2439 case CK_i486:
2440 case CK_WinChipC6:
2441 case CK_WinChip2:
2442 case CK_C3:
2443 case CK_i586:
2444 case CK_Pentium:
2445 case CK_PentiumMMX:
2446 case CK_i686:
2447 case CK_PentiumPro:
2448 case CK_Pentium2:
2449 case CK_Pentium3:
2450 case CK_Pentium3M:
2451 case CK_PentiumM:
2452 case CK_Yonah:
2453 case CK_C3_2:
2454 case CK_Pentium4:
2455 case CK_Pentium4M:
2456 case CK_Prescott:
2457 case CK_K6:
2458 case CK_K6_2:
2459 case CK_K6_3:
2460 case CK_Athlon:
2461 case CK_AthlonThunderbird:
2462 case CK_Athlon4:
2463 case CK_AthlonXP:
2464 case CK_AthlonMP:
2465 case CK_Geode:
2466 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002467 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002468 return false;
2469
2470 // Fallthrough
2471 case CK_Nocona:
2472 case CK_Core2:
2473 case CK_Penryn:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002474 case CK_Bonnell:
Preston Gurda3c58c02013-09-13 19:27:17 +00002475 case CK_Silvermont:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002476 case CK_Nehalem:
2477 case CK_Westmere:
2478 case CK_SandyBridge:
2479 case CK_IvyBridge:
2480 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00002481 case CK_Broadwell:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002482 case CK_Skylake:
Craig Topper449314e2013-08-20 07:09:39 +00002483 case CK_KNL:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002484 case CK_Athlon64:
2485 case CK_Athlon64SSE3:
2486 case CK_AthlonFX:
2487 case CK_K8:
2488 case CK_K8SSE3:
2489 case CK_Opteron:
2490 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00002491 case CK_AMDFAM10:
Benjamin Kramer569f2152012-01-10 11:50:18 +00002492 case CK_BTVER1:
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002493 case CK_BTVER2:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002494 case CK_BDVER1:
2495 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002496 case CK_BDVER3:
Benjamin Kramer56c58222014-05-02 15:47:51 +00002497 case CK_BDVER4:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00002498 case CK_x86_64:
2499 return true;
2500 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00002501 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00002502 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002503
Craig Topper3164f332014-03-11 03:39:26 +00002504 bool setFPMath(StringRef Name) override;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002505
Craig Topper3164f332014-03-11 03:39:26 +00002506 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002507 // We accept all non-ARM calling conventions
2508 return (CC == CC_X86ThisCall ||
2509 CC == CC_X86FastCall ||
Reid Klecknerd7857f02014-10-24 17:42:17 +00002510 CC == CC_X86StdCall ||
2511 CC == CC_X86VectorCall ||
2512 CC == CC_C ||
Guy Benyeif0a014b2012-12-25 08:53:55 +00002513 CC == CC_X86Pascal ||
2514 CC == CC_IntelOclBicc) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002515 }
2516
Craig Topper3164f332014-03-11 03:39:26 +00002517 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00002518 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00002519 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +00002520
2521 bool hasSjLjLowering() const override {
2522 return true;
2523 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00002524};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00002525
Rafael Espindolaeb265472013-08-21 21:59:03 +00002526bool X86TargetInfo::setFPMath(StringRef Name) {
2527 if (Name == "387") {
2528 FPMath = FP_387;
2529 return true;
2530 }
2531 if (Name == "sse") {
2532 FPMath = FP_SSE;
2533 return true;
2534 }
2535 return false;
2536}
2537
Eric Christopher007b0a02015-08-28 22:32:01 +00002538bool X86TargetInfo::initFeatureMap(
2539 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
Eric Christopher8c47b422015-10-09 18:39:55 +00002540 const std::vector<std::string> &FeaturesVec) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002541 // FIXME: This *really* should not be here.
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002542 // X86_64 always has SSE2.
Derek Schuffc7dd7222012-10-11 15:52:22 +00002543 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper86d79ef2013-09-17 04:51:29 +00002544 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002545
Eric Christopher2b4a7252015-08-27 00:05:52 +00002546 switch (getCPUKind(CPU)) {
Chandler Carruth212334f2011-09-28 08:55:37 +00002547 case CK_Generic:
2548 case CK_i386:
2549 case CK_i486:
2550 case CK_i586:
2551 case CK_Pentium:
2552 case CK_i686:
2553 case CK_PentiumPro:
Chandler Carruth212334f2011-09-28 08:55:37 +00002554 break;
2555 case CK_PentiumMMX:
2556 case CK_Pentium2:
Craig Topperdb4dc082014-11-06 05:52:19 +00002557 case CK_K6:
2558 case CK_WinChipC6:
Craig Topper86d79ef2013-09-17 04:51:29 +00002559 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002560 break;
2561 case CK_Pentium3:
2562 case CK_Pentium3M:
Craig Topperdb4dc082014-11-06 05:52:19 +00002563 case CK_C3_2:
Craig Topper86d79ef2013-09-17 04:51:29 +00002564 setFeatureEnabledImpl(Features, "sse", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002565 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002566 break;
2567 case CK_PentiumM:
2568 case CK_Pentium4:
2569 case CK_Pentium4M:
2570 case CK_x86_64:
Craig Topper86d79ef2013-09-17 04:51:29 +00002571 setFeatureEnabledImpl(Features, "sse2", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002572 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002573 break;
2574 case CK_Yonah:
2575 case CK_Prescott:
2576 case CK_Nocona:
Craig Topper86d79ef2013-09-17 04:51:29 +00002577 setFeatureEnabledImpl(Features, "sse3", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002578 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002579 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002580 break;
2581 case CK_Core2:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002582 case CK_Bonnell:
Craig Topper86d79ef2013-09-17 04:51:29 +00002583 setFeatureEnabledImpl(Features, "ssse3", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002584 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002585 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002586 break;
2587 case CK_Penryn:
Craig Topper86d79ef2013-09-17 04:51:29 +00002588 setFeatureEnabledImpl(Features, "sse4.1", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002589 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002590 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002591 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002592 case CK_Skylake:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002593 setFeatureEnabledImpl(Features, "avx512f", true);
2594 setFeatureEnabledImpl(Features, "avx512cd", true);
2595 setFeatureEnabledImpl(Features, "avx512dq", true);
2596 setFeatureEnabledImpl(Features, "avx512bw", true);
2597 setFeatureEnabledImpl(Features, "avx512vl", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002598 setFeatureEnabledImpl(Features, "xsavec", true);
2599 setFeatureEnabledImpl(Features, "xsaves", true);
Asaf Badouha9d1e182015-12-31 14:14:07 +00002600 setFeatureEnabledImpl(Features, "pku", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002601 // FALLTHROUGH
2602 case CK_Broadwell:
2603 setFeatureEnabledImpl(Features, "rdseed", true);
2604 setFeatureEnabledImpl(Features, "adx", true);
2605 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002606 case CK_Haswell:
Craig Topperdb4dc082014-11-06 05:52:19 +00002607 setFeatureEnabledImpl(Features, "avx2", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002608 setFeatureEnabledImpl(Features, "lzcnt", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002609 setFeatureEnabledImpl(Features, "bmi", true);
2610 setFeatureEnabledImpl(Features, "bmi2", true);
2611 setFeatureEnabledImpl(Features, "rtm", true);
2612 setFeatureEnabledImpl(Features, "fma", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002613 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002614 case CK_IvyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00002615 setFeatureEnabledImpl(Features, "rdrnd", true);
2616 setFeatureEnabledImpl(Features, "f16c", true);
2617 setFeatureEnabledImpl(Features, "fsgsbase", true);
2618 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002619 case CK_SandyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00002620 setFeatureEnabledImpl(Features, "avx", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002621 setFeatureEnabledImpl(Features, "xsave", true);
2622 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002623 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002624 case CK_Westmere:
Craig Topperdb4dc082014-11-06 05:52:19 +00002625 case CK_Silvermont:
2626 setFeatureEnabledImpl(Features, "aes", true);
2627 setFeatureEnabledImpl(Features, "pclmul", true);
2628 // FALLTHROUGH
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002629 case CK_Nehalem:
Craig Topperdb4dc082014-11-06 05:52:19 +00002630 setFeatureEnabledImpl(Features, "sse4.2", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002631 setFeatureEnabledImpl(Features, "fxsr", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002632 setFeatureEnabledImpl(Features, "cx16", true);
2633 break;
2634 case CK_KNL:
2635 setFeatureEnabledImpl(Features, "avx512f", true);
2636 setFeatureEnabledImpl(Features, "avx512cd", true);
2637 setFeatureEnabledImpl(Features, "avx512er", true);
2638 setFeatureEnabledImpl(Features, "avx512pf", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002639 setFeatureEnabledImpl(Features, "fxsr", true);
Robert Khasanov50e6f582014-09-19 09:53:48 +00002640 setFeatureEnabledImpl(Features, "rdseed", true);
2641 setFeatureEnabledImpl(Features, "adx", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002642 setFeatureEnabledImpl(Features, "lzcnt", true);
2643 setFeatureEnabledImpl(Features, "bmi", true);
2644 setFeatureEnabledImpl(Features, "bmi2", true);
2645 setFeatureEnabledImpl(Features, "rtm", true);
2646 setFeatureEnabledImpl(Features, "fma", true);
2647 setFeatureEnabledImpl(Features, "rdrnd", true);
2648 setFeatureEnabledImpl(Features, "f16c", true);
2649 setFeatureEnabledImpl(Features, "fsgsbase", true);
2650 setFeatureEnabledImpl(Features, "aes", true);
2651 setFeatureEnabledImpl(Features, "pclmul", true);
2652 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002653 setFeatureEnabledImpl(Features, "xsaveopt", true);
2654 setFeatureEnabledImpl(Features, "xsave", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002655 break;
2656 case CK_K6_2:
2657 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00002658 case CK_WinChip2:
2659 case CK_C3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002660 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002661 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002662 case CK_Athlon:
2663 case CK_AthlonThunderbird:
2664 case CK_Geode:
Craig Topper86d79ef2013-09-17 04:51:29 +00002665 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00002666 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00002667 case CK_Athlon4:
2668 case CK_AthlonXP:
2669 case CK_AthlonMP:
Craig Topper86d79ef2013-09-17 04:51:29 +00002670 setFeatureEnabledImpl(Features, "sse", true);
2671 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002672 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002673 break;
2674 case CK_K8:
2675 case CK_Opteron:
2676 case CK_Athlon64:
2677 case CK_AthlonFX:
Craig Topper86d79ef2013-09-17 04:51:29 +00002678 setFeatureEnabledImpl(Features, "sse2", true);
2679 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002680 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00002681 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00002682 case CK_AMDFAM10:
2683 setFeatureEnabledImpl(Features, "sse4a", true);
2684 setFeatureEnabledImpl(Features, "lzcnt", true);
2685 setFeatureEnabledImpl(Features, "popcnt", true);
2686 // FALLTHROUGH
Chandler Carruth212334f2011-09-28 08:55:37 +00002687 case CK_K8SSE3:
2688 case CK_OpteronSSE3:
2689 case CK_Athlon64SSE3:
Craig Topper86d79ef2013-09-17 04:51:29 +00002690 setFeatureEnabledImpl(Features, "sse3", true);
2691 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002692 setFeatureEnabledImpl(Features, "fxsr", true);
Roman Divackyce253d82011-10-30 13:47:56 +00002693 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00002694 case CK_BTVER2:
2695 setFeatureEnabledImpl(Features, "avx", true);
2696 setFeatureEnabledImpl(Features, "aes", true);
2697 setFeatureEnabledImpl(Features, "pclmul", true);
2698 setFeatureEnabledImpl(Features, "bmi", true);
2699 setFeatureEnabledImpl(Features, "f16c", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002700 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00002701 // FALLTHROUGH
Benjamin Kramer569f2152012-01-10 11:50:18 +00002702 case CK_BTVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00002703 setFeatureEnabledImpl(Features, "ssse3", true);
2704 setFeatureEnabledImpl(Features, "sse4a", true);
2705 setFeatureEnabledImpl(Features, "lzcnt", true);
2706 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002707 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002708 setFeatureEnabledImpl(Features, "cx16", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002709 setFeatureEnabledImpl(Features, "fxsr", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002710 setFeatureEnabledImpl(Features, "xsave", true);
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002711 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00002712 case CK_BDVER4:
2713 setFeatureEnabledImpl(Features, "avx2", true);
2714 setFeatureEnabledImpl(Features, "bmi2", true);
2715 // FALLTHROUGH
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002716 case CK_BDVER3:
Craig Topper8c7f2512014-11-03 06:51:41 +00002717 setFeatureEnabledImpl(Features, "fsgsbase", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002718 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topper8c7f2512014-11-03 06:51:41 +00002719 // FALLTHROUGH
2720 case CK_BDVER2:
Andrea Di Biagio9760a442014-11-06 12:08:57 +00002721 setFeatureEnabledImpl(Features, "bmi", true);
2722 setFeatureEnabledImpl(Features, "fma", true);
2723 setFeatureEnabledImpl(Features, "f16c", true);
2724 setFeatureEnabledImpl(Features, "tbm", true);
2725 // FALLTHROUGH
2726 case CK_BDVER1:
2727 // xop implies avx, sse4a and fma4.
Craig Topper86d79ef2013-09-17 04:51:29 +00002728 setFeatureEnabledImpl(Features, "xop", true);
2729 setFeatureEnabledImpl(Features, "lzcnt", true);
2730 setFeatureEnabledImpl(Features, "aes", true);
2731 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00002732 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00002733 setFeatureEnabledImpl(Features, "cx16", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00002734 setFeatureEnabledImpl(Features, "fxsr", true);
Craig Topperda9fe562015-10-15 05:23:38 +00002735 setFeatureEnabledImpl(Features, "xsave", true);
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002736 break;
Eli Friedman33465822011-07-08 23:31:17 +00002737 }
Eric Christopherbbd746d2015-10-08 20:10:14 +00002738 if (!TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec))
2739 return false;
2740
2741 // Can't do this earlier because we need to be able to explicitly enable
2742 // or disable these features and the things that they depend upon.
2743
2744 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
2745 auto I = Features.find("sse4.2");
Rafael Espindolaa9195872015-10-24 23:15:31 +00002746 if (I != Features.end() && I->getValue() &&
Eric Christopherbbd746d2015-10-08 20:10:14 +00002747 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-popcnt") ==
2748 FeaturesVec.end())
2749 Features["popcnt"] = true;
2750
2751 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
2752 I = Features.find("3dnow");
Rafael Espindolaa9195872015-10-24 23:15:31 +00002753 if (I != Features.end() && I->getValue() &&
Eric Christopherbbd746d2015-10-08 20:10:14 +00002754 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-prfchw") ==
2755 FeaturesVec.end())
2756 Features["prfchw"] = true;
2757
Eric Christophera7260af2015-10-08 20:10:18 +00002758 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
2759 // then enable MMX.
2760 I = Features.find("sse");
Rafael Espindolaa9195872015-10-24 23:15:31 +00002761 if (I != Features.end() && I->getValue() &&
Eric Christophera7260af2015-10-08 20:10:18 +00002762 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-mmx") ==
2763 FeaturesVec.end())
2764 Features["mmx"] = true;
2765
Eric Christopherbbd746d2015-10-08 20:10:14 +00002766 return true;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002767}
2768
Rafael Espindolae62e2792013-08-20 13:44:29 +00002769void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002770 X86SSEEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002771 if (Enabled) {
2772 switch (Level) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002773 case AVX512F:
2774 Features["avx512f"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002775 case AVX2:
2776 Features["avx2"] = true;
2777 case AVX:
2778 Features["avx"] = true;
Craig Topperda9fe562015-10-15 05:23:38 +00002779 Features["xsave"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002780 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002781 Features["sse4.2"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002782 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002783 Features["sse4.1"] = true;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002784 case SSSE3:
2785 Features["ssse3"] = true;
2786 case SSE3:
2787 Features["sse3"] = true;
2788 case SSE2:
2789 Features["sse2"] = true;
2790 case SSE1:
Rafael Espindolae62e2792013-08-20 13:44:29 +00002791 Features["sse"] = true;
2792 case NoSSE:
2793 break;
2794 }
2795 return;
2796 }
2797
2798 switch (Level) {
2799 case NoSSE:
2800 case SSE1:
2801 Features["sse"] = false;
2802 case SSE2:
Ben Langmuir58078d02013-09-19 13:22:04 +00002803 Features["sse2"] = Features["pclmul"] = Features["aes"] =
2804 Features["sha"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002805 case SSE3:
2806 Features["sse3"] = false;
2807 setXOPLevel(Features, NoXOP, false);
2808 case SSSE3:
2809 Features["ssse3"] = false;
2810 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00002811 Features["sse4.1"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002812 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00002813 Features["sse4.2"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002814 case AVX:
Craig Topperda9fe562015-10-15 05:23:38 +00002815 Features["fma"] = Features["avx"] = Features["f16c"] = Features["xsave"] =
2816 Features["xsaveopt"] = false;
Rafael Espindola0221d862013-08-21 13:28:02 +00002817 setXOPLevel(Features, FMA4, false);
Rafael Espindolae62e2792013-08-20 13:44:29 +00002818 case AVX2:
2819 Features["avx2"] = false;
Craig Topper9c4d17f2013-08-21 03:59:22 +00002820 case AVX512F:
Eric Christopher917e9522014-11-18 22:36:15 +00002821 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
Craig Toppera31a5da2014-12-27 06:59:37 +00002822 Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] =
2823 Features["avx512vl"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002824 }
2825}
2826
2827void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00002828 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002829 if (Enabled) {
2830 switch (Level) {
2831 case AMD3DNowAthlon:
2832 Features["3dnowa"] = true;
2833 case AMD3DNow:
2834 Features["3dnow"] = true;
2835 case MMX:
2836 Features["mmx"] = true;
2837 case NoMMX3DNow:
2838 break;
2839 }
2840 return;
2841 }
2842
2843 switch (Level) {
2844 case NoMMX3DNow:
2845 case MMX:
2846 Features["mmx"] = false;
2847 case AMD3DNow:
2848 Features["3dnow"] = false;
2849 case AMD3DNowAthlon:
2850 Features["3dnowa"] = false;
2851 }
2852}
2853
2854void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper13f61a62013-09-17 04:12:55 +00002855 bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002856 if (Enabled) {
2857 switch (Level) {
2858 case XOP:
2859 Features["xop"] = true;
2860 case FMA4:
2861 Features["fma4"] = true;
2862 setSSELevel(Features, AVX, true);
2863 case SSE4A:
2864 Features["sse4a"] = true;
2865 setSSELevel(Features, SSE3, true);
2866 case NoXOP:
2867 break;
2868 }
2869 return;
2870 }
2871
2872 switch (Level) {
2873 case NoXOP:
2874 case SSE4A:
2875 Features["sse4a"] = false;
2876 case FMA4:
2877 Features["fma4"] = false;
2878 case XOP:
2879 Features["xop"] = false;
2880 }
2881}
2882
Craig Topper86d79ef2013-09-17 04:51:29 +00002883void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
2884 StringRef Name, bool Enabled) {
Eric Christopher298ac302015-07-01 00:08:32 +00002885 // This is a bit of a hack to deal with the sse4 target feature when used
2886 // as part of the target attribute. We handle sse4 correctly everywhere
2887 // else. See below for more information on how we handle the sse4 options.
2888 if (Name != "sse4")
2889 Features[Name] = Enabled;
Rafael Espindolaa6416a72011-11-27 20:00:43 +00002890
Craig Topper29561122013-09-19 01:13:07 +00002891 if (Name == "mmx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002892 setMMXLevel(Features, MMX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002893 } else if (Name == "sse") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002894 setSSELevel(Features, SSE1, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002895 } else if (Name == "sse2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002896 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002897 } else if (Name == "sse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002898 setSSELevel(Features, SSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002899 } else if (Name == "ssse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002900 setSSELevel(Features, SSSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002901 } else if (Name == "sse4.2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002902 setSSELevel(Features, SSE42, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002903 } else if (Name == "sse4.1") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002904 setSSELevel(Features, SSE41, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002905 } else if (Name == "3dnow") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002906 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002907 } else if (Name == "3dnowa") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002908 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002909 } else if (Name == "aes") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002910 if (Enabled)
2911 setSSELevel(Features, SSE2, Enabled);
2912 } else if (Name == "pclmul") {
2913 if (Enabled)
2914 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002915 } else if (Name == "avx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002916 setSSELevel(Features, AVX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002917 } else if (Name == "avx2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002918 setSSELevel(Features, AVX2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00002919 } else if (Name == "avx512f") {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002920 setSSELevel(Features, AVX512F, Enabled);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00002921 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf"
2922 || Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl") {
Craig Topper679b53a2013-08-21 05:29:10 +00002923 if (Enabled)
2924 setSSELevel(Features, AVX512F, Enabled);
2925 } else if (Name == "fma") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00002926 if (Enabled)
2927 setSSELevel(Features, AVX, Enabled);
2928 } else if (Name == "fma4") {
2929 setXOPLevel(Features, FMA4, Enabled);
2930 } else if (Name == "xop") {
2931 setXOPLevel(Features, XOP, Enabled);
2932 } else if (Name == "sse4a") {
2933 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper31db3a22013-09-16 04:54:13 +00002934 } else if (Name == "f16c") {
2935 if (Enabled)
2936 setSSELevel(Features, AVX, Enabled);
Ben Langmuir58078d02013-09-19 13:22:04 +00002937 } else if (Name == "sha") {
2938 if (Enabled)
2939 setSSELevel(Features, SSE2, Enabled);
Eric Christopher298ac302015-07-01 00:08:32 +00002940 } else if (Name == "sse4") {
2941 // We can get here via the __target__ attribute since that's not controlled
2942 // via the -msse4/-mno-sse4 command line alias. Handle this the same way
2943 // here - turn on the sse4.2 if enabled, turn off the sse4.1 level if
2944 // disabled.
2945 if (Enabled)
2946 setSSELevel(Features, SSE42, Enabled);
2947 else
2948 setSSELevel(Features, SSE41, Enabled);
Craig Topperda9fe562015-10-15 05:23:38 +00002949 } else if (Name == "xsave") {
2950 if (Enabled)
2951 setSSELevel(Features, AVX, Enabled);
2952 else
2953 Features["xsaveopt"] = false;
2954 } else if (Name == "xsaveopt" || Name == "xsavec" || Name == "xsaves") {
2955 if (Enabled) {
2956 Features["xsave"] = true;
2957 setSSELevel(Features, AVX, Enabled);
2958 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002959 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00002960}
2961
Eric Christopher3ff21b32013-10-16 21:26:26 +00002962/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00002963/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00002964bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindolaeb265472013-08-21 21:59:03 +00002965 DiagnosticsEngine &Diags) {
Eric Christopher610fe112015-08-26 08:21:55 +00002966 for (const auto &Feature : Features) {
2967 if (Feature[0] != '+')
Daniel Dunbar979586e2009-11-11 09:38:56 +00002968 continue;
2969
Eric Christopher610fe112015-08-26 08:21:55 +00002970 if (Feature == "+aes") {
Eric Christophere1ddaf92010-04-02 23:50:19 +00002971 HasAES = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002972 } else if (Feature == "+pclmul") {
Craig Topper3f122a72012-05-31 05:18:48 +00002973 HasPCLMUL = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002974 } else if (Feature == "+lzcnt") {
Craig Topper22967d42011-12-25 05:06:45 +00002975 HasLZCNT = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002976 } else if (Feature == "+rdrnd") {
Benjamin Kramer1e250392012-07-07 09:39:18 +00002977 HasRDRND = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002978 } else if (Feature == "+fsgsbase") {
Craig Topper8c7f2512014-11-03 06:51:41 +00002979 HasFSGSBASE = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002980 } else if (Feature == "+bmi") {
Craig Topper22967d42011-12-25 05:06:45 +00002981 HasBMI = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002982 } else if (Feature == "+bmi2") {
Craig Topper22967d42011-12-25 05:06:45 +00002983 HasBMI2 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002984 } else if (Feature == "+popcnt") {
Craig Topper1de83482011-12-29 16:10:46 +00002985 HasPOPCNT = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002986 } else if (Feature == "+rtm") {
Michael Liao625a8752012-11-10 05:17:46 +00002987 HasRTM = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002988 } else if (Feature == "+prfchw") {
Michael Liao74f4eaf2013-03-26 17:52:08 +00002989 HasPRFCHW = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002990 } else if (Feature == "+rdseed") {
Michael Liaoffaae352013-03-29 05:17:55 +00002991 HasRDSEED = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002992 } else if (Feature == "+adx") {
Robert Khasanov50e6f582014-09-19 09:53:48 +00002993 HasADX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002994 } else if (Feature == "+tbm") {
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00002995 HasTBM = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002996 } else if (Feature == "+fma") {
Craig Topperbba778b2012-06-03 21:46:30 +00002997 HasFMA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00002998 } else if (Feature == "+f16c") {
Manman Rena45358c2012-10-11 00:59:55 +00002999 HasF16C = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003000 } else if (Feature == "+avx512cd") {
Craig Topper679b53a2013-08-21 05:29:10 +00003001 HasAVX512CD = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003002 } else if (Feature == "+avx512er") {
Craig Topper679b53a2013-08-21 05:29:10 +00003003 HasAVX512ER = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003004 } else if (Feature == "+avx512pf") {
Craig Topper679b53a2013-08-21 05:29:10 +00003005 HasAVX512PF = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003006 } else if (Feature == "+avx512dq") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003007 HasAVX512DQ = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003008 } else if (Feature == "+avx512bw") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003009 HasAVX512BW = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003010 } else if (Feature == "+avx512vl") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003011 HasAVX512VL = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003012 } else if (Feature == "+sha") {
Ben Langmuir58078d02013-09-19 13:22:04 +00003013 HasSHA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003014 } else if (Feature == "+cx16") {
Nick Lewycky50e8f482013-10-05 20:14:27 +00003015 HasCX16 = true;
Craig Toppere33f51f2015-10-16 06:22:36 +00003016 } else if (Feature == "+fxsr") {
3017 HasFXSR = true;
Craig Topperda9fe562015-10-15 05:23:38 +00003018 } else if (Feature == "+xsave") {
3019 HasXSAVE = true;
3020 } else if (Feature == "+xsaveopt") {
3021 HasXSAVEOPT = true;
3022 } else if (Feature == "+xsavec") {
3023 HasXSAVEC = true;
3024 } else if (Feature == "+xsaves") {
3025 HasXSAVES = true;
Asaf Badouha9d1e182015-12-31 14:14:07 +00003026 } else if (Feature == "+pku") {
3027 HasPKU = true;
Nick Lewycky50e8f482013-10-05 20:14:27 +00003028 }
3029
Benjamin Kramer27402c62012-03-05 15:10:44 +00003030 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003031 .Case("+avx512f", AVX512F)
3032 .Case("+avx2", AVX2)
3033 .Case("+avx", AVX)
3034 .Case("+sse4.2", SSE42)
3035 .Case("+sse4.1", SSE41)
3036 .Case("+ssse3", SSSE3)
3037 .Case("+sse3", SSE3)
3038 .Case("+sse2", SSE2)
3039 .Case("+sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00003040 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00003041 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003042
Eli Friedman33465822011-07-08 23:31:17 +00003043 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer27402c62012-03-05 15:10:44 +00003044 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003045 .Case("+3dnowa", AMD3DNowAthlon)
3046 .Case("+3dnow", AMD3DNow)
3047 .Case("+mmx", MMX)
Eli Friedman33465822011-07-08 23:31:17 +00003048 .Default(NoMMX3DNow);
Eli Friedman33465822011-07-08 23:31:17 +00003049 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolae62e2792013-08-20 13:44:29 +00003050
3051 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003052 .Case("+xop", XOP)
3053 .Case("+fma4", FMA4)
3054 .Case("+sse4a", SSE4A)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003055 .Default(NoXOP);
3056 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00003057 }
Eli Friedman33465822011-07-08 23:31:17 +00003058
Rafael Espindolaeb265472013-08-21 21:59:03 +00003059 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
3060 // matches the selected sse level.
Craig Topperd945d502015-10-20 00:00:17 +00003061 if ((FPMath == FP_SSE && SSELevel < SSE1) ||
3062 (FPMath == FP_387 && SSELevel >= SSE1)) {
3063 Diags.Report(diag::err_target_unsupported_fpmath) <<
3064 (FPMath == FP_SSE ? "sse" : "387");
Rafael Espindolaeb265472013-08-21 21:59:03 +00003065 return false;
3066 }
3067
Alexey Bataev00396512015-07-02 03:40:19 +00003068 SimdDefaultAlign =
Ahmed Bougacha68bf64e2015-08-27 22:24:56 +00003069 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Rafael Espindolaeb265472013-08-21 21:59:03 +00003070 return true;
Chris Lattnerc25d8a72009-03-02 22:20:04 +00003071}
Chris Lattnerecd49032009-03-02 22:27:17 +00003072
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003073/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
3074/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00003075void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003076 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00003077 // Target identification.
Derek Schuffc7dd7222012-10-11 15:52:22 +00003078 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003079 Builder.defineMacro("__amd64__");
3080 Builder.defineMacro("__amd64");
3081 Builder.defineMacro("__x86_64");
3082 Builder.defineMacro("__x86_64__");
Bob Wilsona2acb1e2014-08-08 23:46:28 +00003083 if (getTriple().getArchName() == "x86_64h") {
3084 Builder.defineMacro("__x86_64h");
3085 Builder.defineMacro("__x86_64h__");
3086 }
Chris Lattnerecd49032009-03-02 22:27:17 +00003087 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003088 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00003089 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003090
Chris Lattnerecd49032009-03-02 22:27:17 +00003091 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003092 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
3093 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00003094 switch (CPU) {
3095 case CK_Generic:
3096 break;
3097 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003098 // The rest are coming from the i386 define above.
3099 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00003100 break;
3101 case CK_i486:
3102 case CK_WinChipC6:
3103 case CK_WinChip2:
3104 case CK_C3:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003105 defineCPUMacros(Builder, "i486");
Chandler Carruth212334f2011-09-28 08:55:37 +00003106 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003107 case CK_PentiumMMX:
3108 Builder.defineMacro("__pentium_mmx__");
3109 Builder.defineMacro("__tune_pentium_mmx__");
3110 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00003111 case CK_i586:
3112 case CK_Pentium:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003113 defineCPUMacros(Builder, "i586");
3114 defineCPUMacros(Builder, "pentium");
Chandler Carruth212334f2011-09-28 08:55:37 +00003115 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003116 case CK_Pentium3:
3117 case CK_Pentium3M:
3118 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003119 Builder.defineMacro("__tune_pentium3__");
3120 // Fallthrough
3121 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00003122 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003123 Builder.defineMacro("__tune_pentium2__");
3124 // Fallthrough
3125 case CK_PentiumPro:
3126 Builder.defineMacro("__tune_i686__");
3127 Builder.defineMacro("__tune_pentiumpro__");
3128 // Fallthrough
3129 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003130 Builder.defineMacro("__i686");
3131 Builder.defineMacro("__i686__");
3132 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
3133 Builder.defineMacro("__pentiumpro");
3134 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00003135 break;
3136 case CK_Pentium4:
3137 case CK_Pentium4M:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003138 defineCPUMacros(Builder, "pentium4");
Chandler Carruth212334f2011-09-28 08:55:37 +00003139 break;
3140 case CK_Yonah:
3141 case CK_Prescott:
3142 case CK_Nocona:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003143 defineCPUMacros(Builder, "nocona");
Chandler Carruth212334f2011-09-28 08:55:37 +00003144 break;
3145 case CK_Core2:
3146 case CK_Penryn:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003147 defineCPUMacros(Builder, "core2");
Chandler Carruth212334f2011-09-28 08:55:37 +00003148 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003149 case CK_Bonnell:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003150 defineCPUMacros(Builder, "atom");
Chandler Carruth212334f2011-09-28 08:55:37 +00003151 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00003152 case CK_Silvermont:
Benjamin Kramerffecc842013-08-30 14:05:34 +00003153 defineCPUMacros(Builder, "slm");
3154 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003155 case CK_Nehalem:
3156 case CK_Westmere:
3157 case CK_SandyBridge:
3158 case CK_IvyBridge:
3159 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00003160 case CK_Broadwell:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003161 // FIXME: Historically, we defined this legacy name, it would be nice to
3162 // remove it at some point. We've never exposed fine-grained names for
3163 // recent primary x86 CPUs, and we should keep it that way.
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003164 defineCPUMacros(Builder, "corei7");
Chandler Carruth212334f2011-09-28 08:55:37 +00003165 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003166 case CK_Skylake:
3167 // FIXME: Historically, we defined this legacy name, it would be nice to
3168 // remove it at some point. This is the only fine-grained CPU macro in the
3169 // main intel CPU line, and it would be better to not have these and force
3170 // people to use ISA macros.
3171 defineCPUMacros(Builder, "skx");
3172 break;
Craig Topper449314e2013-08-20 07:09:39 +00003173 case CK_KNL:
3174 defineCPUMacros(Builder, "knl");
3175 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003176 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003177 Builder.defineMacro("__k6_2__");
3178 Builder.defineMacro("__tune_k6_2__");
3179 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00003180 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003181 if (CPU != CK_K6_2) { // In case of fallthrough
3182 // FIXME: GCC may be enabling these in cases where some other k6
3183 // architecture is specified but -m3dnow is explicitly provided. The
3184 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003185 Builder.defineMacro("__k6_3__");
3186 Builder.defineMacro("__tune_k6_3__");
3187 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003188 // Fallthrough
3189 case CK_K6:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003190 defineCPUMacros(Builder, "k6");
Chandler Carruth212334f2011-09-28 08:55:37 +00003191 break;
3192 case CK_Athlon:
3193 case CK_AthlonThunderbird:
3194 case CK_Athlon4:
3195 case CK_AthlonXP:
3196 case CK_AthlonMP:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003197 defineCPUMacros(Builder, "athlon");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00003198 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003199 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00003200 Builder.defineMacro("__tune_athlon_sse__");
3201 }
Chandler Carruth212334f2011-09-28 08:55:37 +00003202 break;
3203 case CK_K8:
3204 case CK_K8SSE3:
3205 case CK_x86_64:
3206 case CK_Opteron:
3207 case CK_OpteronSSE3:
3208 case CK_Athlon64:
3209 case CK_Athlon64SSE3:
3210 case CK_AthlonFX:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003211 defineCPUMacros(Builder, "k8");
Chandler Carruth212334f2011-09-28 08:55:37 +00003212 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00003213 case CK_AMDFAM10:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003214 defineCPUMacros(Builder, "amdfam10");
Roman Divacky43eb6f82011-10-30 07:48:46 +00003215 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00003216 case CK_BTVER1:
3217 defineCPUMacros(Builder, "btver1");
3218 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00003219 case CK_BTVER2:
3220 defineCPUMacros(Builder, "btver2");
3221 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003222 case CK_BDVER1:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003223 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003224 break;
3225 case CK_BDVER2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003226 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003227 break;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00003228 case CK_BDVER3:
3229 defineCPUMacros(Builder, "bdver3");
3230 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00003231 case CK_BDVER4:
3232 defineCPUMacros(Builder, "bdver4");
3233 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003234 case CK_Geode:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003235 defineCPUMacros(Builder, "geode");
Chandler Carruth212334f2011-09-28 08:55:37 +00003236 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003237 }
Chris Lattner96e43572009-03-02 22:40:39 +00003238
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003239 // Target properties.
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003240 Builder.defineMacro("__REGISTER_PREFIX__", "");
3241
Chris Lattner6df41af2009-04-19 17:32:33 +00003242 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
3243 // functions in glibc header files that use FP Stack inline asm which the
3244 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003245 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003246
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003247 if (HasAES)
3248 Builder.defineMacro("__AES__");
3249
Craig Topper3f122a72012-05-31 05:18:48 +00003250 if (HasPCLMUL)
3251 Builder.defineMacro("__PCLMUL__");
3252
Craig Topper22967d42011-12-25 05:06:45 +00003253 if (HasLZCNT)
3254 Builder.defineMacro("__LZCNT__");
3255
Benjamin Kramer1e250392012-07-07 09:39:18 +00003256 if (HasRDRND)
3257 Builder.defineMacro("__RDRND__");
3258
Craig Topper8c7f2512014-11-03 06:51:41 +00003259 if (HasFSGSBASE)
3260 Builder.defineMacro("__FSGSBASE__");
3261
Craig Topper22967d42011-12-25 05:06:45 +00003262 if (HasBMI)
3263 Builder.defineMacro("__BMI__");
3264
3265 if (HasBMI2)
3266 Builder.defineMacro("__BMI2__");
3267
Craig Topper1de83482011-12-29 16:10:46 +00003268 if (HasPOPCNT)
3269 Builder.defineMacro("__POPCNT__");
3270
Michael Liao625a8752012-11-10 05:17:46 +00003271 if (HasRTM)
3272 Builder.defineMacro("__RTM__");
3273
Michael Liao74f4eaf2013-03-26 17:52:08 +00003274 if (HasPRFCHW)
3275 Builder.defineMacro("__PRFCHW__");
3276
Michael Liaoffaae352013-03-29 05:17:55 +00003277 if (HasRDSEED)
3278 Builder.defineMacro("__RDSEED__");
3279
Robert Khasanov50e6f582014-09-19 09:53:48 +00003280 if (HasADX)
3281 Builder.defineMacro("__ADX__");
3282
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00003283 if (HasTBM)
3284 Builder.defineMacro("__TBM__");
3285
Rafael Espindolae62e2792013-08-20 13:44:29 +00003286 switch (XOPLevel) {
3287 case XOP:
3288 Builder.defineMacro("__XOP__");
3289 case FMA4:
Craig Topperffdb46c2011-12-30 07:33:42 +00003290 Builder.defineMacro("__FMA4__");
Rafael Espindolae62e2792013-08-20 13:44:29 +00003291 case SSE4A:
3292 Builder.defineMacro("__SSE4A__");
3293 case NoXOP:
3294 break;
3295 }
Craig Topperffdb46c2011-12-30 07:33:42 +00003296
Craig Topperbba778b2012-06-03 21:46:30 +00003297 if (HasFMA)
3298 Builder.defineMacro("__FMA__");
3299
Manman Rena45358c2012-10-11 00:59:55 +00003300 if (HasF16C)
3301 Builder.defineMacro("__F16C__");
3302
Craig Topper679b53a2013-08-21 05:29:10 +00003303 if (HasAVX512CD)
3304 Builder.defineMacro("__AVX512CD__");
3305 if (HasAVX512ER)
3306 Builder.defineMacro("__AVX512ER__");
3307 if (HasAVX512PF)
3308 Builder.defineMacro("__AVX512PF__");
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003309 if (HasAVX512DQ)
3310 Builder.defineMacro("__AVX512DQ__");
3311 if (HasAVX512BW)
3312 Builder.defineMacro("__AVX512BW__");
3313 if (HasAVX512VL)
3314 Builder.defineMacro("__AVX512VL__");
Craig Topper679b53a2013-08-21 05:29:10 +00003315
Ben Langmuir58078d02013-09-19 13:22:04 +00003316 if (HasSHA)
3317 Builder.defineMacro("__SHA__");
3318
Craig Toppere33f51f2015-10-16 06:22:36 +00003319 if (HasFXSR)
3320 Builder.defineMacro("__FXSR__");
Craig Topperda9fe562015-10-15 05:23:38 +00003321 if (HasXSAVE)
3322 Builder.defineMacro("__XSAVE__");
3323 if (HasXSAVEOPT)
3324 Builder.defineMacro("__XSAVEOPT__");
3325 if (HasXSAVEC)
3326 Builder.defineMacro("__XSAVEC__");
3327 if (HasXSAVES)
3328 Builder.defineMacro("__XSAVES__");
Asaf Badouha9d1e182015-12-31 14:14:07 +00003329 if (HasPKU)
3330 Builder.defineMacro("__PKU__");
Nick Lewycky50e8f482013-10-05 20:14:27 +00003331 if (HasCX16)
3332 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
3333
Chris Lattner96e43572009-03-02 22:40:39 +00003334 // Each case falls through to the previous one here.
3335 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003336 case AVX512F:
Craig Topper007b0592013-08-20 07:39:54 +00003337 Builder.defineMacro("__AVX512F__");
Craig Topper23b92192012-01-09 09:19:09 +00003338 case AVX2:
3339 Builder.defineMacro("__AVX2__");
3340 case AVX:
3341 Builder.defineMacro("__AVX__");
Chris Lattner96e43572009-03-02 22:40:39 +00003342 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003343 Builder.defineMacro("__SSE4_2__");
Chris Lattner96e43572009-03-02 22:40:39 +00003344 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003345 Builder.defineMacro("__SSE4_1__");
Chris Lattner96e43572009-03-02 22:40:39 +00003346 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003347 Builder.defineMacro("__SSSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00003348 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003349 Builder.defineMacro("__SSE3__");
Chris Lattner96e43572009-03-02 22:40:39 +00003350 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003351 Builder.defineMacro("__SSE2__");
3352 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Chris Lattner96e43572009-03-02 22:40:39 +00003353 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003354 Builder.defineMacro("__SSE__");
3355 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Eli Friedman33465822011-07-08 23:31:17 +00003356 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00003357 break;
3358 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003359
Derek Schuffc7dd7222012-10-11 15:52:22 +00003360 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003361 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003362 case AVX512F:
Craig Topper23b92192012-01-09 09:19:09 +00003363 case AVX2:
3364 case AVX:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003365 case SSE42:
3366 case SSE41:
3367 case SSSE3:
3368 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003369 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003370 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003371 break;
3372 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003373 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003374 break;
3375 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003376 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003377 }
3378 }
3379
Anders Carlssone437c682010-01-27 03:47:49 +00003380 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00003381 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00003382 case AMD3DNowAthlon:
3383 Builder.defineMacro("__3dNOW_A__");
3384 case AMD3DNow:
3385 Builder.defineMacro("__3dNOW__");
Eli Friedman33465822011-07-08 23:31:17 +00003386 case MMX:
3387 Builder.defineMacro("__MMX__");
3388 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00003389 break;
3390 }
Michael J. Spencera0d5eb3a2013-04-04 23:53:43 +00003391
3392 if (CPU >= CK_i486) {
3393 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
3394 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
3395 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
3396 }
3397 if (CPU >= CK_i586)
3398 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerecd49032009-03-02 22:27:17 +00003399}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003400
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003401bool X86TargetInfo::hasFeature(StringRef Feature) const {
3402 return llvm::StringSwitch<bool>(Feature)
3403 .Case("aes", HasAES)
3404 .Case("avx", SSELevel >= AVX)
3405 .Case("avx2", SSELevel >= AVX2)
Craig Topper9c4d17f2013-08-21 03:59:22 +00003406 .Case("avx512f", SSELevel >= AVX512F)
Craig Topper679b53a2013-08-21 05:29:10 +00003407 .Case("avx512cd", HasAVX512CD)
3408 .Case("avx512er", HasAVX512ER)
3409 .Case("avx512pf", HasAVX512PF)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003410 .Case("avx512dq", HasAVX512DQ)
3411 .Case("avx512bw", HasAVX512BW)
3412 .Case("avx512vl", HasAVX512VL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003413 .Case("bmi", HasBMI)
3414 .Case("bmi2", HasBMI2)
Nick Lewycky50e8f482013-10-05 20:14:27 +00003415 .Case("cx16", HasCX16)
3416 .Case("f16c", HasF16C)
Craig Topperbba778b2012-06-03 21:46:30 +00003417 .Case("fma", HasFMA)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003418 .Case("fma4", XOPLevel >= FMA4)
Craig Topper8c7f2512014-11-03 06:51:41 +00003419 .Case("fsgsbase", HasFSGSBASE)
Craig Toppere33f51f2015-10-16 06:22:36 +00003420 .Case("fxsr", HasFXSR)
Craig Topper8dbc5842014-11-03 07:05:26 +00003421 .Case("lzcnt", HasLZCNT)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003422 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
3423 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
3424 .Case("mmx", MMX3DNowLevel >= MMX)
Craig Topper3f122a72012-05-31 05:18:48 +00003425 .Case("pclmul", HasPCLMUL)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003426 .Case("popcnt", HasPOPCNT)
Michael Liao74f4eaf2013-03-26 17:52:08 +00003427 .Case("prfchw", HasPRFCHW)
Craig Topper8dbc5842014-11-03 07:05:26 +00003428 .Case("rdrnd", HasRDRND)
Michael Liaoffaae352013-03-29 05:17:55 +00003429 .Case("rdseed", HasRDSEED)
Craig Topper8dbc5842014-11-03 07:05:26 +00003430 .Case("rtm", HasRTM)
Ben Langmuir58078d02013-09-19 13:22:04 +00003431 .Case("sha", HasSHA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003432 .Case("sse", SSELevel >= SSE1)
3433 .Case("sse2", SSELevel >= SSE2)
3434 .Case("sse3", SSELevel >= SSE3)
3435 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola89049822013-08-23 20:21:37 +00003436 .Case("sse4.1", SSELevel >= SSE41)
3437 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003438 .Case("sse4a", XOPLevel >= SSE4A)
Craig Topper8dbc5842014-11-03 07:05:26 +00003439 .Case("tbm", HasTBM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003440 .Case("x86", true)
Derek Schuffc7dd7222012-10-11 15:52:22 +00003441 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
3442 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003443 .Case("xop", XOPLevel >= XOP)
Craig Topperda9fe562015-10-15 05:23:38 +00003444 .Case("xsave", HasXSAVE)
3445 .Case("xsavec", HasXSAVEC)
3446 .Case("xsaves", HasXSAVES)
3447 .Case("xsaveopt", HasXSAVEOPT)
Asaf Badouha9d1e182015-12-31 14:14:07 +00003448 .Case("pku", HasPKU)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00003449 .Default(false);
3450}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003451
Eric Christopherd9832702015-06-29 21:00:05 +00003452// We can't use a generic validation scheme for the features accepted here
3453// versus subtarget features accepted in the target attribute because the
3454// bitfield structure that's initialized in the runtime only supports the
3455// below currently rather than the full range of subtarget features. (See
3456// X86TargetInfo::hasFeature for a somewhat comprehensive list).
3457bool X86TargetInfo::validateCpuSupports(StringRef FeatureStr) const {
3458 return llvm::StringSwitch<bool>(FeatureStr)
3459 .Case("cmov", true)
3460 .Case("mmx", true)
3461 .Case("popcnt", true)
3462 .Case("sse", true)
3463 .Case("sse2", true)
3464 .Case("sse3", true)
3465 .Case("sse4.1", true)
3466 .Case("sse4.2", true)
3467 .Case("avx", true)
3468 .Case("avx2", true)
3469 .Case("sse4a", true)
3470 .Case("fma4", true)
3471 .Case("xop", true)
3472 .Case("fma", true)
3473 .Case("avx512f", true)
3474 .Case("bmi", true)
3475 .Case("bmi2", true)
3476 .Default(false);
3477}
3478
Eli Friedman3fd920a2008-08-20 02:34:37 +00003479bool
Anders Carlsson58436352009-02-28 17:11:49 +00003480X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00003481 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00003482 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003483 default: return false;
Alexey Bataev91e58602015-07-20 12:08:00 +00003484 // Constant constraints.
3485 case 'e': // 32-bit signed integer constant for use with sign-extending x86_64
3486 // instructions.
3487 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
3488 // x86_64 instructions.
3489 case 's':
3490 Info.setRequiresImmediate();
3491 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00003492 case 'I':
3493 Info.setRequiresImmediate(0, 31);
3494 return true;
3495 case 'J':
3496 Info.setRequiresImmediate(0, 63);
3497 return true;
3498 case 'K':
3499 Info.setRequiresImmediate(-128, 127);
3500 return true;
3501 case 'L':
Alexey Bataev91e58602015-07-20 12:08:00 +00003502 Info.setRequiresImmediate({ int(0xff), int(0xffff), int(0xffffffff) });
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00003503 return true;
3504 case 'M':
3505 Info.setRequiresImmediate(0, 3);
3506 return true;
3507 case 'N':
3508 Info.setRequiresImmediate(0, 255);
3509 return true;
3510 case 'O':
3511 Info.setRequiresImmediate(0, 127);
3512 return true;
Alexey Bataev91e58602015-07-20 12:08:00 +00003513 // Register constraints.
3514 case 'Y': // 'Y' is the first character for several 2-character constraints.
3515 // Shift the pointer to the second character of the constraint.
3516 Name++;
3517 switch (*Name) {
3518 default:
3519 return false;
3520 case '0': // First SSE register.
3521 case 't': // Any SSE register, when SSE2 is enabled.
3522 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
3523 case 'm': // Any MMX register, when inter-unit moves enabled.
3524 Info.setAllowsRegister();
3525 return true;
3526 }
3527 case 'f': // Any x87 floating point stack register.
Akira Hatanaka88ef7282014-07-18 23:30:30 +00003528 // Constraint 'f' cannot be used for output operands.
3529 if (Info.ConstraintStr[0] == '=')
3530 return false;
Akira Hatanaka88ef7282014-07-18 23:30:30 +00003531 Info.setAllowsRegister();
3532 return true;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003533 case 'a': // eax.
3534 case 'b': // ebx.
3535 case 'c': // ecx.
3536 case 'd': // edx.
3537 case 'S': // esi.
3538 case 'D': // edi.
3539 case 'A': // edx:eax.
Alexey Bataev91e58602015-07-20 12:08:00 +00003540 case 't': // Top of floating point stack.
3541 case 'u': // Second from top of floating point stack.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003542 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00003543 case 'y': // Any MMX register.
Anders Carlsson5f7ee682008-10-06 19:17:39 +00003544 case 'x': // Any SSE register.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003545 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00003546 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
3547 case 'l': // "Index" registers: any general register that can be used as an
3548 // index in a base+index memory access.
3549 Info.setAllowsRegister();
3550 return true;
Alexey Bataev91e58602015-07-20 12:08:00 +00003551 // Floating point constant constraints.
Dale Johannesen46742a42010-08-24 22:33:12 +00003552 case 'C': // SSE floating point constant.
3553 case 'G': // x87 floating point constant.
Eli Friedman3fd920a2008-08-20 02:34:37 +00003554 return true;
3555 }
3556}
3557
Akira Hatanaka974131e2014-09-18 18:17:18 +00003558bool X86TargetInfo::validateOutputSize(StringRef Constraint,
3559 unsigned Size) const {
3560 // Strip off constraint modifiers.
3561 while (Constraint[0] == '=' ||
3562 Constraint[0] == '+' ||
3563 Constraint[0] == '&')
3564 Constraint = Constraint.substr(1);
3565
3566 return validateOperandSize(Constraint, Size);
3567}
3568
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003569bool X86TargetInfo::validateInputSize(StringRef Constraint,
3570 unsigned Size) const {
Akira Hatanaka974131e2014-09-18 18:17:18 +00003571 return validateOperandSize(Constraint, Size);
3572}
3573
3574bool X86TargetInfo::validateOperandSize(StringRef Constraint,
3575 unsigned Size) const {
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003576 switch (Constraint[0]) {
3577 default: break;
3578 case 'y':
3579 return Size <= 64;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003580 case 'f':
3581 case 't':
3582 case 'u':
3583 return Size <= 128;
Hans Wennborg3c619a42014-09-18 20:24:04 +00003584 case 'x':
Alexey Bataev91e58602015-07-20 12:08:00 +00003585 if (SSELevel >= AVX512F)
3586 // 512-bit zmm registers can be used if target supports AVX512F.
3587 return Size <= 512U;
3588 else if (SSELevel >= AVX)
3589 // 256-bit ymm registers can be used if target supports AVX.
3590 return Size <= 256U;
3591 return Size <= 128U;
3592 case 'Y':
3593 // 'Y' is the first character for several 2-character constraints.
3594 switch (Constraint[1]) {
3595 default: break;
3596 case 'm':
3597 // 'Ym' is synonymous with 'y'.
3598 return Size <= 64;
3599 case 'i':
3600 case 't':
3601 // 'Yi' and 'Yt' are synonymous with 'x' when SSE2 is enabled.
3602 if (SSELevel >= AVX512F)
3603 return Size <= 512U;
3604 else if (SSELevel >= AVX)
3605 return Size <= 256U;
3606 return SSELevel >= SSE2 && Size <= 128U;
3607 }
3608
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003609 }
3610
3611 return true;
3612}
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00003613
Eli Friedman3fd920a2008-08-20 02:34:37 +00003614std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003615X86TargetInfo::convertConstraint(const char *&Constraint) const {
3616 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003617 case 'a': return std::string("{ax}");
3618 case 'b': return std::string("{bx}");
3619 case 'c': return std::string("{cx}");
3620 case 'd': return std::string("{dx}");
3621 case 'S': return std::string("{si}");
3622 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00003623 case 'p': // address
3624 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00003625 case 't': // top of floating point stack.
3626 return std::string("{st}");
3627 case 'u': // second from top of floating point stack.
3628 return std::string("{st(1)}"); // second from top of floating point stack.
3629 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00003630 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00003631 }
3632}
Chris Lattner5ba61f02006-10-14 07:39:34 +00003633
Eli Friedman3fd920a2008-08-20 02:34:37 +00003634// X86-32 generic target
3635class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00003636public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003637 X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003638 DoubleAlign = LongLongAlign = 32;
3639 LongDoubleWidth = 96;
3640 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00003641 SuitableAlign = 128;
Eric Christopher964a5f32015-08-05 23:48:05 +00003642 DataLayoutString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
Eli Friedman32ca82a2009-03-29 20:31:09 +00003643 SizeType = UnsignedInt;
3644 PtrDiffType = SignedInt;
3645 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003646 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003647
3648 // Use fpret for all types.
3649 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
3650 (1 << TargetInfo::Double) |
3651 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003652
3653 // x86-32 has atomics up to 8 bytes
3654 // FIXME: Check that we actually have cmpxchg8b before setting
3655 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
3656 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003657 }
Craig Topper3164f332014-03-11 03:39:26 +00003658 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003659 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman3fd920a2008-08-20 02:34:37 +00003660 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003661
Craig Topper3164f332014-03-11 03:39:26 +00003662 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003663 if (RegNo == 0) return 0;
3664 if (RegNo == 1) return 2;
3665 return -1;
3666 }
Akira Hatanaka974131e2014-09-18 18:17:18 +00003667 bool validateOperandSize(StringRef Constraint,
3668 unsigned Size) const override {
Bill Wendling887b4852012-11-12 06:42:51 +00003669 switch (Constraint[0]) {
3670 default: break;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003671 case 'R':
3672 case 'q':
3673 case 'Q':
Bill Wendling887b4852012-11-12 06:42:51 +00003674 case 'a':
3675 case 'b':
3676 case 'c':
3677 case 'd':
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003678 case 'S':
3679 case 'D':
Bill Wendling3c7fed82012-11-12 18:52:32 +00003680 return Size <= 32;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00003681 case 'A':
3682 return Size <= 64;
Bill Wendling887b4852012-11-12 06:42:51 +00003683 }
3684
Akira Hatanaka974131e2014-09-18 18:17:18 +00003685 return X86TargetInfo::validateOperandSize(Constraint, Size);
Bill Wendling887b4852012-11-12 06:42:51 +00003686 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003687};
Eli Friedman3fd920a2008-08-20 02:34:37 +00003688
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003689class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
3690public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003691 NetBSDI386TargetInfo(const llvm::Triple &Triple)
3692 : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003693
Craig Topper3164f332014-03-11 03:39:26 +00003694 unsigned getFloatEvalMethod() const override {
Joerg Sonnenberger0e921f22013-11-11 14:00:37 +00003695 unsigned Major, Minor, Micro;
3696 getTriple().getOSVersion(Major, Minor, Micro);
3697 // New NetBSD uses the default rounding mode.
3698 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
3699 return X86_32TargetInfo::getFloatEvalMethod();
3700 // NetBSD before 6.99.26 defaults to "double" rounding.
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003701 return 1;
3702 }
3703};
Joerg Sonnenberger16237142012-01-06 18:32:26 +00003704
Eli Friedmane3aa4542009-07-05 18:47:56 +00003705class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
3706public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003707 OpenBSDI386TargetInfo(const llvm::Triple &Triple)
3708 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedmane3aa4542009-07-05 18:47:56 +00003709 SizeType = UnsignedLong;
3710 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00003711 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00003712 }
3713};
Eli Friedmane3aa4542009-07-05 18:47:56 +00003714
Eli Friedman9fa28852012-08-08 23:57:20 +00003715class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
3716public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003717 BitrigI386TargetInfo(const llvm::Triple &Triple)
3718 : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman9fa28852012-08-08 23:57:20 +00003719 SizeType = UnsignedLong;
3720 IntPtrType = SignedLong;
3721 PtrDiffType = SignedLong;
3722 }
3723};
Eli Friedman9fa28852012-08-08 23:57:20 +00003724
Torok Edwinb2b37c62009-06-30 17:10:35 +00003725class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003726public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003727 DarwinI386TargetInfo(const llvm::Triple &Triple)
3728 : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00003729 LongDoubleWidth = 128;
3730 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003731 SuitableAlign = 128;
Tim Northover5627d392015-10-30 16:30:45 +00003732 MaxVectorAlign = 256;
3733 // The watchOS simulator uses the builtin bool type for Objective-C.
3734 llvm::Triple T = llvm::Triple(Triple);
3735 if (T.isWatchOS())
3736 UseSignedCharForObjCBool = false;
Eli Friedman32ca82a2009-03-29 20:31:09 +00003737 SizeType = UnsignedLong;
3738 IntPtrType = SignedLong;
Eric Christopher964a5f32015-08-05 23:48:05 +00003739 DataLayoutString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
Daniel Dunbarbd606522010-05-27 00:35:16 +00003740 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00003741 }
3742
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00003743 bool handleTargetFeatures(std::vector<std::string> &Features,
3744 DiagnosticsEngine &Diags) override {
3745 if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
3746 Diags))
3747 return false;
Ahmed Bougacha02b7b562015-08-27 22:42:12 +00003748 // We now know the features we have: we can decide how to align vectors.
3749 MaxVectorAlign =
3750 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00003751 return true;
3752 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00003753};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00003754
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003755// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00003756class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003757public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003758 WindowsX86_32TargetInfo(const llvm::Triple &Triple)
3759 : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
Chris Lattner46be2e12009-06-24 17:12:15 +00003760 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00003761 DoubleAlign = LongLongAlign = 64;
Reid Kleckner7510c092015-04-01 16:45:06 +00003762 bool IsWinCOFF =
3763 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
Eric Christopher964a5f32015-08-05 23:48:05 +00003764 DataLayoutString = IsWinCOFF
3765 ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
3766 : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003767 }
Craig Topper3164f332014-03-11 03:39:26 +00003768 void getTargetDefines(const LangOptions &Opts,
3769 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003770 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
3771 }
3772};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003773
3774// x86-32 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003775class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003776public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00003777 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003778 : WindowsX86_32TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00003779 LongDoubleWidth = LongDoubleAlign = 64;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003780 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3781 }
Craig Topper3164f332014-03-11 03:39:26 +00003782 void getTargetDefines(const LangOptions &Opts,
3783 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003784 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
3785 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
3786 // The value of the following reflects processor type.
3787 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
3788 // We lost the original triple, so we use the default.
3789 Builder.defineMacro("_M_IX86", "600");
3790 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003791};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003792
David Majnemerae1ed0e2015-05-28 04:36:18 +00003793static void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
Eric Christopherb093d692015-10-09 18:39:59 +00003794 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
3795 // supports __declspec natively under -fms-extensions, but we define a no-op
3796 // __declspec macro anyway for pre-processor compatibility.
Reid Kleckner47606832014-04-21 20:58:00 +00003797 if (Opts.MicrosoftExt)
3798 Builder.defineMacro("__declspec", "__declspec");
3799 else
3800 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
3801
3802 if (!Opts.MicrosoftExt) {
3803 // Provide macros for all the calling convention keywords. Provide both
3804 // single and double underscore prefixed variants. These are available on
3805 // x64 as well as x86, even though they have no effect.
3806 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
3807 for (const char *CC : CCs) {
Reid Kleckner70cfa662014-04-21 22:29:45 +00003808 std::string GCCSpelling = "__attribute__((__";
3809 GCCSpelling += CC;
3810 GCCSpelling += "__))";
Reid Kleckner47606832014-04-21 20:58:00 +00003811 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
3812 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
3813 }
3814 }
3815}
3816
David Majnemerae1ed0e2015-05-28 04:36:18 +00003817static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
3818 Builder.defineMacro("__MSVCRT__");
3819 Builder.defineMacro("__MINGW32__");
3820 addCygMingDefines(Opts, Builder);
3821}
3822
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003823// x86-32 MinGW target
3824class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
3825public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003826 MinGWX86_32TargetInfo(const llvm::Triple &Triple)
Yaron Keren4da1a372015-08-20 21:36:14 +00003827 : WindowsX86_32TargetInfo(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00003828 void getTargetDefines(const LangOptions &Opts,
3829 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003830 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00003831 DefineStd(Builder, "WIN32", Opts);
3832 DefineStd(Builder, "WINNT", Opts);
3833 Builder.defineMacro("_X86_");
Reid Kleckner47606832014-04-21 20:58:00 +00003834 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003835 }
3836};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003837
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003838// x86-32 Cygwin target
3839class CygwinX86_32TargetInfo : public X86_32TargetInfo {
3840public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003841 CygwinX86_32TargetInfo(const llvm::Triple &Triple)
3842 : X86_32TargetInfo(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003843 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003844 DoubleAlign = LongLongAlign = 64;
Eric Christopher964a5f32015-08-05 23:48:05 +00003845 DataLayoutString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00003846 }
Craig Topper3164f332014-03-11 03:39:26 +00003847 void getTargetDefines(const LangOptions &Opts,
3848 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003849 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumi02f43952012-12-14 10:17:26 +00003850 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003851 Builder.defineMacro("__CYGWIN__");
3852 Builder.defineMacro("__CYGWIN32__");
David Majnemerae1ed0e2015-05-28 04:36:18 +00003853 addCygMingDefines(Opts, Builder);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003854 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00003855 if (Opts.CPlusPlus)
3856 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00003857 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003858};
Eli Friedmanc968a6a2008-08-21 01:40:19 +00003859
Chris Lattnerb986aba2010-04-11 19:29:39 +00003860// x86-32 Haiku target
3861class HaikuX86_32TargetInfo : public X86_32TargetInfo {
3862public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003863 HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003864 SizeType = UnsignedLong;
Chris Lattner8b290212010-04-22 17:48:00 +00003865 IntPtrType = SignedLong;
3866 PtrDiffType = SignedLong;
Eli Friedman4e91899e2012-11-27 02:58:24 +00003867 ProcessIDType = SignedLong;
Rafael Espindolac55be6d2010-11-09 16:41:02 +00003868 this->UserLabelPrefix = "";
Benjamin Kramerd0b9f092012-11-08 12:59:15 +00003869 this->TLSSupported = false;
Eli Friedman04831922010-08-22 01:00:03 +00003870 }
Craig Topper3164f332014-03-11 03:39:26 +00003871 void getTargetDefines(const LangOptions &Opts,
3872 MacroBuilder &Builder) const override {
Chris Lattnerb986aba2010-04-11 19:29:39 +00003873 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3874 Builder.defineMacro("__INTEL__");
3875 Builder.defineMacro("__HAIKU__");
3876 }
3877};
Chris Lattnerb986aba2010-04-11 19:29:39 +00003878
Alexey Bataevc99b0492015-11-25 09:24:26 +00003879// X86-32 MCU target
3880class MCUX86_32TargetInfo : public X86_32TargetInfo {
3881public:
3882 MCUX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
3883 LongDoubleWidth = 64;
3884 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
3885 }
3886
3887 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
3888 // On MCU we support only C calling convention.
3889 return CC == CC_C ? CCCR_OK : CCCR_Warning;
3890 }
3891
3892 void getTargetDefines(const LangOptions &Opts,
3893 MacroBuilder &Builder) const override {
3894 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3895 Builder.defineMacro("__iamcu");
3896 Builder.defineMacro("__iamcu__");
3897 }
3898};
3899
Douglas Gregor9fabd852011-07-01 22:41:14 +00003900// RTEMS Target
3901template<typename Target>
3902class RTEMSTargetInfo : public OSTargetInfo<Target> {
3903protected:
Craig Topper3164f332014-03-11 03:39:26 +00003904 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
3905 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003906 // RTEMS defines; list based off of gcc output
3907
Douglas Gregor9fabd852011-07-01 22:41:14 +00003908 Builder.defineMacro("__rtems__");
3909 Builder.defineMacro("__ELF__");
3910 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003911
Douglas Gregor9fabd852011-07-01 22:41:14 +00003912public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003913 RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
3914 this->UserLabelPrefix = "";
Douglas Gregor9fabd852011-07-01 22:41:14 +00003915
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003916 switch (Triple.getArch()) {
3917 default:
3918 case llvm::Triple::x86:
3919 // this->MCountName = ".mcount";
3920 break;
3921 case llvm::Triple::mips:
3922 case llvm::Triple::mipsel:
3923 case llvm::Triple::ppc:
3924 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +00003925 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003926 // this->MCountName = "_mcount";
3927 break;
3928 case llvm::Triple::arm:
3929 // this->MCountName = "__mcount";
3930 break;
Douglas Gregor9fabd852011-07-01 22:41:14 +00003931 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003932 }
Douglas Gregor9fabd852011-07-01 22:41:14 +00003933};
3934
Douglas Gregor9fabd852011-07-01 22:41:14 +00003935// x86-32 RTEMS target
3936class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
3937public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003938 RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003939 SizeType = UnsignedLong;
3940 IntPtrType = SignedLong;
3941 PtrDiffType = SignedLong;
3942 this->UserLabelPrefix = "";
3943 }
Craig Topper3164f332014-03-11 03:39:26 +00003944 void getTargetDefines(const LangOptions &Opts,
3945 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00003946 X86_32TargetInfo::getTargetDefines(Opts, Builder);
3947 Builder.defineMacro("__INTEL__");
3948 Builder.defineMacro("__rtems__");
3949 }
3950};
Douglas Gregor9fabd852011-07-01 22:41:14 +00003951
Eli Friedman3fd920a2008-08-20 02:34:37 +00003952// x86-64 generic target
3953class X86_64TargetInfo : public X86TargetInfo {
3954public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00003955 X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
David Blaikie40f842d2014-07-10 18:46:15 +00003956 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
David Majnemer8fa8c382015-03-17 23:55:00 +00003957 bool IsWinCOFF =
3958 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
Zinovy Nis1db95732014-07-10 15:27:19 +00003959 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00003960 LongDoubleWidth = 128;
3961 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00003962 LargeArrayMinWidth = 128;
3963 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00003964 SuitableAlign = 128;
Zinovy Nis1db95732014-07-10 15:27:19 +00003965 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
3966 PtrDiffType = IsX32 ? SignedInt : SignedLong;
3967 IntPtrType = IsX32 ? SignedInt : SignedLong;
3968 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Zinovy Nis1db95732014-07-10 15:27:19 +00003969 Int64Type = IsX32 ? SignedLongLong : SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00003970 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00003971
Eric Christopher917e9522014-11-18 22:36:15 +00003972 // Pointers are 32-bit in x32.
Eric Christopher964a5f32015-08-05 23:48:05 +00003973 DataLayoutString = IsX32 ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
3974 : IsWinCOFF
3975 ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
3976 : "e-m:e-i64:64-f80:128-n8:16:32:64-S128";
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00003977
3978 // Use fpret only for long double.
3979 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003980
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00003981 // Use fp2ret for _Complex long double.
3982 ComplexLongDoubleUsesFP2Ret = true;
3983
Charles Davisc7d5c942015-09-17 20:55:33 +00003984 // Make __builtin_ms_va_list available.
3985 HasBuiltinMSVaList = true;
3986
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003987 // x86-64 has atomics up to 16 bytes.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00003988 MaxAtomicPromoteWidth = 128;
Tim Northover1471cb12014-07-02 10:25:45 +00003989 MaxAtomicInlineWidth = 128;
Chris Lattner10a5b382007-01-29 05:24:35 +00003990 }
Craig Topper3164f332014-03-11 03:39:26 +00003991 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00003992 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson5fa3f342007-11-24 23:38:12 +00003993 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00003994
Craig Topper3164f332014-03-11 03:39:26 +00003995 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00003996 if (RegNo == 0) return 0;
3997 if (RegNo == 1) return 1;
3998 return -1;
3999 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004000
Craig Topper3164f332014-03-11 03:39:26 +00004001 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Charles Davisb5a214e2013-08-30 04:39:01 +00004002 return (CC == CC_C ||
Reid Kleckner80944df2014-10-31 22:00:51 +00004003 CC == CC_X86VectorCall ||
Charles Davisb5a214e2013-08-30 04:39:01 +00004004 CC == CC_IntelOclBicc ||
4005 CC == CC_X86_64Win64) ? CCCR_OK : CCCR_Warning;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004006 }
4007
Craig Topper3164f332014-03-11 03:39:26 +00004008 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00004009 return CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004010 }
4011
Pavel Chupinfd223e12014-08-04 12:39:43 +00004012 // for x32 we need it here explicitly
4013 bool hasInt128Type() const override { return true; }
Akira Hatanaka8c26ea62015-11-18 00:15:28 +00004014
4015 bool validateGlobalRegisterVariable(StringRef RegName,
4016 unsigned RegSize,
4017 bool &HasSizeMismatch) const override {
4018 // rsp and rbp are the only 64-bit registers the x86 backend can currently
4019 // handle.
4020 if (RegName.equals("rsp") || RegName.equals("rbp")) {
4021 // Check that the register size is 64-bit.
4022 HasSizeMismatch = RegSize != 64;
4023 return true;
4024 }
4025
4026 // Check if the register is a 32-bit register the backend can handle.
4027 return X86TargetInfo::validateGlobalRegisterVariable(RegName, RegSize,
4028 HasSizeMismatch);
4029 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00004030};
Eli Friedman3fd920a2008-08-20 02:34:37 +00004031
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004032// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004033class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004034public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004035 WindowsX86_64TargetInfo(const llvm::Triple &Triple)
4036 : WindowsTargetInfo<X86_64TargetInfo>(Triple) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004037 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00004038 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00004039 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00004040 IntMaxType = SignedLongLong;
Nate Begeman6e8865a2010-07-21 02:02:56 +00004041 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00004042 SizeType = UnsignedLongLong;
4043 PtrDiffType = SignedLongLong;
4044 IntPtrType = SignedLongLong;
NAKAMURA Takumif7c30222011-01-17 22:56:08 +00004045 this->UserLabelPrefix = "";
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004046 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004047
Craig Topper3164f332014-03-11 03:39:26 +00004048 void getTargetDefines(const LangOptions &Opts,
4049 MacroBuilder &Builder) const override {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004050 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004051 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004052 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004053
Craig Topper3164f332014-03-11 03:39:26 +00004054 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004055 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00004056 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004057
Craig Topper3164f332014-03-11 03:39:26 +00004058 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004059 switch (CC) {
4060 case CC_X86StdCall:
4061 case CC_X86ThisCall:
4062 case CC_X86FastCall:
4063 return CCCR_Ignore;
4064 case CC_C:
4065 case CC_X86VectorCall:
4066 case CC_IntelOclBicc:
4067 case CC_X86_64SysV:
4068 return CCCR_OK;
4069 default:
4070 return CCCR_Warning;
4071 }
Charles Davisb5a214e2013-08-30 04:39:01 +00004072 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004073};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004074
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004075// x86-64 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00004076class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004077public:
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00004078 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple)
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004079 : WindowsX86_64TargetInfo(Triple) {
Eli Friedman015d6282011-03-22 21:25:11 +00004080 LongDoubleWidth = LongDoubleAlign = 64;
4081 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004082 }
Craig Topper3164f332014-03-11 03:39:26 +00004083 void getTargetDefines(const LangOptions &Opts,
4084 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004085 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4086 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
David Majnemerb856e8f2015-07-26 23:17:29 +00004087 Builder.defineMacro("_M_X64", "100");
4088 Builder.defineMacro("_M_AMD64", "100");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004089 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004090};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004091
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004092// x86-64 MinGW target
4093class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
4094public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004095 MinGWX86_64TargetInfo(const llvm::Triple &Triple)
Reid Kleckner11a17192015-10-28 22:29:52 +00004096 : WindowsX86_64TargetInfo(Triple) {
4097 // Mingw64 rounds long double size and alignment up to 16 bytes, but sticks
4098 // with x86 FP ops. Weird.
4099 LongDoubleWidth = LongDoubleAlign = 128;
4100 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended;
4101 }
4102
Craig Topper3164f332014-03-11 03:39:26 +00004103 void getTargetDefines(const LangOptions &Opts,
4104 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004105 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004106 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004107 Builder.defineMacro("__MINGW64__");
Reid Kleckner47606832014-04-21 20:58:00 +00004108 addMinGWDefines(Opts, Builder);
Reid Klecknere070b992014-11-14 02:01:10 +00004109
4110 // GCC defines this macro when it is using __gxx_personality_seh0.
4111 if (!Opts.SjLjExceptions)
4112 Builder.defineMacro("__SEH__");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004113 }
4114};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004115
Yaron Kerend030d112015-07-22 17:38:19 +00004116// x86-64 Cygwin target
4117class CygwinX86_64TargetInfo : public X86_64TargetInfo {
4118public:
4119 CygwinX86_64TargetInfo(const llvm::Triple &Triple)
4120 : X86_64TargetInfo(Triple) {
4121 TLSSupported = false;
4122 WCharType = UnsignedShort;
4123 }
4124 void getTargetDefines(const LangOptions &Opts,
4125 MacroBuilder &Builder) const override {
4126 X86_64TargetInfo::getTargetDefines(Opts, Builder);
4127 Builder.defineMacro("__x86_64__");
4128 Builder.defineMacro("__CYGWIN__");
4129 Builder.defineMacro("__CYGWIN64__");
4130 addCygMingDefines(Opts, Builder);
4131 DefineStd(Builder, "unix", Opts);
4132 if (Opts.CPlusPlus)
4133 Builder.defineMacro("_GNU_SOURCE");
4134
4135 // GCC defines this macro when it is using __gxx_personality_seh0.
4136 if (!Opts.SjLjExceptions)
4137 Builder.defineMacro("__SEH__");
4138 }
4139};
4140
Eli Friedman2857ccb2009-07-01 03:36:11 +00004141class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
4142public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004143 DarwinX86_64TargetInfo(const llvm::Triple &Triple)
4144 : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman2857ccb2009-07-01 03:36:11 +00004145 Int64Type = SignedLongLong;
Tim Northovera2ee4332014-03-29 15:09:45 +00004146 // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
4147 llvm::Triple T = llvm::Triple(Triple);
Bob Wilson946c04c2014-10-19 02:19:27 +00004148 if (T.isiOS())
Tim Northovera2ee4332014-03-29 15:09:45 +00004149 UseSignedCharForObjCBool = false;
Eric Christopher964a5f32015-08-05 23:48:05 +00004150 DataLayoutString = "e-m:o-i64:64-f80:128-n8:16:32:64-S128";
Eli Friedman2857ccb2009-07-01 03:36:11 +00004151 }
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004152
4153 bool handleTargetFeatures(std::vector<std::string> &Features,
4154 DiagnosticsEngine &Diags) override {
4155 if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
4156 Diags))
4157 return false;
Ahmed Bougacha02b7b562015-08-27 22:42:12 +00004158 // We now know the features we have: we can decide how to align vectors.
4159 MaxVectorAlign =
4160 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004161 return true;
4162 }
Eli Friedman2857ccb2009-07-01 03:36:11 +00004163};
Eli Friedman2857ccb2009-07-01 03:36:11 +00004164
Eli Friedman245f2292009-07-05 22:31:18 +00004165class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
4166public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004167 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
4168 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
Eli Friedman245f2292009-07-05 22:31:18 +00004169 IntMaxType = SignedLongLong;
Eli Friedman245f2292009-07-05 22:31:18 +00004170 Int64Type = SignedLongLong;
4171 }
4172};
Eli Friedman245f2292009-07-05 22:31:18 +00004173
Eli Friedman9fa28852012-08-08 23:57:20 +00004174class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
4175public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004176 BitrigX86_64TargetInfo(const llvm::Triple &Triple)
4177 : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
4178 IntMaxType = SignedLongLong;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004179 Int64Type = SignedLongLong;
Eli Friedman9fa28852012-08-08 23:57:20 +00004180 }
4181};
Tim Northover9bb857a2013-01-31 12:13:10 +00004182
Eli Friedmanf05b7722008-08-20 07:44:10 +00004183class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004184 // Possible FPU choices.
4185 enum FPUMode {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004186 VFP2FPU = (1 << 0),
4187 VFP3FPU = (1 << 1),
4188 VFP4FPU = (1 << 2),
Bernard Ogdenda13af32013-10-24 18:32:51 +00004189 NeonFPU = (1 << 3),
4190 FPARMV8 = (1 << 4)
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004191 };
4192
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004193 // Possible HWDiv features.
4194 enum HWDivMode {
4195 HWDivThumb = (1 << 0),
4196 HWDivARM = (1 << 1)
4197 };
4198
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004199 static bool FPUModeIsVFP(FPUMode Mode) {
Bernard Ogdenda13af32013-10-24 18:32:51 +00004200 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004201 }
4202
4203 static const TargetInfo::GCCRegAlias GCCRegAliases[];
4204 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004205
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004206 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004207
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004208 StringRef CPUProfile;
4209 StringRef CPUAttr;
4210
Rafael Espindolaeb265472013-08-21 21:59:03 +00004211 enum {
4212 FP_Default,
4213 FP_VFP,
4214 FP_Neon
4215 } FPMath;
4216
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004217 unsigned ArchISA;
Renato Goline84b0002015-10-08 16:43:26 +00004218 unsigned ArchKind = llvm::ARM::AK_ARMV4T;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004219 unsigned ArchProfile;
4220 unsigned ArchVersion;
4221
Bernard Ogdenda13af32013-10-24 18:32:51 +00004222 unsigned FPU : 5;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004223
Logan Chien57086ce2012-10-10 06:56:20 +00004224 unsigned IsAAPCS : 1;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004225 unsigned HWDiv : 2;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004226
4227 // Initialized via features.
4228 unsigned SoftFloat : 1;
4229 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00004230
Bernard Ogden18b57012013-10-29 09:47:51 +00004231 unsigned CRC : 1;
Tim Northover02e38602014-02-03 17:28:04 +00004232 unsigned Crypto : 1;
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004233 unsigned DSP : 1;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004234 unsigned Unaligned : 1;
4235
4236 enum {
4237 LDREX_B = (1 << 0), /// byte (8-bit)
4238 LDREX_H = (1 << 1), /// half (16-bit)
4239 LDREX_W = (1 << 2), /// word (32-bit)
4240 LDREX_D = (1 << 3), /// double (64-bit)
4241 };
4242
4243 uint32_t LDREX;
Bernard Ogden18b57012013-10-29 09:47:51 +00004244
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004245 // ACLE 6.5.1 Hardware floating point
4246 enum {
4247 HW_FP_HP = (1 << 1), /// half (16-bit)
4248 HW_FP_SP = (1 << 2), /// single (32-bit)
4249 HW_FP_DP = (1 << 3), /// double (64-bit)
4250 };
4251 uint32_t HW_FP;
4252
Chris Lattner5cc15e02010-03-03 19:03:45 +00004253 static const Builtin::Info BuiltinInfo[];
4254
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004255 void setABIAAPCS() {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004256 IsAAPCS = true;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004257
4258 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
Rafael Espindolac418ae92014-01-03 19:22:05 +00004259 const llvm::Triple &T = getTriple();
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004260
Renato Golin9ba39232015-02-27 16:35:48 +00004261 // size_t is unsigned long on MachO-derived environments, NetBSD and Bitrig.
4262 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
4263 T.getOS() == llvm::Triple::Bitrig)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004264 SizeType = UnsignedLong;
4265 else
4266 SizeType = UnsignedInt;
4267
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00004268 switch (T.getOS()) {
4269 case llvm::Triple::NetBSD:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004270 WCharType = SignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00004271 break;
4272 case llvm::Triple::Win32:
4273 WCharType = UnsignedShort;
4274 break;
4275 case llvm::Triple::Linux:
4276 default:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004277 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
4278 WCharType = UnsignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00004279 break;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004280 }
4281
4282 UseBitFieldTypeAlignment = true;
4283
4284 ZeroLengthBitfieldBoundary = 0;
4285
Tim Northover147cd2f2014-10-14 22:12:21 +00004286 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
4287 // so set preferred for small types to 32.
4288 if (T.isOSBinFormatMachO()) {
Eric Christopher964a5f32015-08-05 23:48:05 +00004289 DataLayoutString =
Tim Northover147cd2f2014-10-14 22:12:21 +00004290 BigEndian ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4291 : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
4292 } else if (T.isOSWindows()) {
Tim Northover147cd2f2014-10-14 22:12:21 +00004293 assert(!BigEndian && "Windows on ARM does not support big endian");
Eric Christopher964a5f32015-08-05 23:48:05 +00004294 DataLayoutString = "e"
4295 "-m:w"
4296 "-p:32:32"
4297 "-i64:64"
4298 "-v128:64:128"
4299 "-a:0:32"
4300 "-n32"
4301 "-S64";
Derek Schuff6ab52fa2015-03-30 20:31:33 +00004302 } else if (T.isOSNaCl()) {
4303 assert(!BigEndian && "NaCl on ARM does not support big endian");
Eric Christopher964a5f32015-08-05 23:48:05 +00004304 DataLayoutString = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004305 } else {
Eric Christopher964a5f32015-08-05 23:48:05 +00004306 DataLayoutString =
Tim Northover147cd2f2014-10-14 22:12:21 +00004307 BigEndian ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
4308 : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004309 }
4310
4311 // FIXME: Enumerated types are variable width in straight AAPCS.
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004312 }
4313
Tim Northover5627d392015-10-30 16:30:45 +00004314 void setABIAPCS(bool IsAAPCS16) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00004315 const llvm::Triple &T = getTriple();
4316
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004317 IsAAPCS = false;
4318
Tim Northover5627d392015-10-30 16:30:45 +00004319 if (IsAAPCS16)
4320 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
4321 else
4322 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004323
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004324 // size_t is unsigned int on FreeBSD.
Rafael Espindolac418ae92014-01-03 19:22:05 +00004325 if (T.getOS() == llvm::Triple::FreeBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00004326 SizeType = UnsignedInt;
4327 else
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004328 SizeType = UnsignedLong;
4329
4330 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
4331 WCharType = SignedInt;
4332
4333 // Do not respect the alignment of bit-field types when laying out
4334 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
4335 UseBitFieldTypeAlignment = false;
4336
4337 /// gcc forces the alignment to 4 bytes, regardless of the type of the
4338 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
4339 /// gcc.
4340 ZeroLengthBitfieldBoundary = 32;
4341
Tim Northover5627d392015-10-30 16:30:45 +00004342 if (T.isOSBinFormatMachO() && IsAAPCS16) {
4343 assert(!BigEndian && "AAPCS16 does not support big-endian");
4344 DataLayoutString = "e-m:o-p:32:32-i64:64-a:0:32-n32-S128";
4345 } else if (T.isOSBinFormatMachO())
Eric Christopher964a5f32015-08-05 23:48:05 +00004346 DataLayoutString =
Tim Northover147cd2f2014-10-14 22:12:21 +00004347 BigEndian
4348 ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4349 : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32";
4350 else
Eric Christopher964a5f32015-08-05 23:48:05 +00004351 DataLayoutString =
Tim Northover147cd2f2014-10-14 22:12:21 +00004352 BigEndian
4353 ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
4354 : "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 +00004355
4356 // FIXME: Override "preferred align" for double and long long.
4357 }
4358
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004359 void setArchInfo() {
4360 StringRef ArchName = getTriple().getArchName();
4361
Renato Goline84b0002015-10-08 16:43:26 +00004362 ArchISA = llvm::ARM::parseArchISA(ArchName);
4363 CPU = llvm::ARM::getDefaultCPU(ArchName);
4364 unsigned AK = llvm::ARM::parseArch(ArchName);
4365 if (AK != llvm::ARM::AK_INVALID)
4366 ArchKind = AK;
Vladimir Sukharev457d3412015-08-19 14:50:18 +00004367 setArchInfo(ArchKind);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004368 }
4369
Vladimir Sukharev457d3412015-08-19 14:50:18 +00004370 void setArchInfo(unsigned Kind) {
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004371 StringRef SubArch;
4372
4373 // cache TargetParser info
Vladimir Sukharev457d3412015-08-19 14:50:18 +00004374 ArchKind = Kind;
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00004375 SubArch = llvm::ARM::getSubArch(ArchKind);
4376 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
4377 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004378
4379 // cache CPU related strings
4380 CPUAttr = getCPUAttr();
4381 CPUProfile = getCPUProfile();
4382 }
4383
4384 void setAtomic() {
Eric Christopherb093d692015-10-09 18:39:59 +00004385 // when triple does not specify a sub arch,
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004386 // then we are not using inline atomics
Renato Goline84b0002015-10-08 16:43:26 +00004387 bool ShouldUseInlineAtomic =
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004388 (ArchISA == llvm::ARM::IK_ARM && ArchVersion >= 6) ||
4389 (ArchISA == llvm::ARM::IK_THUMB && ArchVersion >= 7);
Eric Christopherb093d692015-10-09 18:39:59 +00004390 // Cortex M does not support 8 byte atomics, while general Thumb2 does.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004391 if (ArchProfile == llvm::ARM::PK_M) {
4392 MaxAtomicPromoteWidth = 32;
4393 if (ShouldUseInlineAtomic)
4394 MaxAtomicInlineWidth = 32;
4395 }
4396 else {
4397 MaxAtomicPromoteWidth = 64;
4398 if (ShouldUseInlineAtomic)
4399 MaxAtomicInlineWidth = 64;
Eric Christopherb093d692015-10-09 18:39:59 +00004400 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004401 }
4402
4403 bool isThumb() const {
4404 return (ArchISA == llvm::ARM::IK_THUMB);
4405 }
4406
4407 bool supportsThumb() const {
4408 return CPUAttr.count('T') || ArchVersion >= 6;
4409 }
4410
4411 bool supportsThumb2() const {
4412 return CPUAttr.equals("6T2") || ArchVersion >= 7;
4413 }
4414
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004415 StringRef getCPUAttr() const {
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004416 // For most sub-arches, the build attribute CPU name is enough.
4417 // For Cortex variants, it's slightly different.
4418 switch(ArchKind) {
4419 default:
Chandler Carruthd96f37a2015-08-30 07:51:18 +00004420 return llvm::ARM::getCPUAttr(ArchKind);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004421 case llvm::ARM::AK_ARMV6M:
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004422 return "6M";
Tim Northover525c73c2015-07-21 21:47:33 +00004423 case llvm::ARM::AK_ARMV7S:
4424 return "7S";
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004425 case llvm::ARM::AK_ARMV7A:
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004426 return "7A";
4427 case llvm::ARM::AK_ARMV7R:
4428 return "7R";
4429 case llvm::ARM::AK_ARMV7M:
4430 return "7M";
4431 case llvm::ARM::AK_ARMV7EM:
4432 return "7EM";
4433 case llvm::ARM::AK_ARMV8A:
4434 return "8A";
4435 case llvm::ARM::AK_ARMV8_1A:
4436 return "8_1A";
4437 }
4438 }
4439
4440 StringRef getCPUProfile() const {
4441 switch(ArchProfile) {
4442 case llvm::ARM::PK_A:
4443 return "A";
4444 case llvm::ARM::PK_R:
4445 return "R";
4446 case llvm::ARM::PK_M:
4447 return "M";
4448 default:
4449 return "";
4450 }
4451 }
4452
Chris Lattner17df24e2008-04-21 18:56:49 +00004453public:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004454 ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
Renato Goline84b0002015-10-08 16:43:26 +00004455 : TargetInfo(Triple), FPMath(FP_Default),
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004456 IsAAPCS(true), LDREX(0), HW_FP(0) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00004457 BigEndian = IsBigEndian;
4458
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00004459 switch (getTriple().getOS()) {
4460 case llvm::Triple::NetBSD:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00004461 PtrDiffType = SignedLong;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00004462 break;
4463 default:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00004464 PtrDiffType = SignedInt;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00004465 break;
4466 }
Chih-Hung Hsiehcda1cd52015-07-24 17:39:13 +00004467
Renato Goline84b0002015-10-08 16:43:26 +00004468 // Cache arch related info.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004469 setArchInfo();
Chih-Hung Hsiehcda1cd52015-07-24 17:39:13 +00004470
Chris Lattner1a8f3942010-04-23 16:29:58 +00004471 // {} in inline assembly are neon specifiers, not assembly variant
4472 // specifiers.
4473 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004474
Eric Christopher0e261882014-12-05 01:06:59 +00004475 // FIXME: This duplicates code from the driver that sets the -target-abi
4476 // option - this code is used if -target-abi isn't passed and should
4477 // be unified in some way.
4478 if (Triple.isOSBinFormatMachO()) {
4479 // The backend is hardwired to assume AAPCS for M-class processors, ensure
4480 // the frontend matches that.
4481 if (Triple.getEnvironment() == llvm::Triple::EABI ||
4482 Triple.getOS() == llvm::Triple::UnknownOS ||
4483 StringRef(CPU).startswith("cortex-m")) {
4484 setABI("aapcs");
Tim Northover5627d392015-10-30 16:30:45 +00004485 } else if (Triple.isWatchOS()) {
4486 setABI("aapcs16");
Eric Christopher0e261882014-12-05 01:06:59 +00004487 } else {
4488 setABI("apcs-gnu");
4489 }
4490 } else if (Triple.isOSWindows()) {
4491 // FIXME: this is invalid for WindowsCE
4492 setABI("aapcs");
4493 } else {
4494 // Select the default based on the platform.
4495 switch (Triple.getEnvironment()) {
4496 case llvm::Triple::Android:
4497 case llvm::Triple::GNUEABI:
4498 case llvm::Triple::GNUEABIHF:
4499 setABI("aapcs-linux");
4500 break;
4501 case llvm::Triple::EABIHF:
4502 case llvm::Triple::EABI:
4503 setABI("aapcs");
4504 break;
Eric Christopher560cc4f2014-12-18 02:08:55 +00004505 case llvm::Triple::GNU:
Renato Goline84b0002015-10-08 16:43:26 +00004506 setABI("apcs-gnu");
4507 break;
Eric Christopher0e261882014-12-05 01:06:59 +00004508 default:
4509 if (Triple.getOS() == llvm::Triple::NetBSD)
4510 setABI("apcs-gnu");
4511 else
4512 setABI("aapcs");
4513 break;
4514 }
4515 }
John McCall86353412010-08-21 22:46:04 +00004516
4517 // ARM targets default to using the ARM C++ ABI.
John McCall359b8852013-01-25 22:30:49 +00004518 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004519
Renato Golin15b86152015-07-03 16:41:13 +00004520 // ARM has atomics up to 8 bytes
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004521 setAtomic();
Rafael Espindola5ab8e2e2015-07-02 15:14:10 +00004522
James Molloya7139222012-03-12 09:14:10 +00004523 // Do force alignment of members that follow zero length bitfields. If
Eric Christopher917e9522014-11-18 22:36:15 +00004524 // the alignment of the zero-length bitfield is greater than the member
4525 // that follows it, `bar', `bar' will be aligned as the type of the
James Molloya7139222012-03-12 09:14:10 +00004526 // zero length bitfield.
4527 UseZeroLengthBitfieldAlignment = true;
Eli Friedmanb5366062008-05-20 14:21:01 +00004528 }
Alexandros Lamprineas73b07612015-07-02 13:21:34 +00004529
Alp Toker4925ba72014-06-07 23:30:42 +00004530 StringRef getABI() const override { return ABI; }
Alexandros Lamprineas73b07612015-07-02 13:21:34 +00004531
Craig Topper3164f332014-03-11 03:39:26 +00004532 bool setABI(const std::string &Name) override {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00004533 ABI = Name;
4534
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00004535 // The defaults (above) are for AAPCS, check if we need to change them.
4536 //
4537 // FIXME: We need support for -meabi... we could just mangle it into the
4538 // name.
Tim Northover756447a2015-10-30 16:30:36 +00004539 if (Name == "apcs-gnu" || Name == "aapcs16") {
Tim Northover5627d392015-10-30 16:30:45 +00004540 setABIAPCS(Name == "aapcs16");
Rafael Espindolad6c2b722013-12-18 19:47:32 +00004541 return true;
4542 }
4543 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
4544 setABIAAPCS();
4545 return true;
4546 }
4547 return false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00004548 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00004549
Renato Golinf5c4dec2015-05-27 13:33:00 +00004550 // FIXME: This should be based on Arch attributes, not CPU names.
Eric Christopher8c47b422015-10-09 18:39:55 +00004551 bool
4552 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
4553 StringRef CPU,
4554 const std::vector<std::string> &FeaturesVec) const override {
4555
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00004556 std::vector<const char*> TargetFeatures;
Bradley Smithb3501962015-11-16 11:16:36 +00004557 unsigned Arch = llvm::ARM::parseArch(getTriple().getArchName());
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00004558
4559 // get default FPU features
Bradley Smithb3501962015-11-16 11:16:36 +00004560 unsigned FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00004561 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
4562
4563 // get default Extension features
Bradley Smithb3501962015-11-16 11:16:36 +00004564 unsigned Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00004565 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
4566
4567 for (const char *Feature : TargetFeatures)
4568 if (Feature[0] == '+')
Eric Christopherb093d692015-10-09 18:39:59 +00004569 Features[Feature+1] = true;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004570
Eric Christopher007b0a02015-08-28 22:32:01 +00004571 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004572 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004573
Craig Topper3164f332014-03-11 03:39:26 +00004574 bool handleTargetFeatures(std::vector<std::string> &Features,
4575 DiagnosticsEngine &Diags) override {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004576 FPU = 0;
Bernard Ogden18b57012013-10-29 09:47:51 +00004577 CRC = 0;
Tim Northover02e38602014-02-03 17:28:04 +00004578 Crypto = 0;
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004579 DSP = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004580 Unaligned = 1;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004581 SoftFloat = SoftFloatABI = false;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004582 HWDiv = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00004583
Ranjeet Singhac08e532015-06-24 23:39:25 +00004584 // This does not diagnose illegal cases like having both
4585 // "+vfpv2" and "+vfpv3" or having "+neon" and "+fp-only-sp".
4586 uint32_t HW_FP_remove = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00004587 for (const auto &Feature : Features) {
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004588 if (Feature == "+soft-float") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00004589 SoftFloat = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004590 } else if (Feature == "+soft-float-abi") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00004591 SoftFloatABI = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004592 } else if (Feature == "+vfp2") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004593 FPU |= VFP2FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00004594 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004595 } else if (Feature == "+vfp3") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004596 FPU |= VFP3FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00004597 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004598 } else if (Feature == "+vfp4") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004599 FPU |= VFP4FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00004600 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004601 } else if (Feature == "+fp-armv8") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00004602 FPU |= FPARMV8;
Ranjeet Singhac08e532015-06-24 23:39:25 +00004603 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004604 } else if (Feature == "+neon") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004605 FPU |= NeonFPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00004606 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004607 } else if (Feature == "+hwdiv") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004608 HWDiv |= HWDivThumb;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004609 } else if (Feature == "+hwdiv-arm") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004610 HWDiv |= HWDivARM;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004611 } else if (Feature == "+crc") {
Bernard Ogden18b57012013-10-29 09:47:51 +00004612 CRC = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004613 } else if (Feature == "+crypto") {
Tim Northover02e38602014-02-03 17:28:04 +00004614 Crypto = 1;
Artyom Skrobov05d85ae2015-10-23 17:19:02 +00004615 } else if (Feature == "+dsp") {
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004616 DSP = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004617 } else if (Feature == "+fp-only-sp") {
Richard Barton7dacc242015-10-21 10:03:55 +00004618 HW_FP_remove |= HW_FP_DP;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004619 } else if (Feature == "+strict-align") {
4620 Unaligned = 0;
4621 } else if (Feature == "+fp16") {
4622 HW_FP |= HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004623 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00004624 }
Ranjeet Singhac08e532015-06-24 23:39:25 +00004625 HW_FP &= ~HW_FP_remove;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004626
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004627 switch (ArchVersion) {
4628 case 6:
4629 if (ArchProfile == llvm::ARM::PK_M)
4630 LDREX = 0;
4631 else if (ArchKind == llvm::ARM::AK_ARMV6K)
4632 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4633 else
4634 LDREX = LDREX_W;
4635 break;
4636 case 7:
4637 if (ArchProfile == llvm::ARM::PK_M)
4638 LDREX = LDREX_W | LDREX_H | LDREX_B ;
4639 else
4640 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4641 break;
4642 case 8:
4643 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
4644 }
4645
Rafael Espindolaeb265472013-08-21 21:59:03 +00004646 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
4647 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
4648 return false;
4649 }
4650
4651 if (FPMath == FP_Neon)
4652 Features.push_back("+neonfp");
4653 else if (FPMath == FP_VFP)
4654 Features.push_back("-neonfp");
4655
Daniel Dunbar893d4752009-12-19 04:15:38 +00004656 // Remove front-end specific options which the backend handles differently.
Eric Christopher9e172d22015-05-12 01:26:21 +00004657 auto Feature =
4658 std::find(Features.begin(), Features.end(), "+soft-float-abi");
4659 if (Feature != Features.end())
4660 Features.erase(Feature);
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00004661
Rafael Espindolaeb265472013-08-21 21:59:03 +00004662 return true;
Daniel Dunbar893d4752009-12-19 04:15:38 +00004663 }
4664
Craig Topper3164f332014-03-11 03:39:26 +00004665 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004666 return llvm::StringSwitch<bool>(Feature)
4667 .Case("arm", true)
Ben Langmuir587aeaf2015-08-07 01:59:56 +00004668 .Case("aarch32", true)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004669 .Case("softfloat", SoftFloat)
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004670 .Case("thumb", isThumb())
Amara Emerson8c3de542013-09-16 18:07:35 +00004671 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004672 .Case("hwdiv", HWDiv & HWDivThumb)
4673 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004674 .Default(false);
4675 }
Renato Golin15b86152015-07-03 16:41:13 +00004676
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004677 bool setCPU(const std::string &Name) override {
Vladimir Sukharev457d3412015-08-19 14:50:18 +00004678 if (Name != "generic")
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00004679 setArchInfo(llvm::ARM::parseCPUArch(Name));
Vladimir Sukharev457d3412015-08-19 14:50:18 +00004680
Renato Golin15b86152015-07-03 16:41:13 +00004681 if (ArchKind == llvm::ARM::AK_INVALID)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004682 return false;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004683 setAtomic();
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004684 CPU = Name;
4685 return true;
4686 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004687
Craig Topper3164f332014-03-11 03:39:26 +00004688 bool setFPMath(StringRef Name) override;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004689
Craig Topper3164f332014-03-11 03:39:26 +00004690 void getTargetDefines(const LangOptions &Opts,
4691 MacroBuilder &Builder) const override {
Chris Lattnerecd49032009-03-02 22:27:17 +00004692 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004693 Builder.defineMacro("__arm");
4694 Builder.defineMacro("__arm__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00004695
Chris Lattnerecd49032009-03-02 22:27:17 +00004696 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004697 Builder.defineMacro("__REGISTER_PREFIX__", "");
Tim Northover5627d392015-10-30 16:30:45 +00004698
4699 // Unfortunately, __ARM_ARCH_7K__ is now more of an ABI descriptor. The CPU
4700 // happens to be Cortex-A7 though, so it should still get __ARM_ARCH_7A__.
4701 if (getTriple().isWatchOS())
4702 Builder.defineMacro("__ARM_ARCH_7K__", "2");
4703
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004704 if (!CPUAttr.empty())
4705 Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004706
4707 // ACLE 6.4.1 ARM/Thumb instruction set architecture
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004708 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
Benjamin Kramerb42d9a52015-12-24 10:07:37 +00004709 Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004710
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004711 if (ArchVersion >= 8) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004712 // ACLE 6.5.7 Crypto Extension
4713 if (Crypto)
4714 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
4715 // ACLE 6.5.8 CRC32 Extension
4716 if (CRC)
4717 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
4718 // ACLE 6.5.10 Numeric Maximum and Minimum
4719 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
4720 // ACLE 6.5.9 Directed Rounding
4721 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
James Molloy0ffb0932014-09-15 11:25:38 +00004722 }
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004723
4724 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It
4725 // is not defined for the M-profile.
4726 // NOTE that the deffault profile is assumed to be 'A'
4727 if (CPUProfile.empty() || CPUProfile != "M")
4728 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
4729
4730 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supporst the original
4731 // Thumb ISA (including v6-M). It is set to 2 if the core supports the
4732 // Thumb-2 ISA as found in the v6T2 architecture and all v7 architecture.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004733 if (supportsThumb2())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004734 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004735 else if (supportsThumb())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004736 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
4737
4738 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
4739 // instruction set such as ARM or Thumb.
4740 Builder.defineMacro("__ARM_32BIT_STATE", "1");
4741
4742 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
4743
4744 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004745 if (!CPUProfile.empty())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00004746 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004747
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004748 // ACLE 6.4.3 Unaligned access supported in hardware
Eric Christopherb093d692015-10-09 18:39:59 +00004749 if (Unaligned)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004750 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
Eric Christopherb093d692015-10-09 18:39:59 +00004751
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004752 // ACLE 6.4.4 LDREX/STREX
4753 if (LDREX)
4754 Builder.defineMacro("__ARM_FEATURE_LDREX", "0x" + llvm::utohexstr(LDREX));
4755
4756 // ACLE 6.4.5 CLZ
Eric Christopherb093d692015-10-09 18:39:59 +00004757 if (ArchVersion == 5 ||
4758 (ArchVersion == 6 && CPUProfile != "M") ||
4759 ArchVersion > 6)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004760 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
4761
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004762 // ACLE 6.5.1 Hardware Floating Point
4763 if (HW_FP)
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +00004764 Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00004765
Yi Konga44c4d72014-06-27 21:25:42 +00004766 // ACLE predefines.
4767 Builder.defineMacro("__ARM_ACLE", "200");
4768
Oliver Stannarddc2854c2015-09-03 12:40:58 +00004769 // FP16 support (we currently only support IEEE format).
4770 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
4771 Builder.defineMacro("__ARM_FP16_ARGS", "1");
4772
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004773 // ACLE 6.5.3 Fused multiply-accumulate (FMA)
4774 if (ArchVersion >= 7 && (CPUProfile != "M" || CPUAttr == "7EM"))
4775 Builder.defineMacro("__ARM_FEATURE_FMA", "1");
4776
Mike Stump9d54bd72009-04-08 02:07:04 +00004777 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004778
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004779 // FIXME: It's more complicated than this and we don't really support
4780 // interworking.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004781 // Windows on ARM does not "support" interworking
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004782 if (5 <= ArchVersion && ArchVersion <= 8 && !getTriple().isOSWindows())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004783 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004784
David Tweed8f676532012-10-25 13:33:01 +00004785 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Tim Northovere77f78c2013-11-11 19:11:22 +00004786 // Embedded targets on Darwin follow AAPCS, but not EABI.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00004787 // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
4788 if (!getTriple().isOSDarwin() && !getTriple().isOSWindows())
Daniel Dunbarf7124da2012-10-22 18:51:13 +00004789 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004790 Builder.defineMacro("__ARM_PCS", "1");
4791
David Tweed8f676532012-10-25 13:33:01 +00004792 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp")
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00004793 Builder.defineMacro("__ARM_PCS_VFP", "1");
4794 }
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004795
Daniel Dunbar893d4752009-12-19 04:15:38 +00004796 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004797 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00004798
4799 if (CPU == "xscale")
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004800 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004801
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004802 if (isThumb()) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004803 Builder.defineMacro("__THUMBEL__");
4804 Builder.defineMacro("__thumb__");
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004805 if (supportsThumb2())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004806 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004807 }
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004808
4809 // ACLE 6.4.9 32-bit SIMD instructions
4810 if (ArchVersion >= 6 && (CPUProfile != "M" || CPUAttr == "7EM"))
4811 Builder.defineMacro("__ARM_FEATURE_SIMD32", "1");
4812
4813 // ACLE 6.4.10 Hardware Integer Divide
Eric Christopherb093d692015-10-09 18:39:59 +00004814 if (((HWDiv & HWDivThumb) && isThumb()) ||
4815 ((HWDiv & HWDivARM) && !isThumb())) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004816 Builder.defineMacro("__ARM_FEATURE_IDIV", "1");
Silviu Barangaf9671dd2013-10-21 10:54:53 +00004817 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004818 }
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00004819
4820 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004821 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004822
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004823 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004824 Builder.defineMacro("__VFP_FP__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00004825 if (FPU & VFP2FPU)
4826 Builder.defineMacro("__ARM_VFPV2__");
4827 if (FPU & VFP3FPU)
4828 Builder.defineMacro("__ARM_VFPV3__");
4829 if (FPU & VFP4FPU)
4830 Builder.defineMacro("__ARM_VFPV4__");
4831 }
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00004832
Daniel Dunbar0def3d12009-12-21 23:28:17 +00004833 // This only gets set when Neon instructions are actually available, unlike
4834 // the VFP define, hence the soft float and arch check. This is subtly
4835 // different from gcc, we follow the intent which was that it should be set
4836 // when Neon instructions are actually available.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004837 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004838 Builder.defineMacro("__ARM_NEON", "1");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004839 Builder.defineMacro("__ARM_NEON__");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004840 // current AArch32 NEON implementations do not support double-precision
4841 // floating-point even when it is present in VFP.
Eric Christopherb093d692015-10-09 18:39:59 +00004842 Builder.defineMacro("__ARM_NEON_FP",
4843 "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
Tim Northover5bb34ca2013-11-21 12:36:34 +00004844 }
Joey Gouly1e8637b2013-09-18 10:07:09 +00004845
Bradley Smith0f28f0c2014-01-20 10:52:00 +00004846 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
4847 Opts.ShortWChar ? "2" : "4");
4848
4849 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
4850 Opts.ShortEnums ? "1" : "4");
4851
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004852 if (ArchVersion >= 6 && CPUAttr != "6M") {
Weiming Zhao53a797c2013-09-30 22:51:32 +00004853 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4854 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4855 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4856 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
4857 }
Sergey Dmitrouk745f5302014-11-25 08:57:36 +00004858
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004859 // ACLE 6.4.7 DSP instructions
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004860 if (DSP) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004861 Builder.defineMacro("__ARM_FEATURE_DSP", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004862 }
4863
4864 // ACLE 6.4.8 Saturation instructions
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004865 bool SAT = false;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004866 if ((ArchVersion == 6 && CPUProfile != "M") || ArchVersion > 6 ) {
4867 Builder.defineMacro("__ARM_FEATURE_SAT", "1");
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004868 SAT = true;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004869 }
4870
4871 // ACLE 6.4.6 Q (saturation) flag
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00004872 if (DSP || SAT)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00004873 Builder.defineMacro("__ARM_FEATURE_QBIT", "1");
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00004874
4875 if (Opts.UnsafeFPMath)
4876 Builder.defineMacro("__ARM_FP_FAST", "1");
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00004877
4878 if (ArchKind == llvm::ARM::AK_ARMV8_1A)
4879 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
Chris Lattner17df24e2008-04-21 18:56:49 +00004880 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00004881
Craig Topper6c03a542015-10-19 04:51:35 +00004882 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
4883 return llvm::makeArrayRef(BuiltinInfo,
4884 clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin);
Chris Lattner17df24e2008-04-21 18:56:49 +00004885 }
Craig Topper3164f332014-03-11 03:39:26 +00004886 bool isCLZForZeroUndef() const override { return false; }
4887 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northover5627d392015-10-30 16:30:45 +00004888 return IsAAPCS
4889 ? AAPCSABIBuiltinVaList
4890 : (getTriple().isWatchOS() ? TargetInfo::CharPtrBuiltinVaList
4891 : TargetInfo::VoidPtrBuiltinVaList);
Chris Lattner17df24e2008-04-21 18:56:49 +00004892 }
Craig Topperf054e3a2015-10-19 03:52:27 +00004893 ArrayRef<const char *> getGCCRegNames() const override;
4894 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00004895 bool validateAsmConstraint(const char *&Name,
4896 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00004897 switch (*Name) {
Eric Christopher9e491882012-08-16 23:50:41 +00004898 default: break;
Nate Begeman2908fa02008-04-22 05:03:19 +00004899 case 'l': // r0-r7
4900 case 'h': // r8-r15
4901 case 'w': // VFP Floating point register single precision
4902 case 'P': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00004903 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00004904 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00004905 case 'I':
4906 case 'J':
4907 case 'K':
4908 case 'L':
4909 case 'M':
4910 // FIXME
4911 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00004912 case 'Q': // A memory address that is a single base register.
4913 Info.setAllowsMemory();
4914 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004915 case 'U': // a memory reference...
4916 switch (Name[1]) {
4917 case 'q': // ...ARMV4 ldrsb
4918 case 'v': // ...VFP load/store (reg+constant offset)
4919 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00004920 case 't': // address valid for load/store opaque types wider
Eric Christopherfd081ca2012-11-14 22:08:59 +00004921 // than 128-bits
Eric Christopherd1048542011-06-17 01:40:49 +00004922 case 'n': // valid address for Neon doubleword vector load/store
4923 case 'm': // valid address for Neon element and structure load/store
4924 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopherfd081ca2012-11-14 22:08:59 +00004925 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004926 Info.setAllowsMemory();
4927 Name++;
4928 return true;
4929 }
Nate Begeman2908fa02008-04-22 05:03:19 +00004930 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004931 return false;
4932 }
Craig Topper3164f332014-03-11 03:39:26 +00004933 std::string convertConstraint(const char *&Constraint) const override {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004934 std::string R;
4935 switch (*Constraint) {
4936 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00004937 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004938 Constraint++;
4939 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00004940 case 'p': // 'p' should be translated to 'r' by default.
4941 R = std::string("r");
4942 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004943 default:
4944 return std::string(1, *Constraint);
4945 }
4946 return R;
4947 }
Akira Hatanaka987f1862014-08-22 06:05:21 +00004948 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00004949 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00004950 std::string &SuggestedModifier) const override {
Bill Wendling3c6591d2012-11-30 23:18:12 +00004951 bool isOutput = (Constraint[0] == '=');
Bill Wendling05175082012-11-30 23:46:56 +00004952 bool isInOut = (Constraint[0] == '+');
Bill Wendling3c6591d2012-11-30 23:18:12 +00004953
Bill Wendling9d1ee112012-10-25 23:28:48 +00004954 // Strip off constraint modifiers.
4955 while (Constraint[0] == '=' ||
4956 Constraint[0] == '+' ||
4957 Constraint[0] == '&')
4958 Constraint = Constraint.substr(1);
4959
4960 switch (Constraint[0]) {
4961 default: break;
4962 case 'r': {
4963 switch (Modifier) {
4964 default:
Tim Northover8f24b172013-12-08 15:24:55 +00004965 return (isInOut || isOutput || Size <= 64);
Bill Wendling9d1ee112012-10-25 23:28:48 +00004966 case 'q':
4967 // A register of size 32 cannot fit a vector type.
4968 return false;
4969 }
4970 }
4971 }
4972
4973 return true;
4974 }
Craig Topper3164f332014-03-11 03:39:26 +00004975 const char *getClobbers() const override {
Eli Friedmanf05b7722008-08-20 07:44:10 +00004976 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00004977 return "";
4978 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004979
Craig Topper3164f332014-03-11 03:39:26 +00004980 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004981 return (CC == CC_AAPCS || CC == CC_AAPCS_VFP) ? CCCR_OK : CCCR_Warning;
4982 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00004983
Craig Topper3164f332014-03-11 03:39:26 +00004984 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00004985 if (RegNo == 0) return 0;
4986 if (RegNo == 1) return 1;
4987 return -1;
4988 }
Matthias Braund1e2fad2015-07-17 00:15:22 +00004989
4990 bool hasSjLjLowering() const override {
4991 return true;
4992 }
Chris Lattner17df24e2008-04-21 18:56:49 +00004993};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00004994
Rafael Espindolaeb265472013-08-21 21:59:03 +00004995bool ARMTargetInfo::setFPMath(StringRef Name) {
4996 if (Name == "neon") {
4997 FPMath = FP_Neon;
4998 return true;
4999 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
5000 Name == "vfp4") {
5001 FPMath = FP_VFP;
5002 return true;
5003 }
5004 return false;
5005}
5006
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005007const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005008 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005009 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005010 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
5011
5012 // Float registers
5013 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
5014 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
5015 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005016 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005017
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005018 // Double registers
5019 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
5020 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00005021 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
5022 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005023
5024 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00005025 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
5026 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005027};
5028
Craig Topperf054e3a2015-10-19 03:52:27 +00005029ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const {
5030 return llvm::makeArrayRef(GCCRegNames);
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005031}
5032
5033const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005034 { { "a1" }, "r0" },
5035 { { "a2" }, "r1" },
5036 { { "a3" }, "r2" },
5037 { { "a4" }, "r3" },
5038 { { "v1" }, "r4" },
5039 { { "v2" }, "r5" },
5040 { { "v3" }, "r6" },
5041 { { "v4" }, "r7" },
5042 { { "v5" }, "r8" },
5043 { { "v6", "rfp" }, "r9" },
5044 { { "sl" }, "r10" },
5045 { { "fp" }, "r11" },
5046 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00005047 { { "r13" }, "sp" },
5048 { { "r14" }, "lr" },
5049 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005050 // The S, D and Q registers overlap, but aren't really aliases; we
5051 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005052};
5053
Craig Topperf054e3a2015-10-19 03:52:27 +00005054ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const {
5055 return llvm::makeArrayRef(GCCRegAliases);
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005056}
Chris Lattner5cc15e02010-03-03 19:03:45 +00005057
5058const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00005059#define BUILTIN(ID, TYPE, ATTRS) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005060 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005061#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5062 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Tim Northovera2ee4332014-03-29 15:09:45 +00005063#include "clang/Basic/BuiltinsNEON.def"
Tim Northoverc322f832014-01-30 14:47:51 +00005064
Craig Topper07d3b622015-08-07 05:14:44 +00005065#define BUILTIN(ID, TYPE, ATTRS) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005066 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005067#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005068 { #ID, TYPE, ATTRS, nullptr, LANG, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005069#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5070 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Chris Lattner5cc15e02010-03-03 19:03:45 +00005071#include "clang/Basic/BuiltinsARM.def"
5072};
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005073
5074class ARMleTargetInfo : public ARMTargetInfo {
5075public:
5076 ARMleTargetInfo(const llvm::Triple &Triple)
5077 : ARMTargetInfo(Triple, false) { }
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005078 void getTargetDefines(const LangOptions &Opts,
5079 MacroBuilder &Builder) const override {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005080 Builder.defineMacro("__ARMEL__");
5081 ARMTargetInfo::getTargetDefines(Opts, Builder);
5082 }
5083};
5084
5085class ARMbeTargetInfo : public ARMTargetInfo {
5086public:
5087 ARMbeTargetInfo(const llvm::Triple &Triple)
5088 : ARMTargetInfo(Triple, true) { }
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005089 void getTargetDefines(const LangOptions &Opts,
5090 MacroBuilder &Builder) const override {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005091 Builder.defineMacro("__ARMEB__");
5092 Builder.defineMacro("__ARM_BIG_ENDIAN");
5093 ARMTargetInfo::getTargetDefines(Opts, Builder);
5094 }
5095};
Chris Lattner17df24e2008-04-21 18:56:49 +00005096
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005097class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
5098 const llvm::Triple Triple;
5099public:
5100 WindowsARMTargetInfo(const llvm::Triple &Triple)
5101 : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
5102 TLSSupported = false;
5103 WCharType = UnsignedShort;
5104 SizeType = UnsignedInt;
5105 UserLabelPrefix = "";
5106 }
5107 void getVisualStudioDefines(const LangOptions &Opts,
5108 MacroBuilder &Builder) const {
5109 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
5110
5111 // FIXME: this is invalid for WindowsCE
5112 Builder.defineMacro("_M_ARM_NT", "1");
5113 Builder.defineMacro("_M_ARMT", "_M_ARM");
5114 Builder.defineMacro("_M_THUMB", "_M_ARM");
5115
5116 assert((Triple.getArch() == llvm::Triple::arm ||
5117 Triple.getArch() == llvm::Triple::thumb) &&
5118 "invalid architecture for Windows ARM target info");
5119 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5120 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
5121
5122 // TODO map the complete set of values
5123 // 31: VFPv3 40: VFPv4
5124 Builder.defineMacro("_M_ARM_FP", "31");
5125 }
Saleem Abdulrasool521cec82014-06-29 23:05:41 +00005126 BuiltinVaListKind getBuiltinVaListKind() const override {
5127 return TargetInfo::CharPtrBuiltinVaList;
5128 }
Martell Malone7ccda3c2015-08-14 18:00:09 +00005129 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
5130 switch (CC) {
5131 case CC_X86StdCall:
5132 case CC_X86ThisCall:
5133 case CC_X86FastCall:
5134 case CC_X86VectorCall:
5135 return CCCR_Ignore;
5136 case CC_C:
5137 return CCCR_OK;
5138 default:
5139 return CCCR_Warning;
5140 }
5141 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005142};
5143
5144// Windows ARM + Itanium C++ ABI Target
5145class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
5146public:
5147 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple)
5148 : WindowsARMTargetInfo(Triple) {
5149 TheCXXABI.set(TargetCXXABI::GenericARM);
5150 }
5151
5152 void getTargetDefines(const LangOptions &Opts,
5153 MacroBuilder &Builder) const override {
5154 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5155
5156 if (Opts.MSVCCompat)
5157 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5158 }
5159};
5160
5161// Windows ARM, MS (C++) ABI
5162class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
5163public:
5164 MicrosoftARMleTargetInfo(const llvm::Triple &Triple)
5165 : WindowsARMTargetInfo(Triple) {
5166 TheCXXABI.set(TargetCXXABI::Microsoft);
5167 }
5168
5169 void getTargetDefines(const LangOptions &Opts,
5170 MacroBuilder &Builder) const override {
5171 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5172 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
5173 }
5174};
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005175
Yaron Keren321249c2015-07-15 13:32:23 +00005176// ARM MinGW target
5177class MinGWARMTargetInfo : public WindowsARMTargetInfo {
5178public:
5179 MinGWARMTargetInfo(const llvm::Triple &Triple)
5180 : WindowsARMTargetInfo(Triple) {
5181 TheCXXABI.set(TargetCXXABI::GenericARM);
5182 }
5183
5184 void getTargetDefines(const LangOptions &Opts,
5185 MacroBuilder &Builder) const override {
5186 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
5187 DefineStd(Builder, "WIN32", Opts);
5188 DefineStd(Builder, "WINNT", Opts);
5189 Builder.defineMacro("_ARM_");
5190 addMinGWDefines(Opts, Builder);
5191 }
5192};
5193
5194// ARM Cygwin target
5195class CygwinARMTargetInfo : public ARMleTargetInfo {
5196public:
5197 CygwinARMTargetInfo(const llvm::Triple &Triple) : ARMleTargetInfo(Triple) {
5198 TLSSupported = false;
5199 WCharType = UnsignedShort;
5200 DoubleAlign = LongLongAlign = 64;
Eric Christopher964a5f32015-08-05 23:48:05 +00005201 DataLayoutString = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64";
Yaron Keren321249c2015-07-15 13:32:23 +00005202 }
5203 void getTargetDefines(const LangOptions &Opts,
5204 MacroBuilder &Builder) const override {
5205 ARMleTargetInfo::getTargetDefines(Opts, Builder);
5206 Builder.defineMacro("_ARM_");
5207 Builder.defineMacro("__CYGWIN__");
5208 Builder.defineMacro("__CYGWIN32__");
5209 DefineStd(Builder, "unix", Opts);
5210 if (Opts.CPlusPlus)
5211 Builder.defineMacro("_GNU_SOURCE");
5212 }
5213};
5214
Mike Stump11289f42009-09-09 15:08:12 +00005215class DarwinARMTargetInfo :
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005216 public DarwinTargetInfo<ARMleTargetInfo> {
Torok Edwinb2b37c62009-06-30 17:10:35 +00005217protected:
Craig Topper3164f332014-03-11 03:39:26 +00005218 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
5219 MacroBuilder &Builder) const override {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00005220 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00005221 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00005222
Torok Edwinb2b37c62009-06-30 17:10:35 +00005223public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005224 DarwinARMTargetInfo(const llvm::Triple &Triple)
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005225 : DarwinTargetInfo<ARMleTargetInfo>(Triple) {
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00005226 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00005227 // iOS always has 64-bit atomic instructions.
Eric Christopher917e9522014-11-18 22:36:15 +00005228 // FIXME: This should be based off of the target features in
5229 // ARMleTargetInfo.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00005230 MaxAtomicInlineWidth = 64;
John McCall359b8852013-01-25 22:30:49 +00005231
Tim Northover5627d392015-10-30 16:30:45 +00005232 if (Triple.isWatchOS()) {
5233 // Darwin on iOS uses a variant of the ARM C++ ABI.
5234 TheCXXABI.set(TargetCXXABI::WatchOS);
5235
5236 // The 32-bit ABI is silent on what ptrdiff_t should be, but given that
5237 // size_t is long, it's a bit weird for it to be int.
5238 PtrDiffType = SignedLong;
5239
5240 // BOOL should be a real boolean on the new ABI
5241 UseSignedCharForObjCBool = false;
5242 } else
5243 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00005244 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00005245};
Eli Friedmanf05b7722008-08-20 07:44:10 +00005246
Tim Northover573cbee2014-05-24 12:52:07 +00005247class AArch64TargetInfo : public TargetInfo {
Eric Christopher964a5f32015-08-05 23:48:05 +00005248 virtual void setDataLayoutString() = 0;
Tim Northovera2ee4332014-03-29 15:09:45 +00005249 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5250 static const char *const GCCRegNames[];
5251
James Molloy75f5f9e2014-04-16 15:33:48 +00005252 enum FPUModeEnum {
5253 FPUMode,
5254 NeonMode
5255 };
5256
5257 unsigned FPU;
Bradley Smith418c5932014-05-02 15:17:51 +00005258 unsigned CRC;
James Molloy75f5f9e2014-04-16 15:33:48 +00005259 unsigned Crypto;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005260 unsigned Unaligned;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00005261 unsigned V8_1A;
James Molloy75f5f9e2014-04-16 15:33:48 +00005262
Tim Northovera2ee4332014-03-29 15:09:45 +00005263 static const Builtin::Info BuiltinInfo[];
5264
5265 std::string ABI;
5266
5267public:
Tim Northover573cbee2014-05-24 12:52:07 +00005268 AArch64TargetInfo(const llvm::Triple &Triple)
Tim Northovera2ee4332014-03-29 15:09:45 +00005269 : TargetInfo(Triple), ABI("aapcs") {
Tim Northover25e8a672014-05-24 12:51:25 +00005270
5271 if (getTriple().getOS() == llvm::Triple::NetBSD) {
5272 WCharType = SignedInt;
5273
5274 // NetBSD apparently prefers consistency across ARM targets to consistency
5275 // across 64-bit targets.
5276 Int64Type = SignedLongLong;
5277 IntMaxType = SignedLongLong;
Tim Northover25e8a672014-05-24 12:51:25 +00005278 } else {
5279 WCharType = UnsignedInt;
5280 Int64Type = SignedLong;
5281 IntMaxType = SignedLong;
Tim Northover25e8a672014-05-24 12:51:25 +00005282 }
5283
Tim Northovera2ee4332014-03-29 15:09:45 +00005284 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00005285 MaxVectorAlign = 128;
Tim Northovera2ee4332014-03-29 15:09:45 +00005286 MaxAtomicInlineWidth = 128;
5287 MaxAtomicPromoteWidth = 128;
5288
Tim Northovera6a19f12015-02-06 01:25:07 +00005289 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
Tim Northovera2ee4332014-03-29 15:09:45 +00005290 LongDoubleFormat = &llvm::APFloat::IEEEquad;
5291
Tim Northovera2ee4332014-03-29 15:09:45 +00005292 // {} in inline assembly are neon specifiers, not assembly variant
5293 // specifiers.
5294 NoAsmVariants = true;
5295
Tim Northover7ad87af2015-01-16 18:44:04 +00005296 // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
5297 // contributes to the alignment of the containing aggregate in the same way
5298 // a plain (non bit-field) member of that type would, without exception for
5299 // zero-sized or anonymous bit-fields."
Tim Northover5627d392015-10-30 16:30:45 +00005300 assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
Tim Northover7ad87af2015-01-16 18:44:04 +00005301 UseZeroLengthBitfieldAlignment = true;
5302
Tim Northover573cbee2014-05-24 12:52:07 +00005303 // AArch64 targets default to using the ARM C++ ABI.
Tim Northovera2ee4332014-03-29 15:09:45 +00005304 TheCXXABI.set(TargetCXXABI::GenericAArch64);
5305 }
5306
Alp Toker4925ba72014-06-07 23:30:42 +00005307 StringRef getABI() const override { return ABI; }
David Blaikie1cbb9712014-11-14 19:09:44 +00005308 bool setABI(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005309 if (Name != "aapcs" && Name != "darwinpcs")
5310 return false;
5311
5312 ABI = Name;
5313 return true;
5314 }
5315
David Blaikie1cbb9712014-11-14 19:09:44 +00005316 bool setCPU(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005317 bool CPUKnown = llvm::StringSwitch<bool>(Name)
James Molloy5e73df52014-04-16 15:06:20 +00005318 .Case("generic", true)
MinSeong Kim50d9c152016-01-05 12:53:24 +00005319 .Cases("cortex-a53", "cortex-a57", "cortex-a72",
5320 "cortex-a35", "exynos-m1", true)
Tim Northovera2ee4332014-03-29 15:09:45 +00005321 .Case("cyclone", true)
5322 .Default(false);
5323 return CPUKnown;
5324 }
5325
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005326 void getTargetDefines(const LangOptions &Opts,
5327 MacroBuilder &Builder) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005328 // Target identification.
Tim Northovera2ee4332014-03-29 15:09:45 +00005329 Builder.defineMacro("__aarch64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00005330
5331 // Target properties.
5332 Builder.defineMacro("_LP64");
5333 Builder.defineMacro("__LP64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00005334
5335 // ACLE predefines. Many can only have one possible value on v8 AArch64.
5336 Builder.defineMacro("__ARM_ACLE", "200");
5337 Builder.defineMacro("__ARM_ARCH", "8");
5338 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
5339
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005340 Builder.defineMacro("__ARM_64BIT_STATE", "1");
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00005341 Builder.defineMacro("__ARM_PCS_AAPCS64", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005342 Builder.defineMacro("__ARM_ARCH_ISA_A64", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00005343
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005344 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
5345 Builder.defineMacro("__ARM_FEATURE_FMA", "1");
5346 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xF");
5347 Builder.defineMacro("__ARM_FEATURE_IDIV", "1"); // As specified in ACLE
James Molloy0ffb0932014-09-15 11:25:38 +00005348 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005349 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
5350 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00005351
5352 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
5353
5354 // 0xe implies support for half, single and double precision operations.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005355 Builder.defineMacro("__ARM_FP", "0xE");
Tim Northovera2ee4332014-03-29 15:09:45 +00005356
5357 // PCS specifies this for SysV variants, which is all we support. Other ABIs
5358 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005359 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
5360 Builder.defineMacro("__ARM_FP16_ARGS", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00005361
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00005362 if (Opts.UnsafeFPMath)
5363 Builder.defineMacro("__ARM_FP_FAST", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00005364
5365 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
5366
5367 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
5368 Opts.ShortEnums ? "1" : "4");
5369
James Molloy75f5f9e2014-04-16 15:33:48 +00005370 if (FPU == NeonMode) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005371 Builder.defineMacro("__ARM_NEON", "1");
James Molloy75f5f9e2014-04-16 15:33:48 +00005372 // 64-bit NEON supports half, single and double precision operations.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005373 Builder.defineMacro("__ARM_NEON_FP", "0xE");
James Molloy75f5f9e2014-04-16 15:33:48 +00005374 }
Tim Northovera2ee4332014-03-29 15:09:45 +00005375
Bradley Smith418c5932014-05-02 15:17:51 +00005376 if (CRC)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005377 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
Bradley Smith418c5932014-05-02 15:17:51 +00005378
James Molloy75f5f9e2014-04-16 15:33:48 +00005379 if (Crypto)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005380 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
5381
5382 if (Unaligned)
5383 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
Reid Klecknerd167d422015-05-06 15:31:46 +00005384
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00005385 if (V8_1A)
5386 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
5387
Reid Klecknerd167d422015-05-06 15:31:46 +00005388 // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8) builtins work.
5389 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
5390 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
5391 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
5392 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Tim Northovera2ee4332014-03-29 15:09:45 +00005393 }
5394
Craig Topper6c03a542015-10-19 04:51:35 +00005395 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
5396 return llvm::makeArrayRef(BuiltinInfo,
5397 clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin);
Tim Northovera2ee4332014-03-29 15:09:45 +00005398 }
5399
David Blaikie1cbb9712014-11-14 19:09:44 +00005400 bool hasFeature(StringRef Feature) const override {
James Molloy75f5f9e2014-04-16 15:33:48 +00005401 return Feature == "aarch64" ||
5402 Feature == "arm64" ||
Ben Langmuir587aeaf2015-08-07 01:59:56 +00005403 Feature == "arm" ||
James Molloy75f5f9e2014-04-16 15:33:48 +00005404 (Feature == "neon" && FPU == NeonMode);
Tim Northovera2ee4332014-03-29 15:09:45 +00005405 }
5406
James Molloy5e73df52014-04-16 15:06:20 +00005407 bool handleTargetFeatures(std::vector<std::string> &Features,
5408 DiagnosticsEngine &Diags) override {
James Molloy75f5f9e2014-04-16 15:33:48 +00005409 FPU = FPUMode;
Bradley Smith418c5932014-05-02 15:17:51 +00005410 CRC = 0;
James Molloy75f5f9e2014-04-16 15:33:48 +00005411 Crypto = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005412 Unaligned = 1;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00005413 V8_1A = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005414
Eric Christopher610fe112015-08-26 08:21:55 +00005415 for (const auto &Feature : Features) {
5416 if (Feature == "+neon")
James Molloy75f5f9e2014-04-16 15:33:48 +00005417 FPU = NeonMode;
Eric Christopher610fe112015-08-26 08:21:55 +00005418 if (Feature == "+crc")
Bradley Smith418c5932014-05-02 15:17:51 +00005419 CRC = 1;
Eric Christopher610fe112015-08-26 08:21:55 +00005420 if (Feature == "+crypto")
James Molloy75f5f9e2014-04-16 15:33:48 +00005421 Crypto = 1;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005422 if (Feature == "+strict-align")
5423 Unaligned = 0;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00005424 if (Feature == "+v8.1a")
5425 V8_1A = 1;
James Molloy75f5f9e2014-04-16 15:33:48 +00005426 }
5427
Eric Christopher964a5f32015-08-05 23:48:05 +00005428 setDataLayoutString();
James Molloy5e73df52014-04-16 15:06:20 +00005429
5430 return true;
5431 }
5432
David Blaikie1cbb9712014-11-14 19:09:44 +00005433 bool isCLZForZeroUndef() const override { return false; }
Tim Northovera2ee4332014-03-29 15:09:45 +00005434
David Blaikie1cbb9712014-11-14 19:09:44 +00005435 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005436 return TargetInfo::AArch64ABIBuiltinVaList;
5437 }
5438
Craig Topperf054e3a2015-10-19 03:52:27 +00005439 ArrayRef<const char *> getGCCRegNames() const override;
5440 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00005441
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005442 bool validateAsmConstraint(const char *&Name,
5443 TargetInfo::ConstraintInfo &Info) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005444 switch (*Name) {
5445 default:
5446 return false;
5447 case 'w': // Floating point and SIMD registers (V0-V31)
5448 Info.setAllowsRegister();
5449 return true;
James Molloy8bdd24b2014-04-23 10:26:19 +00005450 case 'I': // Constant that can be used with an ADD instruction
5451 case 'J': // Constant that can be used with a SUB instruction
5452 case 'K': // Constant that can be used with a 32-bit logical instruction
5453 case 'L': // Constant that can be used with a 64-bit logical instruction
5454 case 'M': // Constant that can be used as a 32-bit MOV immediate
5455 case 'N': // Constant that can be used as a 64-bit MOV immediate
5456 case 'Y': // Floating point constant zero
5457 case 'Z': // Integer constant zero
5458 return true;
5459 case 'Q': // A memory reference with base register and no offset
5460 Info.setAllowsMemory();
5461 return true;
5462 case 'S': // A symbolic address
5463 Info.setAllowsRegister();
5464 return true;
5465 case 'U':
Eric Christopher917e9522014-11-18 22:36:15 +00005466 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
5467 // Utf: A memory address suitable for ldp/stp in TF mode.
5468 // Usa: An absolute symbolic address.
5469 // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
5470 llvm_unreachable("FIXME: Unimplemented support for U* constraints.");
Tim Northovera2ee4332014-03-29 15:09:45 +00005471 case 'z': // Zero register, wzr or xzr
5472 Info.setAllowsRegister();
5473 return true;
5474 case 'x': // Floating point and SIMD registers (V0-V15)
5475 Info.setAllowsRegister();
5476 return true;
Tim Northovera2ee4332014-03-29 15:09:45 +00005477 }
5478 return false;
5479 }
5480
Akira Hatanaka987f1862014-08-22 06:05:21 +00005481 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00005482 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00005483 std::string &SuggestedModifier) const override {
James Molloy8a157bf2014-07-25 10:19:47 +00005484 // Strip off constraint modifiers.
5485 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
5486 Constraint = Constraint.substr(1);
5487
5488 switch (Constraint[0]) {
5489 default:
5490 return true;
5491 case 'z':
5492 case 'r': {
5493 switch (Modifier) {
5494 case 'x':
5495 case 'w':
5496 // For now assume that the person knows what they're
5497 // doing with the modifier.
5498 return true;
5499 default:
5500 // By default an 'r' constraint will be in the 'x'
5501 // registers.
Akira Hatanaka987f1862014-08-22 06:05:21 +00005502 if (Size == 64)
5503 return true;
5504
5505 SuggestedModifier = "w";
5506 return false;
James Molloy8a157bf2014-07-25 10:19:47 +00005507 }
5508 }
5509 }
5510 }
5511
David Blaikie1cbb9712014-11-14 19:09:44 +00005512 const char *getClobbers() const override { return ""; }
Tim Northovera2ee4332014-03-29 15:09:45 +00005513
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00005514 int getEHDataRegisterNumber(unsigned RegNo) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005515 if (RegNo == 0)
5516 return 0;
5517 if (RegNo == 1)
5518 return 1;
5519 return -1;
5520 }
5521};
5522
Tim Northover573cbee2014-05-24 12:52:07 +00005523const char *const AArch64TargetInfo::GCCRegNames[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00005524 // 32-bit Integer registers
5525 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
5526 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
5527 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
5528
5529 // 64-bit Integer registers
5530 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
5531 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
5532 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
5533
5534 // 32-bit floating point regsisters
5535 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10",
5536 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
5537 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
5538
5539 // 64-bit floating point regsisters
5540 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
5541 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
5542 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
5543
5544 // Vector registers
5545 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10",
5546 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
5547 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
5548};
5549
Craig Topperf054e3a2015-10-19 03:52:27 +00005550ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const {
5551 return llvm::makeArrayRef(GCCRegNames);
Tim Northovera2ee4332014-03-29 15:09:45 +00005552}
5553
Tim Northover573cbee2014-05-24 12:52:07 +00005554const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00005555 { { "w31" }, "wsp" },
5556 { { "x29" }, "fp" },
5557 { { "x30" }, "lr" },
5558 { { "x31" }, "sp" },
5559 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
5560 // don't want to substitute one of these for a different-sized one.
5561};
5562
Craig Topperf054e3a2015-10-19 03:52:27 +00005563ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const {
5564 return llvm::makeArrayRef(GCCRegAliases);
Tim Northovera2ee4332014-03-29 15:09:45 +00005565}
5566
Tim Northover573cbee2014-05-24 12:52:07 +00005567const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00005568#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00005569 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Tim Northovera2ee4332014-03-29 15:09:45 +00005570#include "clang/Basic/BuiltinsNEON.def"
5571
5572#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00005573 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Tim Northover573cbee2014-05-24 12:52:07 +00005574#include "clang/Basic/BuiltinsAArch64.def"
Tim Northovera2ee4332014-03-29 15:09:45 +00005575};
James Molloy5e73df52014-04-16 15:06:20 +00005576
Tim Northover573cbee2014-05-24 12:52:07 +00005577class AArch64leTargetInfo : public AArch64TargetInfo {
Eric Christopher964a5f32015-08-05 23:48:05 +00005578 void setDataLayoutString() override {
James Molloy5e73df52014-04-16 15:06:20 +00005579 if (getTriple().isOSBinFormatMachO())
Eric Christopher964a5f32015-08-05 23:48:05 +00005580 DataLayoutString = "e-m:o-i64:64-i128:128-n32:64-S128";
James Molloy5e73df52014-04-16 15:06:20 +00005581 else
Eric Christopher964a5f32015-08-05 23:48:05 +00005582 DataLayoutString = "e-m:e-i64:64-i128:128-n32:64-S128";
James Molloy5e73df52014-04-16 15:06:20 +00005583 }
5584
5585public:
Tim Northover573cbee2014-05-24 12:52:07 +00005586 AArch64leTargetInfo(const llvm::Triple &Triple)
5587 : AArch64TargetInfo(Triple) {
James Molloy5e73df52014-04-16 15:06:20 +00005588 BigEndian = false;
5589 }
5590 void getTargetDefines(const LangOptions &Opts,
5591 MacroBuilder &Builder) const override {
5592 Builder.defineMacro("__AARCH64EL__");
Tim Northover573cbee2014-05-24 12:52:07 +00005593 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00005594 }
5595};
5596
Tim Northover573cbee2014-05-24 12:52:07 +00005597class AArch64beTargetInfo : public AArch64TargetInfo {
Eric Christopher964a5f32015-08-05 23:48:05 +00005598 void setDataLayoutString() override {
James Molloy5e73df52014-04-16 15:06:20 +00005599 assert(!getTriple().isOSBinFormatMachO());
Eric Christopher964a5f32015-08-05 23:48:05 +00005600 DataLayoutString = "E-m:e-i64:64-i128:128-n32:64-S128";
James Molloy5e73df52014-04-16 15:06:20 +00005601 }
5602
5603public:
Tim Northover573cbee2014-05-24 12:52:07 +00005604 AArch64beTargetInfo(const llvm::Triple &Triple)
5605 : AArch64TargetInfo(Triple) { }
James Molloy5e73df52014-04-16 15:06:20 +00005606 void getTargetDefines(const LangOptions &Opts,
5607 MacroBuilder &Builder) const override {
5608 Builder.defineMacro("__AARCH64EB__");
5609 Builder.defineMacro("__AARCH_BIG_ENDIAN");
5610 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northover573cbee2014-05-24 12:52:07 +00005611 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00005612 }
5613};
Tim Northovera2ee4332014-03-29 15:09:45 +00005614
Tim Northover573cbee2014-05-24 12:52:07 +00005615class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
James Molloy5e73df52014-04-16 15:06:20 +00005616protected:
5617 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
5618 MacroBuilder &Builder) const override {
5619 Builder.defineMacro("__AARCH64_SIMD__");
5620 Builder.defineMacro("__ARM64_ARCH_8__");
5621 Builder.defineMacro("__ARM_NEON__");
5622 Builder.defineMacro("__LITTLE_ENDIAN__");
5623 Builder.defineMacro("__REGISTER_PREFIX__", "");
5624 Builder.defineMacro("__arm64", "1");
5625 Builder.defineMacro("__arm64__", "1");
5626
5627 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
5628 }
5629
Tim Northovera2ee4332014-03-29 15:09:45 +00005630public:
Tim Northover573cbee2014-05-24 12:52:07 +00005631 DarwinAArch64TargetInfo(const llvm::Triple &Triple)
5632 : DarwinTargetInfo<AArch64leTargetInfo>(Triple) {
Tim Northovera2ee4332014-03-29 15:09:45 +00005633 Int64Type = SignedLongLong;
5634 WCharType = SignedInt;
5635 UseSignedCharForObjCBool = false;
5636
Tim Northovera6a19f12015-02-06 01:25:07 +00005637 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00005638 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
5639
5640 TheCXXABI.set(TargetCXXABI::iOS64);
5641 }
5642
David Blaikie1cbb9712014-11-14 19:09:44 +00005643 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00005644 return TargetInfo::CharPtrBuiltinVaList;
5645 }
5646};
Tim Northovera2ee4332014-03-29 15:09:45 +00005647
Tony Linthicum76329bf2011-12-12 21:14:55 +00005648// Hexagon abstract base class
5649class HexagonTargetInfo : public TargetInfo {
5650 static const Builtin::Info BuiltinInfo[];
5651 static const char * const GCCRegNames[];
5652 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5653 std::string CPU;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005654 bool HasHVX, HasHVXDouble;
5655
Tony Linthicum76329bf2011-12-12 21:14:55 +00005656public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005657 HexagonTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00005658 BigEndian = false;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005659 DataLayoutString = "e-m:e-p:32:32:32-"
5660 "i64:64:64-i32:32:32-i16:16:16-i1:8:8-"
5661 "f64:64:64-f32:32:32-v64:64:64-v32:32:32-a:0-n16:32";
5662 SizeType = UnsignedInt;
5663 PtrDiffType = SignedInt;
5664 IntPtrType = SignedInt;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005665
5666 // {} in inline assembly are packet specifiers, not assembly variant
5667 // specifiers.
5668 NoAsmVariants = true;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005669
5670 LargeArrayMinWidth = 64;
5671 LargeArrayAlign = 64;
5672 UseBitFieldTypeAlignment = true;
5673 ZeroLengthBitfieldBoundary = 32;
5674 HasHVX = HasHVXDouble = false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005675 }
5676
Craig Topper6c03a542015-10-19 04:51:35 +00005677 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
5678 return llvm::makeArrayRef(BuiltinInfo,
5679 clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005680 }
5681
Craig Topper3164f332014-03-11 03:39:26 +00005682 bool validateAsmConstraint(const char *&Name,
5683 TargetInfo::ConstraintInfo &Info) const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005684 return true;
5685 }
5686
Craig Topper3164f332014-03-11 03:39:26 +00005687 void getTargetDefines(const LangOptions &Opts,
5688 MacroBuilder &Builder) const override;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005689
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005690 bool isCLZForZeroUndef() const override { return false; }
5691
Craig Topper3164f332014-03-11 03:39:26 +00005692 bool hasFeature(StringRef Feature) const override {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005693 return llvm::StringSwitch<bool>(Feature)
5694 .Case("hexagon", true)
5695 .Case("hvx", HasHVX)
5696 .Case("hvx-double", HasHVXDouble)
5697 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005698 }
Craig Topper3164f332014-03-11 03:39:26 +00005699
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005700 bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
5701 StringRef CPU, const std::vector<std::string> &FeaturesVec)
5702 const override;
5703
5704 bool handleTargetFeatures(std::vector<std::string> &Features,
5705 DiagnosticsEngine &Diags) override;
5706
Craig Topper3164f332014-03-11 03:39:26 +00005707 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005708 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005709 }
Craig Topperf054e3a2015-10-19 03:52:27 +00005710 ArrayRef<const char *> getGCCRegNames() const override;
5711 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00005712 const char *getClobbers() const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005713 return "";
5714 }
Sebastian Pop86500282012-01-13 20:37:10 +00005715
5716 static const char *getHexagonCPUSuffix(StringRef Name) {
5717 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop86500282012-01-13 20:37:10 +00005718 .Case("hexagonv4", "4")
Sirish Pande11ebc4e2012-05-10 20:19:54 +00005719 .Case("hexagonv5", "5")
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005720 .Case("hexagonv55", "55")
5721 .Case("hexagonv60", "60")
Craig Topperf1186c52014-05-08 06:41:40 +00005722 .Default(nullptr);
Sebastian Pop86500282012-01-13 20:37:10 +00005723 }
5724
Craig Topper3164f332014-03-11 03:39:26 +00005725 bool setCPU(const std::string &Name) override {
Sebastian Pop86500282012-01-13 20:37:10 +00005726 if (!getHexagonCPUSuffix(Name))
5727 return false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00005728 CPU = Name;
5729 return true;
5730 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005731
5732 int getEHDataRegisterNumber(unsigned RegNo) const override {
5733 return RegNo < 2 ? RegNo : -1;
5734 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005735};
5736
5737void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005738 MacroBuilder &Builder) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005739 Builder.defineMacro("__qdsp6__", "1");
Tony Linthicum76329bf2011-12-12 21:14:55 +00005740 Builder.defineMacro("__hexagon__", "1");
5741
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005742 if (CPU == "hexagonv4") {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005743 Builder.defineMacro("__HEXAGON_V4__");
5744 Builder.defineMacro("__HEXAGON_ARCH__", "4");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005745 if (Opts.HexagonQdsp6Compat) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005746 Builder.defineMacro("__QDSP6_V4__");
5747 Builder.defineMacro("__QDSP6_ARCH__", "4");
5748 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005749 } else if (CPU == "hexagonv5") {
Sirish Pande11ebc4e2012-05-10 20:19:54 +00005750 Builder.defineMacro("__HEXAGON_V5__");
5751 Builder.defineMacro("__HEXAGON_ARCH__", "5");
5752 if(Opts.HexagonQdsp6Compat) {
5753 Builder.defineMacro("__QDSP6_V5__");
5754 Builder.defineMacro("__QDSP6_ARCH__", "5");
5755 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005756 } else if (CPU == "hexagonv60") {
5757 Builder.defineMacro("__HEXAGON_V60__");
5758 Builder.defineMacro("__HEXAGON_ARCH__", "60");
5759 Builder.defineMacro("__QDSP6_V60__");
5760 Builder.defineMacro("__QDSP6_ARCH__", "60");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00005761 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00005762}
5763
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005764bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
5765 DiagnosticsEngine &Diags) {
5766 for (auto &F : Features) {
5767 if (F == "+hvx")
5768 HasHVX = true;
5769 else if (F == "-hvx")
5770 HasHVX = HasHVXDouble = false;
5771 else if (F == "+hvx-double")
5772 HasHVX = HasHVXDouble = true;
5773 else if (F == "-hvx-double")
5774 HasHVXDouble = false;
5775 }
5776 return true;
5777}
5778
5779bool HexagonTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features,
5780 DiagnosticsEngine &Diags, StringRef CPU,
5781 const std::vector<std::string> &FeaturesVec) const {
5782 // Default for v60: -hvx, -hvx-double.
5783 Features["hvx"] = false;
5784 Features["hvx-double"] = false;
5785
5786 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
5787}
5788
5789
5790const char *const HexagonTargetInfo::GCCRegNames[] = {
Tony Linthicum76329bf2011-12-12 21:14:55 +00005791 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5792 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5793 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5794 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
5795 "p0", "p1", "p2", "p3",
5796 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
5797};
5798
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005799ArrayRef<const char*> HexagonTargetInfo::getGCCRegNames() const {
Craig Topperf054e3a2015-10-19 03:52:27 +00005800 return llvm::makeArrayRef(GCCRegNames);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005801}
5802
Tony Linthicum76329bf2011-12-12 21:14:55 +00005803const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
5804 { { "sp" }, "r29" },
5805 { { "fp" }, "r30" },
5806 { { "lr" }, "r31" },
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00005807};
Tony Linthicum76329bf2011-12-12 21:14:55 +00005808
Craig Topperf054e3a2015-10-19 03:52:27 +00005809ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
5810 return llvm::makeArrayRef(GCCRegAliases);
Tony Linthicum76329bf2011-12-12 21:14:55 +00005811}
5812
5813
5814const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00005815#define BUILTIN(ID, TYPE, ATTRS) \
5816 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
5817#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5818 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Tony Linthicum76329bf2011-12-12 21:14:55 +00005819#include "clang/Basic/BuiltinsHexagon.def"
5820};
Tony Linthicum76329bf2011-12-12 21:14:55 +00005821
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005822// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
5823class SparcTargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00005824 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5825 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005826 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00005827public:
Eric Christopher5eaf3812015-05-12 00:04:20 +00005828 SparcTargetInfo(const llvm::Triple &Triple)
5829 : TargetInfo(Triple), SoftFloat(false) {}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005830
Craig Topper3164f332014-03-11 03:39:26 +00005831 bool handleTargetFeatures(std::vector<std::string> &Features,
5832 DiagnosticsEngine &Diags) override {
Eric Christopher5eaf3812015-05-12 00:04:20 +00005833 // The backend doesn't actually handle soft float yet, but in case someone
5834 // is using the support for the front end continue to support it.
Eric Christopherfb481a42015-04-29 23:32:17 +00005835 auto Feature = std::find(Features.begin(), Features.end(), "+soft-float");
5836 if (Feature != Features.end()) {
5837 SoftFloat = true;
5838 Features.erase(Feature);
5839 }
Rafael Espindolaeb265472013-08-21 21:59:03 +00005840 return true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005841 }
Craig Topper3164f332014-03-11 03:39:26 +00005842 void getTargetDefines(const LangOptions &Opts,
5843 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005844 DefineStd(Builder, "sparc", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005845 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00005846
5847 if (SoftFloat)
5848 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00005849 }
Craig Topper3164f332014-03-11 03:39:26 +00005850
5851 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005852 return llvm::StringSwitch<bool>(Feature)
5853 .Case("softfloat", SoftFloat)
5854 .Case("sparc", true)
5855 .Default(false);
5856 }
Craig Topper3164f332014-03-11 03:39:26 +00005857
Craig Topper6c03a542015-10-19 04:51:35 +00005858 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005859 // FIXME: Implement!
Craig Topper6c03a542015-10-19 04:51:35 +00005860 return None;
Gabor Greif49991682008-02-21 16:29:08 +00005861 }
Craig Topper3164f332014-03-11 03:39:26 +00005862 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00005863 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif49991682008-02-21 16:29:08 +00005864 }
Craig Topperf054e3a2015-10-19 03:52:27 +00005865 ArrayRef<const char *> getGCCRegNames() const override;
5866 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00005867 bool validateAsmConstraint(const char *&Name,
5868 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005869 // FIXME: Implement!
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00005870 switch (*Name) {
5871 case 'I': // Signed 13-bit constant
5872 case 'J': // Zero
5873 case 'K': // 32-bit constant with the low 12 bits clear
5874 case 'L': // A constant in the range supported by movcc (11-bit signed imm)
5875 case 'M': // A constant in the range supported by movrcc (19-bit signed imm)
5876 case 'N': // Same as 'K' but zext (required for SIMode)
5877 case 'O': // The constant 4096
5878 return true;
5879 }
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005880 return false;
Gabor Greif49991682008-02-21 16:29:08 +00005881 }
Craig Topper3164f332014-03-11 03:39:26 +00005882 const char *getClobbers() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00005883 // FIXME: Implement!
5884 return "";
Gabor Greif49991682008-02-21 16:29:08 +00005885 }
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00005886
5887 // No Sparc V7 for now, the backend doesn't support it anyway.
5888 enum CPUKind {
5889 CK_GENERIC,
5890 CK_V8,
5891 CK_SUPERSPARC,
5892 CK_SPARCLITE,
5893 CK_F934,
5894 CK_HYPERSPARC,
5895 CK_SPARCLITE86X,
5896 CK_SPARCLET,
5897 CK_TSC701,
5898 CK_V9,
5899 CK_ULTRASPARC,
5900 CK_ULTRASPARC3,
5901 CK_NIAGARA,
5902 CK_NIAGARA2,
5903 CK_NIAGARA3,
5904 CK_NIAGARA4
5905 } CPU = CK_GENERIC;
5906
5907 enum CPUGeneration {
5908 CG_V8,
5909 CG_V9,
5910 };
5911
5912 CPUGeneration getCPUGeneration(CPUKind Kind) const {
5913 switch (Kind) {
5914 case CK_GENERIC:
5915 case CK_V8:
5916 case CK_SUPERSPARC:
5917 case CK_SPARCLITE:
5918 case CK_F934:
5919 case CK_HYPERSPARC:
5920 case CK_SPARCLITE86X:
5921 case CK_SPARCLET:
5922 case CK_TSC701:
5923 return CG_V8;
5924 case CK_V9:
5925 case CK_ULTRASPARC:
5926 case CK_ULTRASPARC3:
5927 case CK_NIAGARA:
5928 case CK_NIAGARA2:
5929 case CK_NIAGARA3:
5930 case CK_NIAGARA4:
5931 return CG_V9;
5932 }
Aaron Ballmana9a72852015-11-11 13:42:02 +00005933 llvm_unreachable("Unexpected CPU kind");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00005934 }
5935
5936 CPUKind getCPUKind(StringRef Name) const {
5937 return llvm::StringSwitch<CPUKind>(Name)
5938 .Case("v8", CK_V8)
5939 .Case("supersparc", CK_SUPERSPARC)
5940 .Case("sparclite", CK_SPARCLITE)
5941 .Case("f934", CK_F934)
5942 .Case("hypersparc", CK_HYPERSPARC)
5943 .Case("sparclite86x", CK_SPARCLITE86X)
5944 .Case("sparclet", CK_SPARCLET)
5945 .Case("tsc701", CK_TSC701)
5946 .Case("v9", CK_V9)
5947 .Case("ultrasparc", CK_ULTRASPARC)
5948 .Case("ultrasparc3", CK_ULTRASPARC3)
5949 .Case("niagara", CK_NIAGARA)
5950 .Case("niagara2", CK_NIAGARA2)
5951 .Case("niagara3", CK_NIAGARA3)
5952 .Case("niagara4", CK_NIAGARA4)
5953 .Default(CK_GENERIC);
5954 }
5955
5956 bool setCPU(const std::string &Name) override {
5957 CPU = getCPUKind(Name);
5958 return CPU != CK_GENERIC;
5959 }
Gabor Greif49991682008-02-21 16:29:08 +00005960};
5961
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005962const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattner9b415d62009-01-27 01:58:38 +00005963 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
5964 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
5965 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
5966 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
5967};
5968
Craig Topperf054e3a2015-10-19 03:52:27 +00005969ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const {
5970 return llvm::makeArrayRef(GCCRegNames);
Chris Lattner9b415d62009-01-27 01:58:38 +00005971}
5972
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00005973const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00005974 { { "g0" }, "r0" },
5975 { { "g1" }, "r1" },
5976 { { "g2" }, "r2" },
5977 { { "g3" }, "r3" },
5978 { { "g4" }, "r4" },
5979 { { "g5" }, "r5" },
5980 { { "g6" }, "r6" },
5981 { { "g7" }, "r7" },
5982 { { "o0" }, "r8" },
5983 { { "o1" }, "r9" },
5984 { { "o2" }, "r10" },
5985 { { "o3" }, "r11" },
5986 { { "o4" }, "r12" },
5987 { { "o5" }, "r13" },
5988 { { "o6", "sp" }, "r14" },
5989 { { "o7" }, "r15" },
5990 { { "l0" }, "r16" },
5991 { { "l1" }, "r17" },
5992 { { "l2" }, "r18" },
5993 { { "l3" }, "r19" },
5994 { { "l4" }, "r20" },
5995 { { "l5" }, "r21" },
5996 { { "l6" }, "r22" },
5997 { { "l7" }, "r23" },
5998 { { "i0" }, "r24" },
5999 { { "i1" }, "r25" },
6000 { { "i2" }, "r26" },
6001 { { "i3" }, "r27" },
6002 { { "i4" }, "r28" },
6003 { { "i5" }, "r29" },
6004 { { "i6", "fp" }, "r30" },
6005 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00006006};
6007
Craig Topperf054e3a2015-10-19 03:52:27 +00006008ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const {
6009 return llvm::makeArrayRef(GCCRegAliases);
Chris Lattner9b415d62009-01-27 01:58:38 +00006010}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006011
6012// SPARC v8 is the 32-bit mode selected by Triple::sparc.
6013class SparcV8TargetInfo : public SparcTargetInfo {
6014public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006015 SparcV8TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Eric Christopher964a5f32015-08-05 23:48:05 +00006016 DataLayoutString = "E-m:e-p:32:32-i64:64-f128:64-n32-S64";
Brad Smith73859112015-08-13 21:45:57 +00006017 // NetBSD / OpenBSD use long (same as llvm default); everyone else uses int.
6018 switch (getTriple().getOS()) {
6019 default:
James Y Knight4b4d19e2015-06-04 15:36:29 +00006020 SizeType = UnsignedInt;
6021 IntPtrType = SignedInt;
6022 PtrDiffType = SignedInt;
Brad Smith73859112015-08-13 21:45:57 +00006023 break;
6024 case llvm::Triple::NetBSD:
6025 case llvm::Triple::OpenBSD:
6026 SizeType = UnsignedLong;
6027 IntPtrType = SignedLong;
6028 PtrDiffType = SignedLong;
6029 break;
Brad Smith56495d52015-08-13 22:00:53 +00006030 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006031 }
6032
Craig Topper3164f332014-03-11 03:39:26 +00006033 void getTargetDefines(const LangOptions &Opts,
6034 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006035 SparcTargetInfo::getTargetDefines(Opts, Builder);
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006036 switch (getCPUGeneration(CPU)) {
6037 case CG_V8:
6038 Builder.defineMacro("__sparcv8");
6039 if (getTriple().getOS() != llvm::Triple::Solaris)
6040 Builder.defineMacro("__sparcv8__");
6041 break;
6042 case CG_V9:
6043 Builder.defineMacro("__sparcv9");
Joerg Sonnenberger4ecfa622015-11-10 19:28:17 +00006044 if (getTriple().getOS() != llvm::Triple::Solaris) {
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006045 Builder.defineMacro("__sparcv9__");
Joerg Sonnenberger4ecfa622015-11-10 19:28:17 +00006046 Builder.defineMacro("__sparc_v9__");
6047 }
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006048 break;
6049 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006050 }
6051};
6052
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006053// SPARCV8el is the 32-bit little-endian mode selected by Triple::sparcel.
6054class SparcV8elTargetInfo : public SparcV8TargetInfo {
6055 public:
6056 SparcV8elTargetInfo(const llvm::Triple &Triple) : SparcV8TargetInfo(Triple) {
Eric Christopher964a5f32015-08-05 23:48:05 +00006057 DataLayoutString = "e-m:e-p:32:32-i64:64-f128:64-n32-S64";
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00006058 BigEndian = false;
6059 }
6060};
6061
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006062// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
6063class SparcV9TargetInfo : public SparcTargetInfo {
6064public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006065 SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006066 // FIXME: Support Sparc quad-precision long double?
Eric Christopher964a5f32015-08-05 23:48:05 +00006067 DataLayoutString = "E-m:e-i64:64-n32:64-S128";
Jakob Stoklund Olesen248520b2013-05-15 03:22:33 +00006068 // This is an LP64 platform.
6069 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00006070
6071 // OpenBSD uses long long for int64_t and intmax_t.
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00006072 if (getTriple().getOS() == llvm::Triple::OpenBSD)
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00006073 IntMaxType = SignedLongLong;
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00006074 else
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00006075 IntMaxType = SignedLong;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00006076 Int64Type = IntMaxType;
Jakob Stoklund Olesen497332c2014-01-16 16:43:19 +00006077
6078 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
6079 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
6080 LongDoubleWidth = 128;
6081 LongDoubleAlign = 128;
6082 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Jakob Stoklund Olesen5b630b42014-01-30 04:48:04 +00006083 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006084 }
6085
Craig Topper3164f332014-03-11 03:39:26 +00006086 void getTargetDefines(const LangOptions &Opts,
6087 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006088 SparcTargetInfo::getTargetDefines(Opts, Builder);
6089 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00006090 Builder.defineMacro("__arch64__");
Rafael Espindola76483742014-08-14 15:14:51 +00006091 // Solaris doesn't need these variants, but the BSDs do.
6092 if (getTriple().getOS() != llvm::Triple::Solaris) {
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00006093 Builder.defineMacro("__sparc64__");
6094 Builder.defineMacro("__sparc_v9__");
6095 Builder.defineMacro("__sparcv9__");
6096 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006097 }
Roman Divackyb1ae3d42014-02-25 18:35:30 +00006098
Craig Topper3164f332014-03-11 03:39:26 +00006099 bool setCPU(const std::string &Name) override {
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006100 if (!SparcTargetInfo::setCPU(Name))
6101 return false;
6102 return getCPUGeneration(CPU) == CG_V9;
Roman Divackyb1ae3d42014-02-25 18:35:30 +00006103 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006104};
6105
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006106class SystemZTargetInfo : public TargetInfo {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006107 static const Builtin::Info BuiltinInfo[];
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006108 static const char *const GCCRegNames[];
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006109 std::string CPU;
6110 bool HasTransactionalExecution;
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006111 bool HasVector;
Ulrich Weigand47445072013-05-06 16:26:41 +00006112
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006113public:
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006114 SystemZTargetInfo(const llvm::Triple &Triple)
Eric Christopherb093d692015-10-09 18:39:59 +00006115 : TargetInfo(Triple), CPU("z10"), HasTransactionalExecution(false),
6116 HasVector(false) {
Ulrich Weigand881497a2015-03-30 13:50:21 +00006117 IntMaxType = SignedLong;
6118 Int64Type = SignedLong;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006119 TLSSupported = true;
6120 IntWidth = IntAlign = 32;
6121 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
6122 PointerWidth = PointerAlign = 64;
6123 LongDoubleWidth = 128;
6124 LongDoubleAlign = 64;
6125 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Ulrich Weigandca3cb7f2015-04-21 17:29:35 +00006126 DefaultAlignForAttributeAligned = 64;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006127 MinGlobalAlign = 16;
Eric Christopher964a5f32015-08-05 23:48:05 +00006128 DataLayoutString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006129 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
6130 }
6131 void getTargetDefines(const LangOptions &Opts,
6132 MacroBuilder &Builder) const override {
6133 Builder.defineMacro("__s390__");
6134 Builder.defineMacro("__s390x__");
6135 Builder.defineMacro("__zarch__");
6136 Builder.defineMacro("__LONG_DOUBLE_128__");
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006137 if (HasTransactionalExecution)
6138 Builder.defineMacro("__HTM__");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00006139 if (Opts.ZVector)
6140 Builder.defineMacro("__VEC__", "10301");
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006141 }
Craig Topper6c03a542015-10-19 04:51:35 +00006142 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6143 return llvm::makeArrayRef(BuiltinInfo,
6144 clang::SystemZ::LastTSBuiltin-Builtin::FirstTSBuiltin);
Ulrich Weigand47445072013-05-06 16:26:41 +00006145 }
6146
Craig Topperf054e3a2015-10-19 03:52:27 +00006147 ArrayRef<const char *> getGCCRegNames() const override;
6148 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006149 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00006150 return None;
Ulrich Weigand47445072013-05-06 16:26:41 +00006151 }
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006152 bool validateAsmConstraint(const char *&Name,
6153 TargetInfo::ConstraintInfo &info) const override;
6154 const char *getClobbers() const override {
6155 // FIXME: Is this really right?
6156 return "";
6157 }
6158 BuiltinVaListKind getBuiltinVaListKind() const override {
6159 return TargetInfo::SystemZBuiltinVaList;
6160 }
6161 bool setCPU(const std::string &Name) override {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006162 CPU = Name;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006163 bool CPUKnown = llvm::StringSwitch<bool>(Name)
6164 .Case("z10", true)
6165 .Case("z196", true)
6166 .Case("zEC12", true)
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006167 .Case("z13", true)
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006168 .Default(false);
6169
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006170 return CPUKnown;
6171 }
Eric Christopher8c47b422015-10-09 18:39:55 +00006172 bool
6173 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
6174 StringRef CPU,
6175 const std::vector<std::string> &FeaturesVec) const override {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006176 if (CPU == "zEC12")
6177 Features["transactional-execution"] = true;
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006178 if (CPU == "z13") {
6179 Features["transactional-execution"] = true;
6180 Features["vector"] = true;
6181 }
Eric Christopher007b0a02015-08-28 22:32:01 +00006182 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006183 }
6184
6185 bool handleTargetFeatures(std::vector<std::string> &Features,
6186 DiagnosticsEngine &Diags) override {
6187 HasTransactionalExecution = false;
Eric Christopher610fe112015-08-26 08:21:55 +00006188 for (const auto &Feature : Features) {
6189 if (Feature == "+transactional-execution")
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006190 HasTransactionalExecution = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006191 else if (Feature == "+vector")
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006192 HasVector = true;
6193 }
6194 // If we use the vector ABI, vector types are 64-bit aligned.
6195 if (HasVector) {
6196 MaxVectorAlign = 64;
Eric Christopher964a5f32015-08-05 23:48:05 +00006197 DataLayoutString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64"
6198 "-v128:64-a:8:16-n32:64";
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006199 }
6200 return true;
6201 }
6202
6203 bool hasFeature(StringRef Feature) const override {
6204 return llvm::StringSwitch<bool>(Feature)
Ulrich Weigandcc673442015-04-01 14:15:35 +00006205 .Case("systemz", true)
6206 .Case("htm", HasTransactionalExecution)
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006207 .Case("vx", HasVector)
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006208 .Default(false);
6209 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00006210
6211 StringRef getABI() const override {
6212 if (HasVector)
6213 return "vector";
6214 return "";
6215 }
Ulrich Weigand47fd2532015-06-16 15:21:47 +00006216
6217 bool useFloat128ManglingForLongDouble() const override {
6218 return true;
6219 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006220};
6221
6222const Builtin::Info SystemZTargetInfo::BuiltinInfo[] = {
6223#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00006224 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00006225#include "clang/Basic/BuiltinsSystemZ.def"
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006226};
6227
6228const char *const SystemZTargetInfo::GCCRegNames[] = {
6229 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6230 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6231 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
6232 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
6233};
6234
Craig Topperf054e3a2015-10-19 03:52:27 +00006235ArrayRef<const char *> SystemZTargetInfo::getGCCRegNames() const {
6236 return llvm::makeArrayRef(GCCRegNames);
Richard Sandifordd03f7b72014-04-10 09:56:24 +00006237}
6238
6239bool SystemZTargetInfo::
6240validateAsmConstraint(const char *&Name,
6241 TargetInfo::ConstraintInfo &Info) const {
6242 switch (*Name) {
6243 default:
6244 return false;
6245
6246 case 'a': // Address register
6247 case 'd': // Data register (equivalent to 'r')
6248 case 'f': // Floating-point register
6249 Info.setAllowsRegister();
6250 return true;
6251
6252 case 'I': // Unsigned 8-bit constant
6253 case 'J': // Unsigned 12-bit constant
6254 case 'K': // Signed 16-bit constant
6255 case 'L': // Signed 20-bit displacement (on all targets we support)
6256 case 'M': // 0x7fffffff
6257 return true;
6258
6259 case 'Q': // Memory with base and unsigned 12-bit displacement
6260 case 'R': // Likewise, plus an index
6261 case 'S': // Memory with base and signed 20-bit displacement
6262 case 'T': // Likewise, plus an index
6263 Info.setAllowsMemory();
6264 return true;
6265 }
6266}
Ulrich Weigand47445072013-05-06 16:26:41 +00006267
Eric Christopherc48497a2015-09-18 21:26:24 +00006268class MSP430TargetInfo : public TargetInfo {
6269 static const char *const GCCRegNames[];
Anton Korobeynikova0f54372009-05-03 13:43:08 +00006270
Eric Christopherc48497a2015-09-18 21:26:24 +00006271public:
6272 MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6273 BigEndian = false;
6274 TLSSupported = false;
6275 IntWidth = 16;
6276 IntAlign = 16;
6277 LongWidth = 32;
6278 LongLongWidth = 64;
6279 LongAlign = LongLongAlign = 16;
6280 PointerWidth = 16;
6281 PointerAlign = 16;
6282 SuitableAlign = 16;
6283 SizeType = UnsignedInt;
6284 IntMaxType = SignedLongLong;
6285 IntPtrType = SignedInt;
6286 PtrDiffType = SignedInt;
6287 SigAtomicType = SignedLong;
6288 DataLayoutString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16";
Anton Korobeynikova0f54372009-05-03 13:43:08 +00006289 }
Eric Christopherc48497a2015-09-18 21:26:24 +00006290 void getTargetDefines(const LangOptions &Opts,
6291 MacroBuilder &Builder) const override {
6292 Builder.defineMacro("MSP430");
6293 Builder.defineMacro("__MSP430__");
6294 // FIXME: defines for different 'flavours' of MCU
6295 }
Craig Topper6c03a542015-10-19 04:51:35 +00006296 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00006297 // FIXME: Implement.
Craig Topper6c03a542015-10-19 04:51:35 +00006298 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00006299 }
6300 bool hasFeature(StringRef Feature) const override {
6301 return Feature == "msp430";
6302 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006303 ArrayRef<const char *> getGCCRegNames() const override;
6304 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00006305 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00006306 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00006307 }
6308 bool validateAsmConstraint(const char *&Name,
6309 TargetInfo::ConstraintInfo &info) const override {
6310 // FIXME: implement
6311 switch (*Name) {
6312 case 'K': // the constant 1
6313 case 'L': // constant -1^20 .. 1^19
6314 case 'M': // constant 1-4:
Eli Friedmana9c3d712009-08-19 20:47:07 +00006315 return true;
6316 }
Eric Christopherc48497a2015-09-18 21:26:24 +00006317 // No target constraints for now.
6318 return false;
6319 }
6320 const char *getClobbers() const override {
6321 // FIXME: Is this really right?
6322 return "";
6323 }
6324 BuiltinVaListKind getBuiltinVaListKind() const override {
6325 // FIXME: implement
6326 return TargetInfo::CharPtrBuiltinVaList;
6327 }
6328};
6329
6330const char *const MSP430TargetInfo::GCCRegNames[] = {
6331 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6332 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"};
6333
Craig Topperf054e3a2015-10-19 03:52:27 +00006334ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
6335 return llvm::makeArrayRef(GCCRegNames);
Eric Christopherc48497a2015-09-18 21:26:24 +00006336}
6337
6338// LLVM and Clang cannot be used directly to output native binaries for
6339// target, but is used to compile C code to llvm bitcode with correct
6340// type and alignment information.
6341//
6342// TCE uses the llvm bitcode as input and uses it for generating customized
6343// target processor and program binary. TCE co-design environment is
6344// publicly available in http://tce.cs.tut.fi
6345
6346static const unsigned TCEOpenCLAddrSpaceMap[] = {
6347 3, // opencl_global
6348 4, // opencl_local
6349 5, // opencl_constant
6350 // FIXME: generic has to be added to the target
6351 0, // opencl_generic
6352 0, // cuda_device
6353 0, // cuda_constant
6354 0 // cuda_shared
6355};
6356
6357class TCETargetInfo : public TargetInfo {
6358public:
6359 TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6360 TLSSupported = false;
6361 IntWidth = 32;
6362 LongWidth = LongLongWidth = 32;
6363 PointerWidth = 32;
6364 IntAlign = 32;
6365 LongAlign = LongLongAlign = 32;
6366 PointerAlign = 32;
6367 SuitableAlign = 32;
6368 SizeType = UnsignedInt;
6369 IntMaxType = SignedLong;
6370 IntPtrType = SignedInt;
6371 PtrDiffType = SignedInt;
6372 FloatWidth = 32;
6373 FloatAlign = 32;
6374 DoubleWidth = 32;
6375 DoubleAlign = 32;
6376 LongDoubleWidth = 32;
6377 LongDoubleAlign = 32;
6378 FloatFormat = &llvm::APFloat::IEEEsingle;
6379 DoubleFormat = &llvm::APFloat::IEEEsingle;
6380 LongDoubleFormat = &llvm::APFloat::IEEEsingle;
6381 DataLayoutString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
6382 "-f64:32-v64:32-v128:32-a:0:32-n32";
6383 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
6384 UseAddrSpaceMapMangling = true;
6385 }
6386
6387 void getTargetDefines(const LangOptions &Opts,
6388 MacroBuilder &Builder) const override {
6389 DefineStd(Builder, "tce", Opts);
6390 Builder.defineMacro("__TCE__");
6391 Builder.defineMacro("__TCE_V1__");
6392 }
6393 bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
6394
Craig Topper6c03a542015-10-19 04:51:35 +00006395 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00006396 const char *getClobbers() const override { return ""; }
6397 BuiltinVaListKind getBuiltinVaListKind() const override {
6398 return TargetInfo::VoidPtrBuiltinVaList;
6399 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006400 ArrayRef<const char *> getGCCRegNames() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00006401 bool validateAsmConstraint(const char *&Name,
6402 TargetInfo::ConstraintInfo &info) const override {
6403 return true;
6404 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006405 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
6406 return None;
6407 }
Eric Christopherc48497a2015-09-18 21:26:24 +00006408};
Eli Friedmana9c3d712009-08-19 20:47:07 +00006409
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006410class BPFTargetInfo : public TargetInfo {
6411public:
6412 BPFTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
6413 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
6414 SizeType = UnsignedLong;
6415 PtrDiffType = SignedLong;
6416 IntPtrType = SignedLong;
6417 IntMaxType = SignedLong;
6418 Int64Type = SignedLong;
6419 RegParmMax = 5;
6420 if (Triple.getArch() == llvm::Triple::bpfeb) {
6421 BigEndian = true;
Eric Christopher964a5f32015-08-05 23:48:05 +00006422 DataLayoutString = "E-m:e-p:64:64-i64:64-n32:64-S128";
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006423 } else {
6424 BigEndian = false;
Eric Christopher964a5f32015-08-05 23:48:05 +00006425 DataLayoutString = "e-m:e-p:64:64-i64:64-n32:64-S128";
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006426 }
6427 MaxAtomicPromoteWidth = 64;
6428 MaxAtomicInlineWidth = 64;
6429 TLSSupported = false;
6430 }
6431 void getTargetDefines(const LangOptions &Opts,
6432 MacroBuilder &Builder) const override {
6433 DefineStd(Builder, "bpf", Opts);
6434 Builder.defineMacro("__BPF__");
6435 }
6436 bool hasFeature(StringRef Feature) const override {
6437 return Feature == "bpf";
6438 }
6439
Craig Topper6c03a542015-10-19 04:51:35 +00006440 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006441 const char *getClobbers() const override {
6442 return "";
6443 }
6444 BuiltinVaListKind getBuiltinVaListKind() const override {
6445 return TargetInfo::VoidPtrBuiltinVaList;
6446 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006447 ArrayRef<const char *> getGCCRegNames() const override {
6448 return None;
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006449 }
6450 bool validateAsmConstraint(const char *&Name,
6451 TargetInfo::ConstraintInfo &info) const override {
6452 return true;
6453 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006454 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
6455 return None;
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00006456 }
6457};
6458
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006459class MipsTargetInfoBase : public TargetInfo {
Eric Christopher964a5f32015-08-05 23:48:05 +00006460 virtual void setDataLayoutString() = 0;
Akira Hatanaka9064e362013-10-29 18:30:33 +00006461
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00006462 static const Builtin::Info BuiltinInfo[];
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006463 std::string CPU;
Simon Atanasyan72244b62012-07-05 16:06:06 +00006464 bool IsMips16;
Simon Atanasyan60777612013-04-14 14:07:51 +00006465 bool IsMicromips;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006466 bool IsNan2008;
Simon Atanasyan16071912013-04-14 14:07:30 +00006467 bool IsSingleFloat;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006468 enum MipsFloatABI {
Simon Atanasyan16071912013-04-14 14:07:30 +00006469 HardFloat, SoftFloat
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006470 } FloatABI;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00006471 enum DspRevEnum {
6472 NoDSP, DSP1, DSP2
6473 } DspRev;
Jack Carter44ff1e52013-08-12 17:20:29 +00006474 bool HasMSA;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006475
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006476protected:
Akira Hatanaka618b2982013-10-29 19:00:35 +00006477 bool HasFP64;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006478 std::string ABI;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006479
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006480public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006481 MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
6482 const std::string &CPUStr)
6483 : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006484 IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
Zoran Jovanovic26a12162015-02-18 15:21:35 +00006485 DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {
6486 TheCXXABI.set(TargetCXXABI::GenericMIPS);
6487 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006488
Daniel Sanders9500d2d2014-07-09 13:56:23 +00006489 bool isNaN2008Default() const {
6490 return CPU == "mips32r6" || CPU == "mips64r6";
6491 }
6492
6493 bool isFP64Default() const {
6494 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
6495 }
6496
Petar Jovanovicd55ae6b2015-02-26 18:19:22 +00006497 bool isNan2008() const override {
6498 return IsNan2008;
6499 }
6500
Alp Toker4925ba72014-06-07 23:30:42 +00006501 StringRef getABI() const override { return ABI; }
Craig Topper3164f332014-03-11 03:39:26 +00006502 bool setCPU(const std::string &Name) override {
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006503 bool IsMips32 = getTriple().getArch() == llvm::Triple::mips ||
6504 getTriple().getArch() == llvm::Triple::mipsel;
Eric Christopher0b26a612010-03-02 02:41:08 +00006505 CPU = Name;
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006506 return llvm::StringSwitch<bool>(Name)
Simon Atanasyan26610c52014-07-04 12:36:56 +00006507 .Case("mips1", IsMips32)
6508 .Case("mips2", IsMips32)
6509 .Case("mips3", true)
6510 .Case("mips4", true)
6511 .Case("mips5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006512 .Case("mips32", IsMips32)
6513 .Case("mips32r2", IsMips32)
Simon Atanasyan162feb52015-02-20 23:37:40 +00006514 .Case("mips32r3", IsMips32)
6515 .Case("mips32r5", IsMips32)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006516 .Case("mips32r6", IsMips32)
6517 .Case("mips64", true)
6518 .Case("mips64r2", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00006519 .Case("mips64r3", true)
6520 .Case("mips64r5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006521 .Case("mips64r6", true)
Simon Atanasyan4e16a422014-07-04 12:37:04 +00006522 .Case("octeon", true)
Daniel Sandersff952582015-10-05 12:24:30 +00006523 .Case("p5600", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00006524 .Default(false);
Eric Christopher0b26a612010-03-02 02:41:08 +00006525 }
Matheus Almeidab84b37d2014-06-05 14:59:18 +00006526 const std::string& getCPU() const { return CPU; }
Eric Christopher8c47b422015-10-09 18:39:55 +00006527 bool
6528 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
6529 StringRef CPU,
6530 const std::vector<std::string> &FeaturesVec) const override {
Simon Atanasyan4e16a422014-07-04 12:37:04 +00006531 if (CPU == "octeon")
6532 Features["mips64r2"] = Features["cnmips"] = true;
6533 else
6534 Features[CPU] = true;
Eric Christopher007b0a02015-08-28 22:32:01 +00006535 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Eric Christopher0b26a612010-03-02 02:41:08 +00006536 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006537
Craig Topper3164f332014-03-11 03:39:26 +00006538 void getTargetDefines(const LangOptions &Opts,
6539 MacroBuilder &Builder) const override {
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006540 Builder.defineMacro("__mips__");
Simon Atanasyan683535b2012-08-29 19:14:58 +00006541 Builder.defineMacro("_mips");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006542 if (Opts.GNUMode)
6543 Builder.defineMacro("mips");
6544
Simon Atanasyan683535b2012-08-29 19:14:58 +00006545 Builder.defineMacro("__REGISTER_PREFIX__", "");
6546
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006547 switch (FloatABI) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006548 case HardFloat:
Simon Atanasyand3d173d2012-06-05 13:06:56 +00006549 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006550 break;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006551 case SoftFloat:
6552 Builder.defineMacro("__mips_soft_float", Twine(1));
6553 break;
Simon Atanasyand3d173d2012-06-05 13:06:56 +00006554 }
Simon Atanasyan26f19672012-04-05 19:28:31 +00006555
Simon Atanasyan16071912013-04-14 14:07:30 +00006556 if (IsSingleFloat)
6557 Builder.defineMacro("__mips_single_float", Twine(1));
6558
Simon Atanasyan2c97a812013-10-18 13:13:53 +00006559 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
6560 Builder.defineMacro("_MIPS_FPSET",
6561 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
6562
Simon Atanasyan72244b62012-07-05 16:06:06 +00006563 if (IsMips16)
6564 Builder.defineMacro("__mips16", Twine(1));
6565
Simon Atanasyan60777612013-04-14 14:07:51 +00006566 if (IsMicromips)
6567 Builder.defineMacro("__mips_micromips", Twine(1));
6568
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006569 if (IsNan2008)
6570 Builder.defineMacro("__mips_nan2008", Twine(1));
6571
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00006572 switch (DspRev) {
6573 default:
6574 break;
6575 case DSP1:
6576 Builder.defineMacro("__mips_dsp_rev", Twine(1));
6577 Builder.defineMacro("__mips_dsp", Twine(1));
6578 break;
6579 case DSP2:
6580 Builder.defineMacro("__mips_dsp_rev", Twine(2));
6581 Builder.defineMacro("__mips_dspr2", Twine(1));
6582 Builder.defineMacro("__mips_dsp", Twine(1));
6583 break;
6584 }
6585
Jack Carter44ff1e52013-08-12 17:20:29 +00006586 if (HasMSA)
6587 Builder.defineMacro("__mips_msa", Twine(1));
6588
Simon Atanasyan26f19672012-04-05 19:28:31 +00006589 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
6590 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
6591 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan5a0642f2012-08-29 15:17:29 +00006592
6593 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
6594 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Daniel Sanders5176f7e2015-12-22 12:59:30 +00006595
6596 // These shouldn't be defined for MIPS-I but there's no need to check
6597 // for that since MIPS-I isn't supported.
6598 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
6599 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
6600 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006601 }
6602
Craig Topper6c03a542015-10-19 04:51:35 +00006603 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6604 return llvm::makeArrayRef(BuiltinInfo,
6605 clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006606 }
Craig Topper3164f332014-03-11 03:39:26 +00006607 bool hasFeature(StringRef Feature) const override {
Akira Hatanaka618b2982013-10-29 19:00:35 +00006608 return llvm::StringSwitch<bool>(Feature)
6609 .Case("mips", true)
6610 .Case("fp64", HasFP64)
6611 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00006612 }
Craig Topper3164f332014-03-11 03:39:26 +00006613 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00006614 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006615 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006616 ArrayRef<const char *> getGCCRegNames() const override {
Daniel Sanders8b59af12013-11-12 12:56:01 +00006617 static const char *const GCCRegNames[] = {
Eric Christopher8b6d0512012-03-27 19:56:11 +00006618 // CPU register names
6619 // Must match second column of GCCRegAliases
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006620 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
6621 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
6622 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopher8b6d0512012-03-27 19:56:11 +00006623 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
6624 // Floating point register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006625 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
6626 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
6627 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
6628 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopher8b6d0512012-03-27 19:56:11 +00006629 // Hi/lo and condition register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006630 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
Daniel Sanders8b59af12013-11-12 12:56:01 +00006631 "$fcc5","$fcc6","$fcc7",
6632 // MSA register names
6633 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7",
6634 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
6635 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
6636 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
6637 // MSA control register names
6638 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
6639 "$msarequest", "$msamap", "$msaunmap"
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006640 };
Craig Topperf054e3a2015-10-19 03:52:27 +00006641 return llvm::makeArrayRef(GCCRegNames);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006642 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006643 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override = 0;
Craig Topper3164f332014-03-11 03:39:26 +00006644 bool validateAsmConstraint(const char *&Name,
6645 TargetInfo::ConstraintInfo &Info) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006646 switch (*Name) {
6647 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00006648 return false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006649 case 'r': // CPU registers.
6650 case 'd': // Equivalent to "r" unless generating MIPS16 code.
Alp Toker958027b2014-07-14 19:42:55 +00006651 case 'y': // Equivalent to "r", backward compatibility only.
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006652 case 'f': // floating-point registers.
Eric Christopherb7e28cc2012-04-03 01:16:32 +00006653 case 'c': // $25 for indirect jumps
6654 case 'l': // lo register
6655 case 'x': // hilo register pair
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006656 Info.setAllowsRegister();
6657 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00006658 case 'I': // Signed 16-bit constant
6659 case 'J': // Integer 0
6660 case 'K': // Unsigned 16-bit constant
6661 case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui)
6662 case 'M': // Constants not loadable via lui, addiu, or ori
6663 case 'N': // Constant -1 to -65535
6664 case 'O': // A signed 15-bit constant
6665 case 'P': // A constant between 1 go 65535
6666 return true;
Jack Carterbeaccdd2013-03-05 19:10:54 +00006667 case 'R': // An address that can be used in a non-macro load or store
Jack Carter427b4042013-03-04 21:36:11 +00006668 Info.setAllowsMemory();
6669 return true;
Daniel Sanders48fa39e2015-03-30 13:47:23 +00006670 case 'Z':
6671 if (Name[1] == 'C') { // An address usable by ll, and sc.
6672 Info.setAllowsMemory();
6673 Name++; // Skip over 'Z'.
6674 return true;
6675 }
6676 return false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006677 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006678 }
6679
Daniel Sanders48fa39e2015-03-30 13:47:23 +00006680 std::string convertConstraint(const char *&Constraint) const override {
6681 std::string R;
6682 switch (*Constraint) {
6683 case 'Z': // Two-character constraint; add "^" hint for later parsing.
6684 if (Constraint[1] == 'C') {
6685 R = std::string("^") + std::string(Constraint, 2);
6686 Constraint++;
6687 return R;
6688 }
6689 break;
6690 }
6691 return TargetInfo::convertConstraint(Constraint);
6692 }
6693
Craig Topper3164f332014-03-11 03:39:26 +00006694 const char *getClobbers() const override {
Toma Tabacucfab40f2015-01-12 14:41:30 +00006695 // In GCC, $1 is not widely used in generated code (it's used only in a few
6696 // specific situations), so there is no real need for users to add it to
6697 // the clobbers list if they want to use it in their inline assembly code.
6698 //
6699 // In LLVM, $1 is treated as a normal GPR and is always allocatable during
6700 // code generation, so using it in inline assembly without adding it to the
6701 // clobbers list can cause conflicts between the inline assembly code and
6702 // the surrounding generated code.
6703 //
6704 // Another problem is that LLVM is allowed to choose $1 for inline assembly
6705 // operands, which will conflict with the ".set at" assembler option (which
6706 // we use only for inline assembly, in order to maintain compatibility with
6707 // GCC) and will also conflict with the user's usage of $1.
6708 //
6709 // The easiest way to avoid these conflicts and keep $1 as an allocatable
6710 // register for generated code is to automatically clobber $1 for all inline
6711 // assembly code.
6712 //
6713 // FIXME: We should automatically clobber $1 only for inline assembly code
6714 // which actually uses it. This would allow LLVM to use $1 for inline
6715 // assembly operands if the user's assembly code doesn't use it.
Toma Tabacu99411952014-12-17 12:02:58 +00006716 return "~{$1}";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006717 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006718
Craig Topper3164f332014-03-11 03:39:26 +00006719 bool handleTargetFeatures(std::vector<std::string> &Features,
6720 DiagnosticsEngine &Diags) override {
Simon Atanasyan72244b62012-07-05 16:06:06 +00006721 IsMips16 = false;
Simon Atanasyan60777612013-04-14 14:07:51 +00006722 IsMicromips = false;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00006723 IsNan2008 = isNaN2008Default();
Simon Atanasyan16071912013-04-14 14:07:30 +00006724 IsSingleFloat = false;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006725 FloatABI = HardFloat;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00006726 DspRev = NoDSP;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00006727 HasFP64 = isFP64Default();
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006728
Eric Christopher610fe112015-08-26 08:21:55 +00006729 for (const auto &Feature : Features) {
6730 if (Feature == "+single-float")
Simon Atanasyan16071912013-04-14 14:07:30 +00006731 IsSingleFloat = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006732 else if (Feature == "+soft-float")
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006733 FloatABI = SoftFloat;
Eric Christopher610fe112015-08-26 08:21:55 +00006734 else if (Feature == "+mips16")
Simon Atanasyan72244b62012-07-05 16:06:06 +00006735 IsMips16 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006736 else if (Feature == "+micromips")
Simon Atanasyan60777612013-04-14 14:07:51 +00006737 IsMicromips = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006738 else if (Feature == "+dsp")
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00006739 DspRev = std::max(DspRev, DSP1);
Eric Christopher610fe112015-08-26 08:21:55 +00006740 else if (Feature == "+dspr2")
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00006741 DspRev = std::max(DspRev, DSP2);
Eric Christopher610fe112015-08-26 08:21:55 +00006742 else if (Feature == "+msa")
Jack Carter44ff1e52013-08-12 17:20:29 +00006743 HasMSA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006744 else if (Feature == "+fp64")
Simon Atanasyan2c97a812013-10-18 13:13:53 +00006745 HasFP64 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006746 else if (Feature == "-fp64")
Simon Atanasyan2c97a812013-10-18 13:13:53 +00006747 HasFP64 = false;
Eric Christopher610fe112015-08-26 08:21:55 +00006748 else if (Feature == "+nan2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00006749 IsNan2008 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00006750 else if (Feature == "-nan2008")
Daniel Sanders9500d2d2014-07-09 13:56:23 +00006751 IsNan2008 = false;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006752 }
Simon Atanasyan9f444d52012-07-05 15:32:46 +00006753
Eric Christopher964a5f32015-08-05 23:48:05 +00006754 setDataLayoutString();
Akira Hatanaka9064e362013-10-29 18:30:33 +00006755
Rafael Espindolaeb265472013-08-21 21:59:03 +00006756 return true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006757 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00006758
Craig Topper3164f332014-03-11 03:39:26 +00006759 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00006760 if (RegNo == 0) return 4;
6761 if (RegNo == 1) return 5;
6762 return -1;
6763 }
Daniel Sanderscfbb71d2014-07-09 13:43:19 +00006764
6765 bool isCLZForZeroUndef() const override { return false; }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006766};
6767
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00006768const Builtin::Info MipsTargetInfoBase::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00006769#define BUILTIN(ID, TYPE, ATTRS) \
6770 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6771#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
6772 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00006773#include "clang/Basic/BuiltinsMips.def"
6774};
6775
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006776class Mips32TargetInfoBase : public MipsTargetInfoBase {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006777public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006778 Mips32TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00006779 : MipsTargetInfoBase(Triple, "o32", "mips32r2") {
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00006780 SizeType = UnsignedInt;
6781 PtrDiffType = SignedInt;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006782 Int64Type = SignedLongLong;
6783 IntMaxType = Int64Type;
Akira Hatanakab2206e72013-01-18 21:58:11 +00006784 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Akira Hatanaka8cc2e862011-11-05 01:48:34 +00006785 }
Craig Topper3164f332014-03-11 03:39:26 +00006786 bool setABI(const std::string &Name) override {
Simon Atanasyan755d7f92014-06-28 15:56:03 +00006787 if (Name == "o32" || Name == "eabi") {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006788 ABI = Name;
6789 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006790 }
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006791 return false;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006792 }
Craig Topper3164f332014-03-11 03:39:26 +00006793 void getTargetDefines(const LangOptions &Opts,
6794 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006795 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006796
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006797 Builder.defineMacro("__mips", "32");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00006798 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
6799
6800 const std::string& CPUStr = getCPU();
6801 if (CPUStr == "mips32")
6802 Builder.defineMacro("__mips_isa_rev", "1");
6803 else if (CPUStr == "mips32r2")
6804 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan162feb52015-02-20 23:37:40 +00006805 else if (CPUStr == "mips32r3")
6806 Builder.defineMacro("__mips_isa_rev", "3");
6807 else if (CPUStr == "mips32r5")
6808 Builder.defineMacro("__mips_isa_rev", "5");
Simon Atanasyane6694eb2015-01-15 07:04:48 +00006809 else if (CPUStr == "mips32r6")
6810 Builder.defineMacro("__mips_isa_rev", "6");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006811
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006812 if (ABI == "o32") {
6813 Builder.defineMacro("__mips_o32");
6814 Builder.defineMacro("_ABIO32", "1");
6815 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
6816 }
6817 else if (ABI == "eabi")
6818 Builder.defineMacro("__mips_eabi");
6819 else
David Blaikie83d382b2011-09-23 05:06:16 +00006820 llvm_unreachable("Invalid ABI for Mips32.");
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006821 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006822 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006823 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
6824 { { "at" }, "$1" },
6825 { { "v0" }, "$2" },
6826 { { "v1" }, "$3" },
6827 { { "a0" }, "$4" },
6828 { { "a1" }, "$5" },
6829 { { "a2" }, "$6" },
6830 { { "a3" }, "$7" },
6831 { { "t0" }, "$8" },
6832 { { "t1" }, "$9" },
6833 { { "t2" }, "$10" },
6834 { { "t3" }, "$11" },
6835 { { "t4" }, "$12" },
6836 { { "t5" }, "$13" },
6837 { { "t6" }, "$14" },
6838 { { "t7" }, "$15" },
6839 { { "s0" }, "$16" },
6840 { { "s1" }, "$17" },
6841 { { "s2" }, "$18" },
6842 { { "s3" }, "$19" },
6843 { { "s4" }, "$20" },
6844 { { "s5" }, "$21" },
6845 { { "s6" }, "$22" },
6846 { { "s7" }, "$23" },
6847 { { "t8" }, "$24" },
6848 { { "t9" }, "$25" },
6849 { { "k0" }, "$26" },
6850 { { "k1" }, "$27" },
6851 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00006852 { { "sp","$sp" }, "$29" },
6853 { { "fp","$fp" }, "$30" },
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006854 { { "ra" }, "$31" }
6855 };
Craig Topperf054e3a2015-10-19 03:52:27 +00006856 return llvm::makeArrayRef(GCCRegAliases);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006857 }
6858};
6859
6860class Mips32EBTargetInfo : public Mips32TargetInfoBase {
Eric Christopher964a5f32015-08-05 23:48:05 +00006861 void setDataLayoutString() override {
6862 DataLayoutString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00006863 }
6864
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006865public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006866 Mips32EBTargetInfo(const llvm::Triple &Triple)
6867 : Mips32TargetInfoBase(Triple) {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006868 }
Craig Topper3164f332014-03-11 03:39:26 +00006869 void getTargetDefines(const LangOptions &Opts,
6870 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006871 DefineStd(Builder, "MIPSEB", Opts);
6872 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006873 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006874 }
6875};
6876
6877class Mips32ELTargetInfo : public Mips32TargetInfoBase {
Eric Christopher964a5f32015-08-05 23:48:05 +00006878 void setDataLayoutString() override {
6879 DataLayoutString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
Akira Hatanaka9064e362013-10-29 18:30:33 +00006880 }
6881
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006882public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006883 Mips32ELTargetInfo(const llvm::Triple &Triple)
6884 : Mips32TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00006885 BigEndian = false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006886 }
Craig Topper3164f332014-03-11 03:39:26 +00006887 void getTargetDefines(const LangOptions &Opts,
6888 MacroBuilder &Builder) const override {
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006889 DefineStd(Builder, "MIPSEL", Opts);
6890 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006891 Mips32TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00006892 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00006893};
Akira Hatanakabef17452011-09-20 19:21:49 +00006894
6895class Mips64TargetInfoBase : public MipsTargetInfoBase {
Akira Hatanakabef17452011-09-20 19:21:49 +00006896public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00006897 Mips64TargetInfoBase(const llvm::Triple &Triple)
Simon Atanasyan1a3665b62014-01-27 13:59:04 +00006898 : MipsTargetInfoBase(Triple, "n64", "mips64r2") {
Akira Hatanakac12a2712011-10-22 00:07:27 +00006899 LongDoubleWidth = LongDoubleAlign = 128;
6900 LongDoubleFormat = &llvm::APFloat::IEEEquad;
David Chisnalla87d8592012-12-08 09:06:08 +00006901 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
6902 LongDoubleWidth = LongDoubleAlign = 64;
6903 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
6904 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006905 setN64ABITypes();
Nick Lewyckyf59e1292011-12-16 22:34:14 +00006906 SuitableAlign = 128;
Akira Hatanakab2206e72013-01-18 21:58:11 +00006907 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Akira Hatanakac12a2712011-10-22 00:07:27 +00006908 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006909
6910 void setN64ABITypes() {
6911 LongWidth = LongAlign = 64;
6912 PointerWidth = PointerAlign = 64;
6913 SizeType = UnsignedLong;
6914 PtrDiffType = SignedLong;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006915 Int64Type = SignedLong;
6916 IntMaxType = Int64Type;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006917 }
6918
6919 void setN32ABITypes() {
6920 LongWidth = LongAlign = 32;
6921 PointerWidth = PointerAlign = 32;
6922 SizeType = UnsignedInt;
6923 PtrDiffType = SignedInt;
Simon Atanasyan495523e42015-01-22 23:16:48 +00006924 Int64Type = SignedLongLong;
6925 IntMaxType = Int64Type;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006926 }
6927
Craig Topper3164f332014-03-11 03:39:26 +00006928 bool setABI(const std::string &Name) override {
Akira Hatanakac12a2712011-10-22 00:07:27 +00006929 if (Name == "n32") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00006930 setN32ABITypes();
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006931 ABI = Name;
6932 return true;
Simon Atanasyan98ba8a62014-06-28 15:56:08 +00006933 }
Simon Atanasyanad805952014-07-01 10:59:09 +00006934 if (Name == "n64") {
Daniel Sandersff1c0442014-04-24 09:58:52 +00006935 setN64ABITypes();
Simon Atanasyanad805952014-07-01 10:59:09 +00006936 ABI = Name;
Simon Atanasyan0da400c2013-02-27 14:55:49 +00006937 return true;
Daniel Sandersff1c0442014-04-24 09:58:52 +00006938 }
6939 return false;
Akira Hatanakabef17452011-09-20 19:21:49 +00006940 }
Daniel Sandersff1c0442014-04-24 09:58:52 +00006941
Craig Topper3164f332014-03-11 03:39:26 +00006942 void getTargetDefines(const LangOptions &Opts,
6943 MacroBuilder &Builder) const override {
Simon Atanasyan16ee0052012-08-29 19:59:32 +00006944 MipsTargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanaka6976ec82012-03-23 23:07:09 +00006945
Simon Atanasyan26292cc2014-01-27 13:59:11 +00006946 Builder.defineMacro("__mips", "64");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00006947 Builder.defineMacro("__mips64");
6948 Builder.defineMacro("__mips64__");
Matheus Almeidab84b37d2014-06-05 14:59:18 +00006949 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
6950
6951 const std::string& CPUStr = getCPU();
6952 if (CPUStr == "mips64")
6953 Builder.defineMacro("__mips_isa_rev", "1");
6954 else if (CPUStr == "mips64r2")
6955 Builder.defineMacro("__mips_isa_rev", "2");
Simon Atanasyan162feb52015-02-20 23:37:40 +00006956 else if (CPUStr == "mips64r3")
6957 Builder.defineMacro("__mips_isa_rev", "3");
6958 else if (CPUStr == "mips64r5")
6959 Builder.defineMacro("__mips_isa_rev", "5");
Simon Atanasyane6694eb2015-01-15 07:04:48 +00006960 else if (CPUStr == "mips64r6")
6961 Builder.defineMacro("__mips_isa_rev", "6");
Simon Atanasyanc6a0be02012-08-29 20:50:11 +00006962
Akira Hatanakabef17452011-09-20 19:21:49 +00006963 if (ABI == "n32") {
6964 Builder.defineMacro("__mips_n32");
6965 Builder.defineMacro("_ABIN32", "2");
6966 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
6967 }
6968 else if (ABI == "n64") {
6969 Builder.defineMacro("__mips_n64");
6970 Builder.defineMacro("_ABI64", "3");
6971 Builder.defineMacro("_MIPS_SIM", "_ABI64");
6972 }
6973 else
David Blaikie83d382b2011-09-23 05:06:16 +00006974 llvm_unreachable("Invalid ABI for Mips64.");
Daniel Sanders5176f7e2015-12-22 12:59:30 +00006975
6976 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Akira Hatanakabef17452011-09-20 19:21:49 +00006977 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006978 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00006979 static const TargetInfo::GCCRegAlias GCCRegAliases[] = {
6980 { { "at" }, "$1" },
6981 { { "v0" }, "$2" },
6982 { { "v1" }, "$3" },
6983 { { "a0" }, "$4" },
6984 { { "a1" }, "$5" },
6985 { { "a2" }, "$6" },
6986 { { "a3" }, "$7" },
6987 { { "a4" }, "$8" },
6988 { { "a5" }, "$9" },
6989 { { "a6" }, "$10" },
6990 { { "a7" }, "$11" },
6991 { { "t0" }, "$12" },
6992 { { "t1" }, "$13" },
6993 { { "t2" }, "$14" },
6994 { { "t3" }, "$15" },
6995 { { "s0" }, "$16" },
6996 { { "s1" }, "$17" },
6997 { { "s2" }, "$18" },
6998 { { "s3" }, "$19" },
6999 { { "s4" }, "$20" },
7000 { { "s5" }, "$21" },
7001 { { "s6" }, "$22" },
7002 { { "s7" }, "$23" },
7003 { { "t8" }, "$24" },
7004 { { "t9" }, "$25" },
7005 { { "k0" }, "$26" },
7006 { { "k1" }, "$27" },
7007 { { "gp" }, "$28" },
Eric Christopher8b6d0512012-03-27 19:56:11 +00007008 { { "sp","$sp" }, "$29" },
7009 { { "fp","$fp" }, "$30" },
Akira Hatanakabef17452011-09-20 19:21:49 +00007010 { { "ra" }, "$31" }
7011 };
Craig Topperf054e3a2015-10-19 03:52:27 +00007012 return llvm::makeArrayRef(GCCRegAliases);
Akira Hatanakabef17452011-09-20 19:21:49 +00007013 }
Daniel Sanders81ea6012014-04-24 16:05:26 +00007014
7015 bool hasInt128Type() const override { return true; }
Akira Hatanakabef17452011-09-20 19:21:49 +00007016};
7017
7018class Mips64EBTargetInfo : public Mips64TargetInfoBase {
Eric Christopher964a5f32015-08-05 23:48:05 +00007019 void setDataLayoutString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00007020 if (ABI == "n32")
Eric Christopher964a5f32015-08-05 23:48:05 +00007021 DataLayoutString = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00007022 else
Eric Christopher964a5f32015-08-05 23:48:05 +00007023 DataLayoutString = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00007024
Akira Hatanakabef17452011-09-20 19:21:49 +00007025 }
Akira Hatanaka9064e362013-10-29 18:30:33 +00007026
Akira Hatanakabef17452011-09-20 19:21:49 +00007027public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007028 Mips64EBTargetInfo(const llvm::Triple &Triple)
Akira Hatanaka9064e362013-10-29 18:30:33 +00007029 : Mips64TargetInfoBase(Triple) {}
Craig Topper3164f332014-03-11 03:39:26 +00007030 void getTargetDefines(const LangOptions &Opts,
7031 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00007032 DefineStd(Builder, "MIPSEB", Opts);
7033 Builder.defineMacro("_MIPSEB");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00007034 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00007035 }
7036};
7037
7038class Mips64ELTargetInfo : public Mips64TargetInfoBase {
Eric Christopher964a5f32015-08-05 23:48:05 +00007039 void setDataLayoutString() override {
Akira Hatanaka9064e362013-10-29 18:30:33 +00007040 if (ABI == "n32")
Eric Christopher964a5f32015-08-05 23:48:05 +00007041 DataLayoutString = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanaka9064e362013-10-29 18:30:33 +00007042 else
Eric Christopher964a5f32015-08-05 23:48:05 +00007043 DataLayoutString = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Akira Hatanakabef17452011-09-20 19:21:49 +00007044 }
7045public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007046 Mips64ELTargetInfo(const llvm::Triple &Triple)
7047 : Mips64TargetInfoBase(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00007048 // Default ABI is n64.
7049 BigEndian = false;
Akira Hatanakabef17452011-09-20 19:21:49 +00007050 }
Craig Topper3164f332014-03-11 03:39:26 +00007051 void getTargetDefines(const LangOptions &Opts,
7052 MacroBuilder &Builder) const override {
Akira Hatanakabef17452011-09-20 19:21:49 +00007053 DefineStd(Builder, "MIPSEL", Opts);
7054 Builder.defineMacro("_MIPSEL");
Simon Atanasyan16ee0052012-08-29 19:59:32 +00007055 Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
Akira Hatanakabef17452011-09-20 19:21:49 +00007056 }
7057};
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007058
Ivan Krasindd7403e2011-08-24 20:22:22 +00007059class PNaClTargetInfo : public TargetInfo {
7060public:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007061 PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
Eli Friedman803acb32011-12-22 03:51:45 +00007062 BigEndian = false;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007063 this->UserLabelPrefix = "";
7064 this->LongAlign = 32;
7065 this->LongWidth = 32;
7066 this->PointerAlign = 32;
7067 this->PointerWidth = 32;
7068 this->IntMaxType = TargetInfo::SignedLongLong;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007069 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00007070 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00007071 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00007072 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00007073 this->SizeType = TargetInfo::UnsignedInt;
7074 this->PtrDiffType = TargetInfo::SignedInt;
7075 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +00007076 this->RegParmMax = 0; // Disallow regparm
Ivan Krasindd7403e2011-08-24 20:22:22 +00007077 }
7078
Craig Toppere6f17d02014-03-11 04:07:52 +00007079 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00007080 Builder.defineMacro("__le32__");
7081 Builder.defineMacro("__pnacl__");
7082 }
Craig Topper3164f332014-03-11 03:39:26 +00007083 void getTargetDefines(const LangOptions &Opts,
7084 MacroBuilder &Builder) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00007085 getArchDefines(Opts, Builder);
7086 }
Craig Topper3164f332014-03-11 03:39:26 +00007087 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00007088 return Feature == "pnacl";
7089 }
Craig Topper6c03a542015-10-19 04:51:35 +00007090 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Craig Topper3164f332014-03-11 03:39:26 +00007091 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00007092 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007093 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007094 ArrayRef<const char *> getGCCRegNames() const override;
7095 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00007096 bool validateAsmConstraint(const char *&Name,
7097 TargetInfo::ConstraintInfo &Info) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00007098 return false;
7099 }
7100
Craig Topper3164f332014-03-11 03:39:26 +00007101 const char *getClobbers() const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00007102 return "";
7103 }
7104};
7105
Craig Topperf054e3a2015-10-19 03:52:27 +00007106ArrayRef<const char *> PNaClTargetInfo::getGCCRegNames() const {
7107 return None;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007108}
7109
Craig Topperf054e3a2015-10-19 03:52:27 +00007110ArrayRef<TargetInfo::GCCRegAlias> PNaClTargetInfo::getGCCRegAliases() const {
7111 return None;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007112}
Ivan Krasindd7403e2011-08-24 20:22:22 +00007113
Petar Jovanovic26a4a402015-07-08 13:07:31 +00007114// We attempt to use PNaCl (le32) frontend and Mips32EL backend.
7115class NaClMips32ELTargetInfo : public Mips32ELTargetInfo {
7116public:
7117 NaClMips32ELTargetInfo(const llvm::Triple &Triple) :
Petar Jovanovic2e0551f2015-08-11 21:27:39 +00007118 Mips32ELTargetInfo(Triple) {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00007119 }
7120
7121 BuiltinVaListKind getBuiltinVaListKind() const override {
7122 return TargetInfo::PNaClABIBuiltinVaList;
7123 }
7124};
7125
JF Bastien643817d2014-09-12 17:52:47 +00007126class Le64TargetInfo : public TargetInfo {
7127 static const Builtin::Info BuiltinInfo[];
7128
7129public:
7130 Le64TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
7131 BigEndian = false;
7132 NoAsmVariants = true;
7133 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
7134 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eric Christopher964a5f32015-08-05 23:48:05 +00007135 DataLayoutString = "e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128";
JF Bastien643817d2014-09-12 17:52:47 +00007136 }
7137
7138 void getTargetDefines(const LangOptions &Opts,
7139 MacroBuilder &Builder) const override {
7140 DefineStd(Builder, "unix", Opts);
7141 defineCPUMacros(Builder, "le64", /*Tuning=*/false);
7142 Builder.defineMacro("__ELF__");
7143 }
Craig Topper6c03a542015-10-19 04:51:35 +00007144 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7145 return llvm::makeArrayRef(BuiltinInfo,
7146 clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin);
JF Bastien643817d2014-09-12 17:52:47 +00007147 }
7148 BuiltinVaListKind getBuiltinVaListKind() const override {
7149 return TargetInfo::PNaClABIBuiltinVaList;
7150 }
7151 const char *getClobbers() const override { return ""; }
Craig Topperf054e3a2015-10-19 03:52:27 +00007152 ArrayRef<const char *> getGCCRegNames() const override {
7153 return None;
JF Bastien643817d2014-09-12 17:52:47 +00007154 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007155 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7156 return None;
JF Bastien643817d2014-09-12 17:52:47 +00007157 }
7158 bool validateAsmConstraint(const char *&Name,
7159 TargetInfo::ConstraintInfo &Info) const override {
7160 return false;
7161 }
7162
7163 bool hasProtectedVisibility() const override { return false; }
JF Bastien643817d2014-09-12 17:52:47 +00007164};
Dan Gohmanc2853072015-09-03 22:51:53 +00007165
7166class WebAssemblyTargetInfo : public TargetInfo {
7167 static const Builtin::Info BuiltinInfo[];
7168
7169 enum SIMDEnum {
7170 NoSIMD,
7171 SIMD128,
7172 } SIMDLevel;
7173
7174public:
7175 explicit WebAssemblyTargetInfo(const llvm::Triple &T)
7176 : TargetInfo(T), SIMDLevel(NoSIMD) {
7177 BigEndian = false;
7178 NoAsmVariants = true;
7179 SuitableAlign = 128;
7180 LargeArrayMinWidth = 128;
7181 LargeArrayAlign = 128;
7182 SimdDefaultAlign = 128;
Dan Gohmanf1c34e62015-09-14 21:56:37 +00007183 SigAtomicType = SignedLong;
Dan Gohman6db46402015-11-10 21:01:46 +00007184 LongDoubleWidth = LongDoubleAlign = 128;
7185 LongDoubleFormat = &llvm::APFloat::IEEEquad;
Dan Gohmanc2853072015-09-03 22:51:53 +00007186 }
7187
7188protected:
7189 void getTargetDefines(const LangOptions &Opts,
7190 MacroBuilder &Builder) const override {
7191 defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
7192 if (SIMDLevel >= SIMD128)
7193 Builder.defineMacro("__wasm_simd128__");
7194 }
7195
7196private:
Eric Christopher8c47b422015-10-09 18:39:55 +00007197 bool
7198 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
7199 StringRef CPU,
7200 const std::vector<std::string> &FeaturesVec) const override {
Dan Gohmanc2853072015-09-03 22:51:53 +00007201 if (CPU == "bleeding-edge")
7202 Features["simd128"] = true;
7203 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
7204 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00007205 bool hasFeature(StringRef Feature) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00007206 return llvm::StringSwitch<bool>(Feature)
7207 .Case("simd128", SIMDLevel >= SIMD128)
7208 .Default(false);
7209 }
7210 bool handleTargetFeatures(std::vector<std::string> &Features,
Hans Wennborg7eb54642015-09-10 17:07:54 +00007211 DiagnosticsEngine &Diags) final {
Dan Gohmanc2853072015-09-03 22:51:53 +00007212 for (const auto &Feature : Features) {
7213 if (Feature == "+simd128") {
7214 SIMDLevel = std::max(SIMDLevel, SIMD128);
7215 continue;
7216 }
7217 if (Feature == "-simd128") {
7218 SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
7219 continue;
7220 }
7221
7222 Diags.Report(diag::err_opt_not_valid_with_opt) << Feature
7223 << "-target-feature";
7224 return false;
7225 }
7226 return true;
7227 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00007228 bool setCPU(const std::string &Name) final {
Dan Gohmanc2853072015-09-03 22:51:53 +00007229 return llvm::StringSwitch<bool>(Name)
7230 .Case("mvp", true)
7231 .Case("bleeding-edge", true)
7232 .Case("generic", true)
7233 .Default(false);
7234 }
Craig Topper6c03a542015-10-19 04:51:35 +00007235 ArrayRef<Builtin::Info> getTargetBuiltins() const final {
7236 return llvm::makeArrayRef(BuiltinInfo,
7237 clang::WebAssembly::LastTSBuiltin - Builtin::FirstTSBuiltin);
Dan Gohmanc2853072015-09-03 22:51:53 +00007238 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00007239 BuiltinVaListKind getBuiltinVaListKind() const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00007240 return VoidPtrBuiltinVaList;
7241 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007242 ArrayRef<const char *> getGCCRegNames() const final {
7243 return None;
Dan Gohmanc2853072015-09-03 22:51:53 +00007244 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007245 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
7246 return None;
Dan Gohmanc2853072015-09-03 22:51:53 +00007247 }
7248 bool
7249 validateAsmConstraint(const char *&Name,
Hans Wennborg7eb54642015-09-10 17:07:54 +00007250 TargetInfo::ConstraintInfo &Info) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00007251 return false;
7252 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00007253 const char *getClobbers() const final { return ""; }
7254 bool isCLZForZeroUndef() const final { return false; }
7255 bool hasInt128Type() const final { return true; }
Dan Gohmanab0e31f2015-09-14 21:49:41 +00007256 IntType getIntTypeByWidth(unsigned BitWidth,
7257 bool IsSigned) const final {
7258 // WebAssembly prefers long long for explicitly 64-bit integers.
7259 return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
7260 : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
7261 }
7262 IntType getLeastIntTypeByWidth(unsigned BitWidth,
7263 bool IsSigned) const final {
7264 // WebAssembly uses long long for int_least64_t and int_fast64_t.
7265 return BitWidth == 64
7266 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
7267 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
7268 }
Dan Gohmanc2853072015-09-03 22:51:53 +00007269};
7270
7271const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
7272#define BUILTIN(ID, TYPE, ATTRS) \
7273 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7274#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
7275 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
7276#include "clang/Basic/BuiltinsWebAssembly.def"
7277};
7278
7279class WebAssembly32TargetInfo : public WebAssemblyTargetInfo {
7280public:
7281 explicit WebAssembly32TargetInfo(const llvm::Triple &T)
7282 : WebAssemblyTargetInfo(T) {
Dan Gohmanf1c34e62015-09-14 21:56:37 +00007283 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Dan Gohman0d75f2c2016-01-07 03:20:15 +00007284 DataLayoutString = "e-m:e-p:32:32-i64:64-n32:64-S128";
Dan Gohmanc2853072015-09-03 22:51:53 +00007285 }
7286
7287protected:
7288 void getTargetDefines(const LangOptions &Opts,
7289 MacroBuilder &Builder) const override {
7290 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
7291 defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
7292 }
7293};
7294
7295class WebAssembly64TargetInfo : public WebAssemblyTargetInfo {
7296public:
7297 explicit WebAssembly64TargetInfo(const llvm::Triple &T)
7298 : WebAssemblyTargetInfo(T) {
7299 LongAlign = LongWidth = 64;
7300 PointerAlign = PointerWidth = 64;
Dan Gohmanf1c34e62015-09-14 21:56:37 +00007301 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Dan Gohman0d75f2c2016-01-07 03:20:15 +00007302 DataLayoutString = "e-m:e-p:64:64-i64:64-n32:64-S128";
Dan Gohmanc2853072015-09-03 22:51:53 +00007303 }
7304
7305protected:
7306 void getTargetDefines(const LangOptions &Opts,
7307 MacroBuilder &Builder) const override {
7308 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
7309 defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
7310 }
7311};
7312
JF Bastien643817d2014-09-12 17:52:47 +00007313const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
7314#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00007315 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
JF Bastien643817d2014-09-12 17:52:47 +00007316#include "clang/Basic/BuiltinsLe64.def"
7317};
7318
Eric Christopherc48497a2015-09-18 21:26:24 +00007319static const unsigned SPIRAddrSpaceMap[] = {
7320 1, // opencl_global
7321 3, // opencl_local
7322 2, // opencl_constant
7323 4, // opencl_generic
7324 0, // cuda_device
7325 0, // cuda_constant
7326 0 // cuda_shared
7327};
7328class SPIRTargetInfo : public TargetInfo {
7329public:
7330 SPIRTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
7331 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
7332 "SPIR target must use unknown OS");
7333 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
7334 "SPIR target must use unknown environment type");
7335 BigEndian = false;
7336 TLSSupported = false;
7337 LongWidth = LongAlign = 64;
7338 AddrSpaceMap = &SPIRAddrSpaceMap;
7339 UseAddrSpaceMapMangling = true;
7340 // Define available target features
7341 // These must be defined in sorted order!
7342 NoAsmVariants = true;
7343 }
7344 void getTargetDefines(const LangOptions &Opts,
7345 MacroBuilder &Builder) const override {
7346 DefineStd(Builder, "SPIR", Opts);
7347 }
7348 bool hasFeature(StringRef Feature) const override {
7349 return Feature == "spir";
7350 }
Craig Topper3164f332014-03-11 03:39:26 +00007351
Craig Topper6c03a542015-10-19 04:51:35 +00007352 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00007353 const char *getClobbers() const override { return ""; }
Craig Topperf054e3a2015-10-19 03:52:27 +00007354 ArrayRef<const char *> getGCCRegNames() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00007355 bool validateAsmConstraint(const char *&Name,
7356 TargetInfo::ConstraintInfo &info) const override {
7357 return true;
7358 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007359 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7360 return None;
7361 }
Eric Christopherc48497a2015-09-18 21:26:24 +00007362 BuiltinVaListKind getBuiltinVaListKind() const override {
7363 return TargetInfo::VoidPtrBuiltinVaList;
7364 }
Alexander Kornienko21de0ae2015-01-20 11:20:41 +00007365
Eric Christopherc48497a2015-09-18 21:26:24 +00007366 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
7367 return (CC == CC_SpirFunction || CC == CC_SpirKernel) ? CCCR_OK
7368 : CCCR_Warning;
7369 }
Alexander Kornienko21de0ae2015-01-20 11:20:41 +00007370
Eric Christopherc48497a2015-09-18 21:26:24 +00007371 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
7372 return CC_SpirFunction;
7373 }
7374};
Guy Benyeib798fc92012-12-11 21:38:14 +00007375
Eric Christopherc48497a2015-09-18 21:26:24 +00007376class SPIR32TargetInfo : public SPIRTargetInfo {
7377public:
7378 SPIR32TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
7379 PointerWidth = PointerAlign = 32;
7380 SizeType = TargetInfo::UnsignedInt;
7381 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
7382 DataLayoutString = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
7383 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
7384 }
7385 void getTargetDefines(const LangOptions &Opts,
7386 MacroBuilder &Builder) const override {
7387 DefineStd(Builder, "SPIR32", Opts);
7388 }
7389};
Guy Benyeib798fc92012-12-11 21:38:14 +00007390
Eric Christopherc48497a2015-09-18 21:26:24 +00007391class SPIR64TargetInfo : public SPIRTargetInfo {
7392public:
7393 SPIR64TargetInfo(const llvm::Triple &Triple) : SPIRTargetInfo(Triple) {
7394 PointerWidth = PointerAlign = 64;
7395 SizeType = TargetInfo::UnsignedLong;
7396 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
7397 DataLayoutString = "e-i64:64-v16:16-v24:32-v32:32-v48:64-"
7398 "v96:128-v192:256-v256:256-v512:512-v1024:1024";
7399 }
7400 void getTargetDefines(const LangOptions &Opts,
7401 MacroBuilder &Builder) const override {
7402 DefineStd(Builder, "SPIR64", Opts);
7403 }
7404};
Guy Benyeib798fc92012-12-11 21:38:14 +00007405
Robert Lytton0e076492013-08-13 09:43:10 +00007406class XCoreTargetInfo : public TargetInfo {
7407 static const Builtin::Info BuiltinInfo[];
7408public:
7409 XCoreTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
7410 BigEndian = false;
7411 NoAsmVariants = true;
7412 LongLongAlign = 32;
7413 SuitableAlign = 32;
7414 DoubleAlign = LongDoubleAlign = 32;
Robert Lyttoncc424662013-11-12 10:09:30 +00007415 SizeType = UnsignedInt;
7416 PtrDiffType = SignedInt;
7417 IntPtrType = SignedInt;
7418 WCharType = UnsignedChar;
7419 WIntType = UnsignedInt;
Robert Lytton0e076492013-08-13 09:43:10 +00007420 UseZeroLengthBitfieldAlignment = true;
Eric Christopher964a5f32015-08-05 23:48:05 +00007421 DataLayoutString = "e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
7422 "-f64:32-a:0:32-n32";
Robert Lytton0e076492013-08-13 09:43:10 +00007423 }
Craig Topper3164f332014-03-11 03:39:26 +00007424 void getTargetDefines(const LangOptions &Opts,
7425 MacroBuilder &Builder) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00007426 Builder.defineMacro("__XS1B__");
7427 }
Craig Topper6c03a542015-10-19 04:51:35 +00007428 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7429 return llvm::makeArrayRef(BuiltinInfo,
7430 clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin);
Robert Lytton0e076492013-08-13 09:43:10 +00007431 }
Craig Topper3164f332014-03-11 03:39:26 +00007432 BuiltinVaListKind getBuiltinVaListKind() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00007433 return TargetInfo::VoidPtrBuiltinVaList;
7434 }
Craig Topper3164f332014-03-11 03:39:26 +00007435 const char *getClobbers() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00007436 return "";
7437 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007438 ArrayRef<const char *> getGCCRegNames() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00007439 static const char * const GCCRegNames[] = {
7440 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
7441 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
7442 };
Craig Topperf054e3a2015-10-19 03:52:27 +00007443 return llvm::makeArrayRef(GCCRegNames);
Robert Lytton0e076492013-08-13 09:43:10 +00007444 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007445 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7446 return None;
Robert Lytton0e076492013-08-13 09:43:10 +00007447 }
Craig Topper3164f332014-03-11 03:39:26 +00007448 bool validateAsmConstraint(const char *&Name,
7449 TargetInfo::ConstraintInfo &Info) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00007450 return false;
7451 }
Craig Topper3164f332014-03-11 03:39:26 +00007452 int getEHDataRegisterNumber(unsigned RegNo) const override {
Robert Lytton1a229262014-01-27 17:56:25 +00007453 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
7454 return (RegNo < 2)? RegNo : -1;
7455 }
Robert Lytton0e076492013-08-13 09:43:10 +00007456};
7457
7458const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00007459#define BUILTIN(ID, TYPE, ATTRS) \
7460 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
7461#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
7462 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Robert Lytton0e076492013-08-13 09:43:10 +00007463#include "clang/Basic/BuiltinsXCore.def"
7464};
Robert Lytton0e076492013-08-13 09:43:10 +00007465
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007466// x86_32 Android target
7467class AndroidX86_32TargetInfo : public LinuxTargetInfo<X86_32TargetInfo> {
7468public:
7469 AndroidX86_32TargetInfo(const llvm::Triple &Triple)
7470 : LinuxTargetInfo<X86_32TargetInfo>(Triple) {
7471 SuitableAlign = 32;
7472 LongDoubleWidth = 64;
7473 LongDoubleFormat = &llvm::APFloat::IEEEdouble;
7474 }
7475};
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007476
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007477// x86_64 Android target
7478class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> {
7479public:
7480 AndroidX86_64TargetInfo(const llvm::Triple &Triple)
7481 : LinuxTargetInfo<X86_64TargetInfo>(Triple) {
7482 LongDoubleFormat = &llvm::APFloat::IEEEquad;
7483 }
Chih-Hung Hsieh0b0eeaa2015-07-24 18:12:54 +00007484
7485 bool useFloat128ManglingForLongDouble() const override {
7486 return true;
7487 }
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007488};
7489} // end anonymous namespace
7490
Chris Lattner5ba61f02006-10-14 07:39:34 +00007491//===----------------------------------------------------------------------===//
7492// Driver code
7493//===----------------------------------------------------------------------===//
7494
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007495static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
Daniel Dunbar52322032009-08-18 05:47:58 +00007496 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00007497
Daniel Dunbar52322032009-08-18 05:47:58 +00007498 switch (Triple.getArch()) {
7499 default:
Craig Topperf1186c52014-05-08 06:41:40 +00007500 return nullptr;
Eli Friedmanb5366062008-05-20 14:21:01 +00007501
Tim Northover2a0783d2014-05-30 14:14:07 +00007502 case llvm::Triple::xcore:
7503 return new XCoreTargetInfo(Triple);
7504
7505 case llvm::Triple::hexagon:
7506 return new HexagonTargetInfo(Triple);
7507
7508 case llvm::Triple::aarch64:
Tim Northovera2ee4332014-03-29 15:09:45 +00007509 if (Triple.isOSDarwin())
Tim Northover573cbee2014-05-24 12:52:07 +00007510 return new DarwinAArch64TargetInfo(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00007511
7512 switch (os) {
Ed Schoutenea9448e2015-10-15 15:07:07 +00007513 case llvm::Triple::CloudABI:
7514 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple);
Ed Maste6a9eda52014-11-13 16:55:42 +00007515 case llvm::Triple::FreeBSD:
7516 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00007517 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00007518 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00007519 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00007520 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple);
Tim Northovera2ee4332014-03-29 15:09:45 +00007521 default:
Tim Northover573cbee2014-05-24 12:52:07 +00007522 return new AArch64leTargetInfo(Triple);
James Molloy5e73df52014-04-16 15:06:20 +00007523 }
7524
Christian Pirker9b019ae2014-02-25 13:51:00 +00007525 case llvm::Triple::aarch64_be:
7526 switch (os) {
Ed Maste6a9eda52014-11-13 16:55:42 +00007527 case llvm::Triple::FreeBSD:
7528 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00007529 case llvm::Triple::Linux:
Tim Northover573cbee2014-05-24 12:52:07 +00007530 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00007531 case llvm::Triple::NetBSD:
Tim Northover573cbee2014-05-24 12:52:07 +00007532 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple);
Christian Pirker9b019ae2014-02-25 13:51:00 +00007533 default:
Tim Northover573cbee2014-05-24 12:52:07 +00007534 return new AArch64beTargetInfo(Triple);
Tim Northover9bb857a2013-01-31 12:13:10 +00007535 }
7536
Daniel Dunbar52322032009-08-18 05:47:58 +00007537 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00007538 case llvm::Triple::thumb:
Tim Northover157d9112014-01-16 08:48:16 +00007539 if (Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007540 return new DarwinARMTargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007541
Daniel Dunbar52322032009-08-18 05:47:58 +00007542 switch (os) {
Rafael Espindolaad8fed52010-06-10 00:46:51 +00007543 case llvm::Triple::Linux:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007544 return new LinuxTargetInfo<ARMleTargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007545 case llvm::Triple::FreeBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007546 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007547 case llvm::Triple::NetBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007548 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00007549 case llvm::Triple::OpenBSD:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007550 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00007551 case llvm::Triple::Bitrig:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007552 return new BitrigTargetInfo<ARMleTargetInfo>(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00007553 case llvm::Triple::RTEMS:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007554 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00007555 case llvm::Triple::NaCl:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007556 return new NaClTargetInfo<ARMleTargetInfo>(Triple);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00007557 case llvm::Triple::Win32:
7558 switch (Triple.getEnvironment()) {
Yaron Keren321249c2015-07-15 13:32:23 +00007559 case llvm::Triple::Cygnus:
7560 return new CygwinARMTargetInfo(Triple);
7561 case llvm::Triple::GNU:
7562 return new MinGWARMTargetInfo(Triple);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00007563 case llvm::Triple::Itanium:
7564 return new ItaniumWindowsARMleTargetInfo(Triple);
7565 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00007566 default: // Assume MSVC for unknown environments
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00007567 return new MicrosoftARMleTargetInfo(Triple);
7568 }
Daniel Dunbar52322032009-08-18 05:47:58 +00007569 default:
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00007570 return new ARMleTargetInfo(Triple);
7571 }
7572
7573 case llvm::Triple::armeb:
7574 case llvm::Triple::thumbeb:
7575 if (Triple.isOSDarwin())
7576 return new DarwinARMTargetInfo(Triple);
7577
7578 switch (os) {
7579 case llvm::Triple::Linux:
7580 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple);
7581 case llvm::Triple::FreeBSD:
7582 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple);
7583 case llvm::Triple::NetBSD:
7584 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple);
7585 case llvm::Triple::OpenBSD:
7586 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple);
7587 case llvm::Triple::Bitrig:
7588 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple);
7589 case llvm::Triple::RTEMS:
7590 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple);
7591 case llvm::Triple::NaCl:
7592 return new NaClTargetInfo<ARMbeTargetInfo>(Triple);
7593 default:
7594 return new ARMbeTargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007595 }
Eli Friedmanb5366062008-05-20 14:21:01 +00007596
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007597 case llvm::Triple::bpfeb:
7598 case llvm::Triple::bpfel:
7599 return new BPFTargetInfo(Triple);
7600
Daniel Dunbar52322032009-08-18 05:47:58 +00007601 case llvm::Triple::msp430:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007602 return new MSP430TargetInfo(Triple);
Eli Friedmanb5366062008-05-20 14:21:01 +00007603
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007604 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007605 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007606 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007607 return new LinuxTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007608 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007609 return new RTEMSTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007610 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007611 return new FreeBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007612 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007613 return new NetBSDTargetInfo<Mips32EBTargetInfo>(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007614 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007615 return new Mips32EBTargetInfo(Triple);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00007616 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007617
7618 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007619 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007620 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007621 return new LinuxTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007622 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007623 return new RTEMSTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007624 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007625 return new FreeBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007626 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007627 return new NetBSDTargetInfo<Mips32ELTargetInfo>(Triple);
Petar Jovanovicc19a2842013-09-21 01:27:01 +00007628 case llvm::Triple::NaCl:
Petar Jovanovic26a4a402015-07-08 13:07:31 +00007629 return new NaClTargetInfo<NaClMips32ELTargetInfo>(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007630 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007631 return new Mips32ELTargetInfo(Triple);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00007632 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007633
Akira Hatanakabef17452011-09-20 19:21:49 +00007634 case llvm::Triple::mips64:
7635 switch (os) {
7636 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007637 return new LinuxTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007638 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007639 return new RTEMSTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007640 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007641 return new FreeBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007642 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007643 return new NetBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00007644 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007645 return new OpenBSDTargetInfo<Mips64EBTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007646 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007647 return new Mips64EBTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007648 }
7649
7650 case llvm::Triple::mips64el:
7651 switch (os) {
7652 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007653 return new LinuxTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007654 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007655 return new RTEMSTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007656 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007657 return new FreeBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007658 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007659 return new NetBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00007660 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007661 return new OpenBSDTargetInfo<Mips64ELTargetInfo>(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007662 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007663 return new Mips64ELTargetInfo(Triple);
Akira Hatanakabef17452011-09-20 19:21:49 +00007664 }
7665
Ivan Krasindd7403e2011-08-24 20:22:22 +00007666 case llvm::Triple::le32:
7667 switch (os) {
Douglas Katzman78d7c542015-05-12 21:18:10 +00007668 case llvm::Triple::NaCl:
7669 return new NaClTargetInfo<PNaClTargetInfo>(Triple);
7670 default:
7671 return nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00007672 }
7673
JF Bastien643817d2014-09-12 17:52:47 +00007674 case llvm::Triple::le64:
7675 return new Le64TargetInfo(Triple);
7676
Daniel Dunbar52322032009-08-18 05:47:58 +00007677 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007678 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007679 return new DarwinPPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007680 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00007681 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007682 return new LinuxTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007683 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007684 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007685 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007686 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00007687 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007688 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007689 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007690 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007691 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007692 return new PPC32TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007693 }
Daniel Dunbar52322032009-08-18 05:47:58 +00007694
7695 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007696 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007697 return new DarwinPPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007698 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00007699 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007700 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007701 case llvm::Triple::Lv2:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007702 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007703 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007704 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007705 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007706 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007707 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007708 return new PPC64TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007709 }
Daniel Dunbar52322032009-08-18 05:47:58 +00007710
Bill Schmidt778d3872013-07-26 01:36:11 +00007711 case llvm::Triple::ppc64le:
7712 switch (os) {
7713 case llvm::Triple::Linux:
7714 return new LinuxTargetInfo<PPC64TargetInfo>(Triple);
Joerg Sonnenberger22a2d992015-04-10 20:53:48 +00007715 case llvm::Triple::NetBSD:
7716 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple);
Bill Schmidt778d3872013-07-26 01:36:11 +00007717 default:
7718 return new PPC64TargetInfo(Triple);
7719 }
7720
Peter Collingbournec947aae2012-05-20 23:28:41 +00007721 case llvm::Triple::nvptx:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007722 return new NVPTX32TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00007723 case llvm::Triple::nvptx64:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007724 return new NVPTX64TargetInfo(Triple);
Peter Collingbournec947aae2012-05-20 23:28:41 +00007725
Tom Stellardd8e38a32015-01-06 20:34:47 +00007726 case llvm::Triple::amdgcn:
Eli Friedmand13b41e2012-10-12 23:32:00 +00007727 case llvm::Triple::r600:
Matt Arsenault3ea39f92015-06-19 17:54:10 +00007728 return new AMDGPUTargetInfo(Triple);
Eli Friedmand13b41e2012-10-12 23:32:00 +00007729
Daniel Dunbar52322032009-08-18 05:47:58 +00007730 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007731 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00007732 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007733 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007734 case llvm::Triple::Solaris:
James Y Knight4b4d19e2015-06-04 15:36:29 +00007735 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007736 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007737 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
Hans Wennborg0bb84622012-08-02 13:45:48 +00007738 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007739 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007740 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007741 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007742 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007743 return new SparcV8TargetInfo(Triple);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00007744 }
Daniel Dunbar52322032009-08-18 05:47:58 +00007745
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007746 // The 'sparcel' architecture copies all the above cases except for Solaris.
7747 case llvm::Triple::sparcel:
7748 switch (os) {
7749 case llvm::Triple::Linux:
7750 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple);
7751 case llvm::Triple::NetBSD:
7752 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple);
7753 case llvm::Triple::OpenBSD:
7754 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple);
7755 case llvm::Triple::RTEMS:
7756 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple);
7757 default:
7758 return new SparcV8elTargetInfo(Triple);
7759 }
7760
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007761 case llvm::Triple::sparcv9:
7762 switch (os) {
7763 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007764 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007765 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007766 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007767 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007768 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007769 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007770 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007771 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007772 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007773 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007774 return new SparcV9TargetInfo(Triple);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007775 }
7776
Ulrich Weigand47445072013-05-06 16:26:41 +00007777 case llvm::Triple::systemz:
7778 switch (os) {
7779 case llvm::Triple::Linux:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007780 return new LinuxTargetInfo<SystemZTargetInfo>(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00007781 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007782 return new SystemZTargetInfo(Triple);
Ulrich Weigand47445072013-05-06 16:26:41 +00007783 }
7784
Eli Friedmana9c3d712009-08-19 20:47:07 +00007785 case llvm::Triple::tce:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007786 return new TCETargetInfo(Triple);
Eli Friedmana9c3d712009-08-19 20:47:07 +00007787
Daniel Dunbar52322032009-08-18 05:47:58 +00007788 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007789 if (Triple.isOSDarwin())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007790 return new DarwinI386TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007791
Daniel Dunbar52322032009-08-18 05:47:58 +00007792 switch (os) {
Ed Schouten7893e682015-06-13 21:33:49 +00007793 case llvm::Triple::CloudABI:
7794 return new CloudABITargetInfo<X86_32TargetInfo>(Triple);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007795 case llvm::Triple::Linux: {
7796 switch (Triple.getEnvironment()) {
7797 default:
7798 return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
7799 case llvm::Triple::Android:
7800 return new AndroidX86_32TargetInfo(Triple);
7801 }
7802 }
Daniel Dunbar52322032009-08-18 05:47:58 +00007803 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007804 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007805 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007806 return new NetBSDI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007807 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007808 return new OpenBSDI386TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00007809 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007810 return new BitrigI386TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007811 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007812 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00007813 case llvm::Triple::KFreeBSD:
7814 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
Chris Lattner3e2ee142010-07-07 16:01:42 +00007815 case llvm::Triple::Minix:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007816 return new MinixTargetInfo<X86_32TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007817 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007818 return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007819 case llvm::Triple::Win32: {
7820 switch (Triple.getEnvironment()) {
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007821 case llvm::Triple::Cygnus:
7822 return new CygwinX86_32TargetInfo(Triple);
7823 case llvm::Triple::GNU:
7824 return new MinGWX86_32TargetInfo(Triple);
Saleem Abdulrasool24bd7da2014-06-28 23:34:11 +00007825 case llvm::Triple::Itanium:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007826 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00007827 default: // Assume MSVC for unknown environments
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00007828 return new MicrosoftX86_32TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007829 }
7830 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00007831 case llvm::Triple::Haiku:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007832 return new HaikuX86_32TargetInfo(Triple);
Douglas Gregor9fabd852011-07-01 22:41:14 +00007833 case llvm::Triple::RTEMS:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007834 return new RTEMSX86_32TargetInfo(Triple);
Eli Benderskyd7c92032012-12-04 18:38:10 +00007835 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007836 return new NaClTargetInfo<X86_32TargetInfo>(Triple);
Alexey Bataevc99b0492015-11-25 09:24:26 +00007837 case llvm::Triple::ELFIAMCU:
7838 return new MCUX86_32TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007839 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007840 return new X86_32TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007841 }
7842
7843 case llvm::Triple::x86_64:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007844 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007845 return new DarwinX86_64TargetInfo(Triple);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00007846
Daniel Dunbar52322032009-08-18 05:47:58 +00007847 switch (os) {
Ed Schoutenf33c6072015-03-11 08:42:46 +00007848 case llvm::Triple::CloudABI:
7849 return new CloudABITargetInfo<X86_64TargetInfo>(Triple);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00007850 case llvm::Triple::Linux: {
7851 switch (Triple.getEnvironment()) {
7852 default:
7853 return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
7854 case llvm::Triple::Android:
7855 return new AndroidX86_64TargetInfo(Triple);
7856 }
7857 }
Chris Lattner002ba6b2010-01-09 05:41:14 +00007858 case llvm::Triple::DragonFly:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007859 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007860 case llvm::Triple::NetBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007861 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007862 case llvm::Triple::OpenBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007863 return new OpenBSDX86_64TargetInfo(Triple);
Eli Friedman9fa28852012-08-08 23:57:20 +00007864 case llvm::Triple::Bitrig:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007865 return new BitrigX86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007866 case llvm::Triple::FreeBSD:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007867 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00007868 case llvm::Triple::KFreeBSD:
7869 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007870 case llvm::Triple::Solaris:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007871 return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007872 case llvm::Triple::Win32: {
7873 switch (Triple.getEnvironment()) {
Yaron Kerend030d112015-07-22 17:38:19 +00007874 case llvm::Triple::Cygnus:
7875 return new CygwinX86_64TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007876 case llvm::Triple::GNU:
7877 return new MinGWX86_64TargetInfo(Triple);
7878 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00007879 default: // Assume MSVC for unknown environments
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00007880 return new MicrosoftX86_64TargetInfo(Triple);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00007881 }
7882 }
Eli Benderskyd7c92032012-12-04 18:38:10 +00007883 case llvm::Triple::NaCl:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007884 return new NaClTargetInfo<X86_64TargetInfo>(Triple);
Alex Rosenberg12207fa2015-01-27 14:47:44 +00007885 case llvm::Triple::PS4:
7886 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007887 default:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00007888 return new X86_64TargetInfo(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007889 }
Guy Benyeib798fc92012-12-11 21:38:14 +00007890
Douglas Katzman78d7c542015-05-12 21:18:10 +00007891 case llvm::Triple::spir: {
7892 if (Triple.getOS() != llvm::Triple::UnknownOS ||
7893 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
7894 return nullptr;
7895 return new SPIR32TargetInfo(Triple);
7896 }
7897 case llvm::Triple::spir64: {
7898 if (Triple.getOS() != llvm::Triple::UnknownOS ||
7899 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
7900 return nullptr;
7901 return new SPIR64TargetInfo(Triple);
7902 }
Dan Gohmanc2853072015-09-03 22:51:53 +00007903 case llvm::Triple::wasm32:
7904 if (!(Triple == llvm::Triple("wasm32-unknown-unknown")))
7905 return nullptr;
7906 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple);
7907 case llvm::Triple::wasm64:
7908 if (!(Triple == llvm::Triple("wasm64-unknown-unknown")))
7909 return nullptr;
7910 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple);
Daniel Dunbar52322032009-08-18 05:47:58 +00007911 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00007912}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007913
7914/// CreateTargetInfo - Return the target info object for the specified target
Eric Christophere4f73b32015-08-07 19:07:08 +00007915/// options.
Alp Toker80758082014-07-06 05:26:44 +00007916TargetInfo *
7917TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
7918 const std::shared_ptr<TargetOptions> &Opts) {
Douglas Gregorf8715de2012-11-16 04:24:59 +00007919 llvm::Triple Triple(Opts->Triple);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007920
7921 // Construct the target
Ahmed Charlesb8984322014-03-07 20:03:18 +00007922 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple));
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007923 if (!Target) {
7924 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
Craig Topperf1186c52014-05-08 06:41:40 +00007925 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007926 }
Alp Toker80758082014-07-06 05:26:44 +00007927 Target->TargetOpts = Opts;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007928
Daniel Dunbaracde99e2009-12-18 18:42:37 +00007929 // Set the target CPU if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00007930 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
7931 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Craig Topperf1186c52014-05-08 06:41:40 +00007932 return nullptr;
Daniel Dunbaracde99e2009-12-18 18:42:37 +00007933 }
7934
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007935 // Set the target ABI if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00007936 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
7937 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Craig Topperf1186c52014-05-08 06:41:40 +00007938 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007939 }
7940
Rafael Espindolaeb265472013-08-21 21:59:03 +00007941 // Set the fp math unit.
7942 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
7943 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
Craig Topperf1186c52014-05-08 06:41:40 +00007944 return nullptr;
Rafael Espindolaeb265472013-08-21 21:59:03 +00007945 }
7946
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007947 // Compute the default target features, we need the target to handle this
7948 // because features may have dependencies on one another.
7949 llvm::StringMap<bool> Features;
Eric Christopher007b0a02015-08-28 22:32:01 +00007950 if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
7951 Opts->FeaturesAsWritten))
Eric Christopher6b454372015-08-25 13:45:24 +00007952 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007953
7954 // Add the features to the compile options.
Douglas Gregorf8715de2012-11-16 04:24:59 +00007955 Opts->Features.clear();
Aaron Ballmanb226d3d2015-08-12 13:38:59 +00007956 for (const auto &F : Features)
7957 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
7958
Eric Christopher3ff21b32013-10-16 21:26:26 +00007959 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Craig Topperf1186c52014-05-08 06:41:40 +00007960 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007961
Ahmed Charles9a16beb2014-03-07 19:33:25 +00007962 return Target.release();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00007963}