blob: b35033876da1dc21fc4d32c116920304356a6354 [file] [log] [blame]
Saleem Abdulrasoolb6e946b2017-05-24 20:27:09 +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
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000015#include "clang/Basic/Builtins.h"
Justin Lebar62907612016-07-06 21:21:39 +000016#include "clang/Basic/Cuda.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000017#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"
Justin Lebar62907612016-07-06 21:21:39 +000021#include "clang/Basic/TargetInfo.h"
Daniel Dunbarb9bbd542009-11-15 06:48:46 +000022#include "clang/Basic/TargetOptions.h"
Tim Northover756447a2015-10-30 16:30:36 +000023#include "clang/Basic/Version.h"
Yaxun Liu2c17e822016-08-09 19:43:38 +000024#include "clang/Frontend/CodeGenOptions.h"
Eli Friedman7cef49e2008-05-20 14:27:34 +000025#include "llvm/ADT/APFloat.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000026#include "llvm/ADT/STLExtras.h"
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +000027#include "llvm/ADT/StringExtras.h"
Daniel Dunbar58bc48c2009-08-19 20:04:03 +000028#include "llvm/ADT/StringRef.h"
Daniel Dunbar979586e2009-11-11 09:38:56 +000029#include "llvm/ADT/StringSwitch.h"
Chris Lattner859c37a2009-08-12 06:24:27 +000030#include "llvm/ADT/Triple.h"
Chris Lattner30ba6742009-08-10 19:03:04 +000031#include "llvm/MC/MCSectionMachO.h"
David Blaikie76bd3c82011-09-23 05:35:21 +000032#include "llvm/Support/ErrorHandling.h"
Renato Golinf5c4dec2015-05-27 13:33:00 +000033#include "llvm/Support/TargetParser.h"
Benjamin Kramerdc2f0062010-01-09 18:20:57 +000034#include <algorithm>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000035#include <memory>
Hans Wennborg7eb54642015-09-10 17:07:54 +000036
Chris Lattner5ba61f02006-10-14 07:39:34 +000037using namespace clang;
38
Chris Lattner5ba61f02006-10-14 07:39:34 +000039//===----------------------------------------------------------------------===//
Chris Lattner1f5ad112006-10-14 18:32:12 +000040// Common code shared among targets.
Chris Lattner5ba61f02006-10-14 07:39:34 +000041//===----------------------------------------------------------------------===//
42
Chris Lattner1e1c0b92009-03-20 16:06:38 +000043/// DefineStd - Define a macro name and standard variants. For example if
44/// MacroName is "unix", then this will define "__unix", "__unix__", and "unix"
45/// when in GNU mode.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000046static void DefineStd(MacroBuilder &Builder, StringRef MacroName,
Chris Lattner1e1c0b92009-03-20 16:06:38 +000047 const LangOptions &Opts) {
48 assert(MacroName[0] != '_' && "Identifier should be in the user's namespace");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000049
Chris Lattner1e1c0b92009-03-20 16:06:38 +000050 // If in GNU mode (e.g. -std=gnu99 but not -std=c99) define the raw identifier
51 // in the user's namespace.
52 if (Opts.GNUMode)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000053 Builder.defineMacro(MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000054
Chris Lattner1e1c0b92009-03-20 16:06:38 +000055 // Define __unix.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000056 Builder.defineMacro("__" + MacroName);
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +000057
Chris Lattner1e1c0b92009-03-20 16:06:38 +000058 // Define __unix__.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000059 Builder.defineMacro("__" + MacroName + "__");
Chris Lattner1e1c0b92009-03-20 16:06:38 +000060}
61
Benjamin Kramere3b442d2012-01-10 11:50:09 +000062static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
63 bool Tuning = true) {
64 Builder.defineMacro("__" + CPUName);
65 Builder.defineMacro("__" + CPUName + "__");
66 if (Tuning)
67 Builder.defineMacro("__tune_" + CPUName + "__");
68}
69
Justin Lebar76945b22016-04-29 23:05:19 +000070static TargetInfo *AllocateTarget(const llvm::Triple &Triple,
71 const TargetOptions &Opts);
72
Chris Lattner09d98f52008-10-05 21:50:58 +000073//===----------------------------------------------------------------------===//
74// Defines specific to certain operating systems.
75//===----------------------------------------------------------------------===//
Chris Lattner30ba6742009-08-10 19:03:04 +000076
Torok Edwinb2b37c62009-06-30 17:10:35 +000077namespace {
Douglas Gregorc05d2a12009-07-01 15:12:53 +000078template<typename TgtInfo>
79class OSTargetInfo : public TgtInfo {
Torok Edwinb2b37c62009-06-30 17:10:35 +000080protected:
Daniel Dunbar40165182009-08-24 09:10:05 +000081 virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000082 MacroBuilder &Builder) const=0;
Torok Edwinb2b37c62009-06-30 17:10:35 +000083public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +000084 OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
85 : TgtInfo(Triple, Opts) {}
Craig Topper3164f332014-03-11 03:39:26 +000086 void getTargetDefines(const LangOptions &Opts,
87 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +000088 TgtInfo::getTargetDefines(Opts, Builder);
89 getOSDefines(Opts, TgtInfo::getTriple(), Builder);
Torok Edwin4e054162009-06-30 17:00:25 +000090 }
Torok Edwinb2b37c62009-06-30 17:10:35 +000091
92};
Chris Lattner30ba6742009-08-10 19:03:04 +000093
Eric Christopher7d0c7252015-09-24 21:17:04 +000094// CloudABI Target
95template <typename Target>
96class CloudABITargetInfo : public OSTargetInfo<Target> {
97protected:
98 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
99 MacroBuilder &Builder) const override {
100 Builder.defineMacro("__CloudABI__");
101 Builder.defineMacro("__ELF__");
102
103 // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
104 Builder.defineMacro("__STDC_ISO_10646__", "201206L");
105 Builder.defineMacro("__STDC_UTF_16__");
106 Builder.defineMacro("__STDC_UTF_32__");
107 }
108
109public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000110 CloudABITargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
111 : OSTargetInfo<Target>(Triple, Opts) {}
Eric Christopher7d0c7252015-09-24 21:17:04 +0000112};
113
Daniel Dunbard86666f2010-01-26 01:44:04 +0000114static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000115 const llvm::Triple &Triple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000116 StringRef &PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000117 VersionTuple &PlatformMinVersion) {
Bob Wilson834400b2013-08-19 20:23:37 +0000118 Builder.defineMacro("__APPLE_CC__", "6000");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000119 Builder.defineMacro("__APPLE__");
Duncan P. N. Exon Smith16b1ac92017-04-27 01:47:22 +0000120 Builder.defineMacro("__STDC_NO_THREADS__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000121 Builder.defineMacro("OBJC_NEW_PROPERTIES");
Alexander Potapenkob4f81902012-09-20 10:10:01 +0000122 // AddressSanitizer doesn't play well with source fortification, which is on
123 // by default on Darwin.
Alexey Samsonovedf99a92014-11-07 22:29:38 +0000124 if (Opts.Sanitize.has(SanitizerKind::Address))
125 Builder.defineMacro("_FORTIFY_SOURCE", "0");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +0000126
John McCall460ce582015-10-22 18:38:17 +0000127 // Darwin defines __weak, __strong, and __unsafe_unretained even in C mode.
128 if (!Opts.ObjC1) {
John McCall31168b02011-06-15 23:02:42 +0000129 // __weak is always defined, for use in blocks and with objc pointers.
130 Builder.defineMacro("__weak", "__attribute__((objc_gc(weak)))");
John McCall460ce582015-10-22 18:38:17 +0000131 Builder.defineMacro("__strong", "");
John McCall31168b02011-06-15 23:02:42 +0000132 Builder.defineMacro("__unsafe_unretained", "");
John McCall31168b02011-06-15 23:02:42 +0000133 }
Eric Christopher0c912c52011-07-07 22:55:26 +0000134
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000135 if (Opts.Static)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000136 Builder.defineMacro("__STATIC__");
Eli Friedmanfd4b1552009-06-04 23:00:29 +0000137 else
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000138 Builder.defineMacro("__DYNAMIC__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000139
140 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000141 Builder.defineMacro("_REENTRANT");
Daniel Dunbar497ff132009-04-10 19:52:24 +0000142
Daniel Dunbarecf13562011-04-19 21:40:34 +0000143 // Get the platform type and version number from the triple.
Daniel Dunbar497ff132009-04-10 19:52:24 +0000144 unsigned Maj, Min, Rev;
Bob Wilson8e5acc52012-01-31 23:52:58 +0000145 if (Triple.isMacOSX()) {
146 Triple.getMacOSXVersion(Maj, Min, Rev);
Manman Renccf25bb2016-06-28 20:55:30 +0000147 PlatformName = "macos";
Daniel Dunbarecf13562011-04-19 21:40:34 +0000148 } else {
Bob Wilson8e5acc52012-01-31 23:52:58 +0000149 Triple.getOSVersion(Maj, Min, Rev);
150 PlatformName = llvm::Triple::getOSTypeName(Triple.getOS());
Daniel Dunbarecf13562011-04-19 21:40:34 +0000151 }
Daniel Dunbard86666f2010-01-26 01:44:04 +0000152
Sebastian Pop422377c2012-01-20 22:01:23 +0000153 // If -target arch-pc-win32-macho option specified, we're
Eric Christopherb081ba62011-07-29 21:20:35 +0000154 // generating code for Win32 ABI. No need to emit
Chad Rosierb90e4022011-07-19 20:00:06 +0000155 // __ENVIRONMENT_XX_OS_VERSION_MIN_REQUIRED__.
156 if (PlatformName == "win32") {
157 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
158 return;
159 }
160
Evan Cheng31dd9a62014-01-26 23:12:43 +0000161 // Set the appropriate OS version define.
162 if (Triple.isiOS()) {
Bob Wilson4cf27c42016-07-18 20:29:14 +0000163 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
164 char Str[7];
165 if (Maj < 10) {
166 Str[0] = '0' + Maj;
167 Str[1] = '0' + (Min / 10);
168 Str[2] = '0' + (Min % 10);
169 Str[3] = '0' + (Rev / 10);
170 Str[4] = '0' + (Rev % 10);
171 Str[5] = '\0';
172 } else {
173 // Handle versions >= 10.
174 Str[0] = '0' + (Maj / 10);
175 Str[1] = '0' + (Maj % 10);
176 Str[2] = '0' + (Min / 10);
177 Str[3] = '0' + (Min % 10);
178 Str[4] = '0' + (Rev / 10);
179 Str[5] = '0' + (Rev % 10);
180 Str[6] = '\0';
181 }
Tim Northover67465f82015-10-30 16:30:30 +0000182 if (Triple.isTvOS())
183 Builder.defineMacro("__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__", Str);
184 else
185 Builder.defineMacro("__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__",
186 Str);
187
188 } else if (Triple.isWatchOS()) {
189 assert(Maj < 10 && Min < 100 && Rev < 100 && "Invalid version!");
190 char Str[6];
191 Str[0] = '0' + Maj;
192 Str[1] = '0' + (Min / 10);
193 Str[2] = '0' + (Min % 10);
194 Str[3] = '0' + (Rev / 10);
195 Str[4] = '0' + (Rev % 10);
196 Str[5] = '\0';
197 Builder.defineMacro("__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__", Str);
Evan Cheng31dd9a62014-01-26 23:12:43 +0000198 } else if (Triple.isMacOSX()) {
199 // Note that the Driver allows versions which aren't representable in the
200 // define (because we only get a single digit for the minor and micro
201 // revision numbers). So, we limit them to the maximum representable
202 // version.
203 assert(Maj < 100 && Min < 100 && Rev < 100 && "Invalid version!");
Bob Wilson2a3710e2014-08-08 21:45:53 +0000204 char Str[7];
205 if (Maj < 10 || (Maj == 10 && Min < 10)) {
206 Str[0] = '0' + (Maj / 10);
207 Str[1] = '0' + (Maj % 10);
208 Str[2] = '0' + std::min(Min, 9U);
209 Str[3] = '0' + std::min(Rev, 9U);
210 Str[4] = '\0';
211 } else {
212 // Handle versions > 10.9.
213 Str[0] = '0' + (Maj / 10);
214 Str[1] = '0' + (Maj % 10);
215 Str[2] = '0' + (Min / 10);
216 Str[3] = '0' + (Min % 10);
217 Str[4] = '0' + (Rev / 10);
218 Str[5] = '0' + (Rev % 10);
219 Str[6] = '\0';
220 }
Evan Cheng31dd9a62014-01-26 23:12:43 +0000221 Builder.defineMacro("__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__", Str);
Daniel Dunbar497ff132009-04-10 19:52:24 +0000222 }
Daniel Dunbarecf13562011-04-19 21:40:34 +0000223
Tim Northover157d9112014-01-16 08:48:16 +0000224 // Tell users about the kernel if there is one.
225 if (Triple.isOSDarwin())
226 Builder.defineMacro("__MACH__");
227
Chris Bieneman46977b62016-04-29 17:53:00 +0000228 // The Watch ABI uses Dwarf EH.
229 if(Triple.isWatchABI())
230 Builder.defineMacro("__ARM_DWARF_EH__");
231
Daniel Dunbarecf13562011-04-19 21:40:34 +0000232 PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Eli Friedman3fd920a2008-08-20 02:34:37 +0000233}
Chris Lattner5ba61f02006-10-14 07:39:34 +0000234
Torok Edwinb2b37c62009-06-30 17:10:35 +0000235template<typename Target>
236class DarwinTargetInfo : public OSTargetInfo<Target> {
237protected:
Craig Topper3164f332014-03-11 03:39:26 +0000238 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
239 MacroBuilder &Builder) const override {
Eric Christopher0c912c52011-07-07 22:55:26 +0000240 getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000241 this->PlatformMinVersion);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000242 }
Mike Stump11289f42009-09-09 15:08:12 +0000243
Torok Edwinb2b37c62009-06-30 17:10:35 +0000244public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000245 DarwinTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
246 : OSTargetInfo<Target>(Triple, Opts) {
Tim Northovera12d0a92016-01-07 09:04:46 +0000247 // By default, no TLS, and we whitelist permitted architecture/OS
248 // combinations.
249 this->TLSSupported = false;
250
251 if (Triple.isMacOSX())
252 this->TLSSupported = !Triple.isMacOSXVersionLT(10, 7);
253 else if (Triple.isiOS()) {
254 // 64-bit iOS supported it from 8 onwards, 32-bit from 9 onwards.
255 if (Triple.getArch() == llvm::Triple::x86_64 ||
256 Triple.getArch() == llvm::Triple::aarch64)
257 this->TLSSupported = !Triple.isOSVersionLT(8);
258 else if (Triple.getArch() == llvm::Triple::x86 ||
259 Triple.getArch() == llvm::Triple::arm ||
260 Triple.getArch() == llvm::Triple::thumb)
261 this->TLSSupported = !Triple.isOSVersionLT(9);
262 } else if (Triple.isWatchOS())
263 this->TLSSupported = !Triple.isOSVersionLT(2);
264
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000265 this->MCountName = "\01mcount";
266 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000267
Craig Topper3164f332014-03-11 03:39:26 +0000268 std::string isValidSectionSpecifier(StringRef SR) const override {
Chris Lattner30ba6742009-08-10 19:03:04 +0000269 // Let MCSectionMachO validate this.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000270 StringRef Segment, Section;
Chris Lattner30ba6742009-08-10 19:03:04 +0000271 unsigned TAA, StubSize;
Daniel Dunbar75942372011-03-19 02:06:21 +0000272 bool HasTAA;
Chris Lattner30ba6742009-08-10 19:03:04 +0000273 return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
Daniel Dunbar75942372011-03-19 02:06:21 +0000274 TAA, HasTAA, StubSize);
Chris Lattner30ba6742009-08-10 19:03:04 +0000275 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000276
Craig Topper3164f332014-03-11 03:39:26 +0000277 const char *getStaticInitSectionSpecifier() const override {
Anders Carlsson851318a2010-06-08 22:47:50 +0000278 // FIXME: We should return 0 when building kexts.
279 return "__TEXT,__StaticInit,regular,pure_instructions";
280 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +0000281
John McCalleed64c72012-01-29 01:20:30 +0000282 /// Darwin does not support protected visibility. Darwin's "default"
283 /// is very similar to ELF's "protected"; Darwin requires a "weak"
284 /// attribute on declarations that can be dynamically replaced.
Craig Topper3164f332014-03-11 03:39:26 +0000285 bool hasProtectedVisibility() const override {
John McCalleed64c72012-01-29 01:20:30 +0000286 return false;
287 }
Akira Hatanaka68ab7fe2016-03-31 06:36:07 +0000288
289 unsigned getExnObjectAlignment() const override {
290 // The alignment of an exception object is 8-bytes for darwin since
291 // libc++abi doesn't declare _Unwind_Exception with __attribute__((aligned))
292 // and therefore doesn't guarantee 16-byte alignment.
293 return 64;
294 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000295};
296
Chris Lattner30ba6742009-08-10 19:03:04 +0000297
Torok Edwinb2b37c62009-06-30 17:10:35 +0000298// DragonFlyBSD Target
299template<typename Target>
300class DragonFlyBSDTargetInfo : public OSTargetInfo<Target> {
301protected:
Craig Topper3164f332014-03-11 03:39:26 +0000302 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
303 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000304 // DragonFly defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000305 Builder.defineMacro("__DragonFly__");
306 Builder.defineMacro("__DragonFly_cc_version", "100001");
307 Builder.defineMacro("__ELF__");
308 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
309 Builder.defineMacro("__tune_i386__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000310 DefineStd(Builder, "unix", Opts);
Torok Edwinb2b37c62009-06-30 17:10:35 +0000311 }
312public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000313 DragonFlyBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
314 : OSTargetInfo<Target>(Triple, Opts) {
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 }
Eli Friedman4286fba2012-02-10 23:02:29 +0000322 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000323};
324
Dimitry Andricc6d924c2016-05-20 17:27:22 +0000325#ifndef FREEBSD_CC_VERSION
326#define FREEBSD_CC_VERSION 0U
327#endif
328
Torok Edwinb2b37c62009-06-30 17:10:35 +0000329// FreeBSD Target
330template<typename Target>
331class FreeBSDTargetInfo : public OSTargetInfo<Target> {
332protected:
Craig Topper3164f332014-03-11 03:39:26 +0000333 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
334 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000335 // FreeBSD defines; list based off of gcc output
336
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000337 unsigned Release = Triple.getOSMajorVersion();
338 if (Release == 0U)
Dimitry Andricc6d924c2016-05-20 17:27:22 +0000339 Release = 8U;
340 unsigned CCVersion = FREEBSD_CC_VERSION;
341 if (CCVersion == 0U)
342 CCVersion = Release * 100000U + 1U;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000343
Benjamin Kramer80ca4072011-10-18 10:10:08 +0000344 Builder.defineMacro("__FreeBSD__", Twine(Release));
Dimitry Andricc6d924c2016-05-20 17:27:22 +0000345 Builder.defineMacro("__FreeBSD_cc_version", Twine(CCVersion));
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000346 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000347 DefineStd(Builder, "unix", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000348 Builder.defineMacro("__ELF__");
Ed Schoutend0621462013-09-29 07:54:52 +0000349
350 // On FreeBSD, wchar_t contains the number of the code point as
351 // used by the character set of the locale. These character sets are
352 // not necessarily a superset of ASCII.
Richard Smith00a4a852015-01-13 01:47:45 +0000353 //
354 // FIXME: This is wrong; the macro refers to the numerical values
355 // of wchar_t *literals*, which are not locale-dependent. However,
356 // FreeBSD systems apparently depend on us getting this wrong, and
357 // setting this to 1 is conforming even if all the basic source
358 // character literals have the same encoding as char and wchar_t.
Ed Schoutend0621462013-09-29 07:54:52 +0000359 Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000360 }
361public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000362 FreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
363 : OSTargetInfo<Target>(Triple, Opts) {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000364 switch (Triple.getArch()) {
365 default:
366 case llvm::Triple::x86:
367 case llvm::Triple::x86_64:
368 this->MCountName = ".mcount";
369 break;
370 case llvm::Triple::mips:
371 case llvm::Triple::mipsel:
372 case llvm::Triple::ppc:
373 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +0000374 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000375 this->MCountName = "_mcount";
376 break;
377 case llvm::Triple::arm:
378 this->MCountName = "__mcount";
379 break;
Duncan Sands9cb27e92009-07-08 13:55:08 +0000380 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000381 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000382};
383
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000384// GNU/kFreeBSD Target
385template<typename Target>
386class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
387protected:
Craig Topper3164f332014-03-11 03:39:26 +0000388 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
389 MacroBuilder &Builder) const override {
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000390 // GNU/kFreeBSD defines; list based off of gcc output
391
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000392 DefineStd(Builder, "unix", Opts);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000393 Builder.defineMacro("__FreeBSD_kernel__");
394 Builder.defineMacro("__GLIBC__");
395 Builder.defineMacro("__ELF__");
396 if (Opts.POSIXThreads)
397 Builder.defineMacro("_REENTRANT");
398 if (Opts.CPlusPlus)
399 Builder.defineMacro("_GNU_SOURCE");
400 }
401public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000402 KFreeBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
403 : OSTargetInfo<Target>(Triple, Opts) {}
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +0000404};
405
Reid Kleckner330fb172016-05-11 16:19:05 +0000406// Haiku Target
407template<typename Target>
408class HaikuTargetInfo : public OSTargetInfo<Target> {
409protected:
410 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
411 MacroBuilder &Builder) const override {
412 // Haiku defines; list based off of gcc output
413 Builder.defineMacro("__HAIKU__");
414 Builder.defineMacro("__ELF__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000415 DefineStd(Builder, "unix", Opts);
Reid Kleckner330fb172016-05-11 16:19:05 +0000416 }
417public:
418 HaikuTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
419 : OSTargetInfo<Target>(Triple, Opts) {
420 this->SizeType = TargetInfo::UnsignedLong;
421 this->IntPtrType = TargetInfo::SignedLong;
422 this->PtrDiffType = TargetInfo::SignedLong;
423 this->ProcessIDType = TargetInfo::SignedLong;
424 this->TLSSupported = false;
425
426 }
427};
428
Chris Lattner3e2ee142010-07-07 16:01:42 +0000429// Minix Target
430template<typename Target>
431class MinixTargetInfo : public OSTargetInfo<Target> {
432protected:
Craig Topper3164f332014-03-11 03:39:26 +0000433 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
434 MacroBuilder &Builder) const override {
Chris Lattner3e2ee142010-07-07 16:01:42 +0000435 // Minix defines
436
437 Builder.defineMacro("__minix", "3");
438 Builder.defineMacro("_EM_WSIZE", "4");
439 Builder.defineMacro("_EM_PSIZE", "4");
440 Builder.defineMacro("_EM_SSIZE", "2");
441 Builder.defineMacro("_EM_LSIZE", "4");
442 Builder.defineMacro("_EM_FSIZE", "4");
443 Builder.defineMacro("_EM_DSIZE", "8");
Eli Friedman83de5132011-12-08 23:54:21 +0000444 Builder.defineMacro("__ELF__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000445 DefineStd(Builder, "unix", Opts);
Chris Lattner3e2ee142010-07-07 16:01:42 +0000446 }
447public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000448 MinixTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
449 : OSTargetInfo<Target>(Triple, Opts) {}
Chris Lattner3e2ee142010-07-07 16:01:42 +0000450};
451
Torok Edwinb2b37c62009-06-30 17:10:35 +0000452// Linux target
453template<typename Target>
454class LinuxTargetInfo : public OSTargetInfo<Target> {
455protected:
Craig Topper3164f332014-03-11 03:39:26 +0000456 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
457 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000458 // Linux defines; list based off of gcc output
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000459 DefineStd(Builder, "unix", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000460 DefineStd(Builder, "linux", Opts);
461 Builder.defineMacro("__gnu_linux__");
462 Builder.defineMacro("__ELF__");
Evgeniy Stepanov14deb7b2015-10-08 21:21:44 +0000463 if (Triple.isAndroid()) {
Evgeniy Stepanov94dc4c92012-04-26 12:08:09 +0000464 Builder.defineMacro("__ANDROID__", "1");
Dan Albert84aee012015-03-03 18:28:38 +0000465 unsigned Maj, Min, Rev;
David Majnemer5c2589a2015-06-01 23:38:25 +0000466 Triple.getEnvironmentVersion(Maj, Min, Rev);
Dan Albert84aee012015-03-03 18:28:38 +0000467 this->PlatformName = "android";
468 this->PlatformMinVersion = VersionTuple(Maj, Min, Rev);
Stephen Hinesa89d8ff2016-11-11 01:29:39 +0000469 if (Maj)
470 Builder.defineMacro("__ANDROID_API__", Twine(Maj));
Dan Albert84aee012015-03-03 18:28:38 +0000471 }
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000472 if (Opts.POSIXThreads)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000473 Builder.defineMacro("_REENTRANT");
Douglas Gregor3ecc6652010-04-21 05:52:38 +0000474 if (Opts.CPlusPlus)
475 Builder.defineMacro("_GNU_SOURCE");
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000476 if (this->HasFloat128)
477 Builder.defineMacro("__FLOAT128__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000478 }
479public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000480 LinuxTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
481 : OSTargetInfo<Target>(Triple, Opts) {
Douglas Gregore6d6e512011-01-12 21:19:25 +0000482 this->WIntType = TargetInfo::UnsignedInt;
Hal Finkelecdb4542014-03-30 13:00:06 +0000483
484 switch (Triple.getArch()) {
485 default:
486 break;
487 case llvm::Triple::ppc:
488 case llvm::Triple::ppc64:
489 case llvm::Triple::ppc64le:
490 this->MCountName = "_mcount";
491 break;
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +0000492 case llvm::Triple::x86:
493 case llvm::Triple::x86_64:
494 case llvm::Triple::systemz:
495 this->HasFloat128 = true;
496 break;
Hal Finkelecdb4542014-03-30 13:00:06 +0000497 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000498 }
Benjamin Kramera518b222011-10-15 17:53:33 +0000499
Craig Topper3164f332014-03-11 03:39:26 +0000500 const char *getStaticInitSectionSpecifier() const override {
Benjamin Kramera518b222011-10-15 17:53:33 +0000501 return ".text.startup";
502 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000503};
504
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000505// NetBSD Target
506template<typename Target>
507class NetBSDTargetInfo : public OSTargetInfo<Target> {
508protected:
Craig Topper3164f332014-03-11 03:39:26 +0000509 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
510 MacroBuilder &Builder) const override {
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000511 // NetBSD defines; list based off of gcc output
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000512 Builder.defineMacro("__NetBSD__");
513 Builder.defineMacro("__unix__");
514 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000515 if (Opts.POSIXThreads)
Joerg Sonnenberger84502662017-01-16 14:07:24 +0000516 Builder.defineMacro("_REENTRANT");
Joerg Sonnenbergercc1edb52014-05-13 18:58:36 +0000517
518 switch (Triple.getArch()) {
519 default:
520 break;
521 case llvm::Triple::arm:
522 case llvm::Triple::armeb:
523 case llvm::Triple::thumb:
524 case llvm::Triple::thumbeb:
525 Builder.defineMacro("__ARM_DWARF_EH__");
526 break;
527 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000528 }
529public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000530 NetBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
531 : OSTargetInfo<Target>(Triple, Opts) {
Joerg Sonnenberger740f3f42015-04-10 21:02:53 +0000532 this->MCountName = "_mcount";
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000533 }
Chris Lattnerd1d820ed2009-07-13 20:29:08 +0000534};
535
Torok Edwinb2b37c62009-06-30 17:10:35 +0000536// OpenBSD Target
537template<typename Target>
538class OpenBSDTargetInfo : public OSTargetInfo<Target> {
539protected:
Craig Topper3164f332014-03-11 03:39:26 +0000540 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
541 MacroBuilder &Builder) const override {
Torok Edwinb2b37c62009-06-30 17:10:35 +0000542 // OpenBSD defines; list based off of gcc output
543
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000544 Builder.defineMacro("__OpenBSD__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000545 DefineStd(Builder, "unix", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000546 Builder.defineMacro("__ELF__");
Daniel Dunbara77eaeb2009-09-03 04:54:28 +0000547 if (Opts.POSIXThreads)
Chris Lattner024e12d2012-04-25 06:12:24 +0000548 Builder.defineMacro("_REENTRANT");
Brad Smith0561a5a2017-02-20 03:18:15 +0000549 if (this->HasFloat128)
550 Builder.defineMacro("__FLOAT128__");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000551 }
552public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000553 OpenBSDTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
554 : OSTargetInfo<Target>(Triple, Opts) {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000555 this->TLSSupported = false;
Eli Friedman3715d1f2011-12-15 02:15:56 +0000556
Eli Friedman3715d1f2011-12-15 02:15:56 +0000557 switch (Triple.getArch()) {
Eli Friedman3715d1f2011-12-15 02:15:56 +0000558 case llvm::Triple::x86:
559 case llvm::Triple::x86_64:
Brad Smith0561a5a2017-02-20 03:18:15 +0000560 this->HasFloat128 = true;
561 // FALLTHROUGH
562 default:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000563 this->MCountName = "__mcount";
564 break;
565 case llvm::Triple::mips64:
566 case llvm::Triple::mips64el:
567 case llvm::Triple::ppc:
Eric Christopherfd081ca2012-11-14 22:08:59 +0000568 case llvm::Triple::sparcv9:
Eli Friedman3715d1f2011-12-15 02:15:56 +0000569 this->MCountName = "_mcount";
570 break;
571 }
572 }
Torok Edwinb2b37c62009-06-30 17:10:35 +0000573};
574
Eli Friedman9fa28852012-08-08 23:57:20 +0000575// Bitrig Target
576template<typename Target>
577class BitrigTargetInfo : public OSTargetInfo<Target> {
578protected:
Craig Topper3164f332014-03-11 03:39:26 +0000579 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
580 MacroBuilder &Builder) const override {
Eli Friedman9fa28852012-08-08 23:57:20 +0000581 // Bitrig defines; list based off of gcc output
582
583 Builder.defineMacro("__Bitrig__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000584 DefineStd(Builder, "unix", Opts);
Eli Friedman9fa28852012-08-08 23:57:20 +0000585 Builder.defineMacro("__ELF__");
586 if (Opts.POSIXThreads)
587 Builder.defineMacro("_REENTRANT");
Renato Golin9ba39232015-02-27 16:35:48 +0000588
589 switch (Triple.getArch()) {
590 default:
591 break;
592 case llvm::Triple::arm:
593 case llvm::Triple::armeb:
594 case llvm::Triple::thumb:
595 case llvm::Triple::thumbeb:
596 Builder.defineMacro("__ARM_DWARF_EH__");
597 break;
598 }
Eli Friedman9fa28852012-08-08 23:57:20 +0000599 }
600public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000601 BitrigTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
602 : OSTargetInfo<Target>(Triple, Opts) {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000603 this->MCountName = "__mcount";
Eli Friedman9fa28852012-08-08 23:57:20 +0000604 }
605};
606
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000607// PSP Target
608template<typename Target>
609class PSPTargetInfo : public OSTargetInfo<Target> {
610protected:
Craig Topper3164f332014-03-11 03:39:26 +0000611 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
612 MacroBuilder &Builder) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000613 // PSP defines; list based on the output of the pspdev gcc toolchain.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000614 Builder.defineMacro("PSP");
615 Builder.defineMacro("_PSP");
616 Builder.defineMacro("__psp__");
617 Builder.defineMacro("__ELF__");
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000618 }
619public:
James Y Knightb214cbc2016-03-04 19:00:41 +0000620 PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
Edward O'Callaghane9a58b12009-11-15 10:22:07 +0000621};
622
John Thompsone467e192009-11-19 17:18:50 +0000623// PS3 PPU Target
624template<typename Target>
625class PS3PPUTargetInfo : public OSTargetInfo<Target> {
626protected:
Craig Topper3164f332014-03-11 03:39:26 +0000627 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
628 MacroBuilder &Builder) const override {
John Thompsone467e192009-11-19 17:18:50 +0000629 // PS3 PPU defines.
John Thompson957816f2010-03-25 16:18:32 +0000630 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000631 Builder.defineMacro("__PPU__");
632 Builder.defineMacro("__CELLOS_LV2__");
633 Builder.defineMacro("__ELF__");
634 Builder.defineMacro("__LP32__");
John Thompson07a61a42010-06-24 22:44:13 +0000635 Builder.defineMacro("_ARCH_PPC64");
636 Builder.defineMacro("__powerpc64__");
John Thompsone467e192009-11-19 17:18:50 +0000637 }
638public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000639 PS3PPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
640 : OSTargetInfo<Target>(Triple, Opts) {
Nick Lewyckyc0a61732011-12-16 22:32:39 +0000641 this->LongWidth = this->LongAlign = 32;
642 this->PointerWidth = this->PointerAlign = 32;
John Thompson07a61a42010-06-24 22:44:13 +0000643 this->IntMaxType = TargetInfo::SignedLongLong;
John Thompson07a61a42010-06-24 22:44:13 +0000644 this->Int64Type = TargetInfo::SignedLongLong;
John Thompson6f8dba72009-12-18 14:21:08 +0000645 this->SizeType = TargetInfo::UnsignedInt;
James Y Knightb214cbc2016-03-04 19:00:41 +0000646 this->resetDataLayout("E-m:e-p:32:32-i64:64-n32:64");
John Thompsone467e192009-11-19 17:18:50 +0000647 }
648};
649
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000650template <typename Target>
651class PS4OSTargetInfo : public OSTargetInfo<Target> {
652protected:
653 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
654 MacroBuilder &Builder) const override {
655 Builder.defineMacro("__FreeBSD__", "9");
656 Builder.defineMacro("__FreeBSD_cc_version", "900001");
657 Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000658 DefineStd(Builder, "unix", Opts);
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000659 Builder.defineMacro("__ELF__");
Paul Robinson9d613612016-05-16 17:22:25 +0000660 Builder.defineMacro("__ORBIS__");
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000661 }
662public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000663 PS4OSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
664 : OSTargetInfo<Target>(Triple, Opts) {
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000665 this->WCharType = this->UnsignedShort;
666
Paul Robinsond30e2ee2015-07-14 20:52:32 +0000667 // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
668 this->MaxTLSAlign = 256;
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000669
Sunil Srivastava0ce2f222016-02-05 20:50:02 +0000670 // On PS4, do not honor explicit bit field alignment,
671 // as in "__attribute__((aligned(2))) int b : 1;".
672 this->UseExplicitBitFieldAlignment = false;
673
Alex Rosenberg12207fa2015-01-27 14:47:44 +0000674 switch (Triple.getArch()) {
675 default:
676 case llvm::Triple::x86_64:
677 this->MCountName = ".mcount";
678 break;
679 }
680 }
681};
682
Torok Edwinb2b37c62009-06-30 17:10:35 +0000683// Solaris target
684template<typename Target>
685class SolarisTargetInfo : public OSTargetInfo<Target> {
686protected:
Craig Topper3164f332014-03-11 03:39:26 +0000687 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
688 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000689 DefineStd(Builder, "sun", Opts);
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000690 DefineStd(Builder, "unix", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +0000691 Builder.defineMacro("__ELF__");
692 Builder.defineMacro("__svr4__");
693 Builder.defineMacro("__SVR4");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000694 // Solaris headers require _XOPEN_SOURCE to be set to 600 for C99 and
695 // newer, but to 500 for everything else. feature_test.h has a check to
696 // ensure that you are not using C99 with an old version of X/Open or C89
Richard Smithab506ad2014-10-20 23:26:58 +0000697 // with a new version.
698 if (Opts.C99)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000699 Builder.defineMacro("_XOPEN_SOURCE", "600");
700 else
701 Builder.defineMacro("_XOPEN_SOURCE", "500");
David Chisnalle04307e2012-03-02 10:49:52 +0000702 if (Opts.CPlusPlus)
David Chisnall0c52c0f2012-02-28 17:10:04 +0000703 Builder.defineMacro("__C99FEATURES__");
David Chisnall0c1941cb2012-02-17 18:35:11 +0000704 Builder.defineMacro("_LARGEFILE_SOURCE");
705 Builder.defineMacro("_LARGEFILE64_SOURCE");
706 Builder.defineMacro("__EXTENSIONS__");
David Chisnall0c52c0f2012-02-28 17:10:04 +0000707 Builder.defineMacro("_REENTRANT");
Torok Edwinb2b37c62009-06-30 17:10:35 +0000708 }
709public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000710 SolarisTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
711 : OSTargetInfo<Target>(Triple, Opts) {
David Chisnallb526e932012-03-28 18:04:14 +0000712 this->WCharType = this->SignedInt;
Torok Edwinb2b37c62009-06-30 17:10:35 +0000713 // FIXME: WIntType should be SignedLong
714 }
715};
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000716
717// Windows target
718template<typename Target>
719class WindowsTargetInfo : public OSTargetInfo<Target> {
720protected:
Craig Topper3164f332014-03-11 03:39:26 +0000721 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
722 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000723 Builder.defineMacro("_WIN32");
724 }
725 void getVisualStudioDefines(const LangOptions &Opts,
726 MacroBuilder &Builder) const {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000727 if (Opts.CPlusPlus) {
David Majnemerf6072342014-07-01 22:24:56 +0000728 if (Opts.RTTIData)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000729 Builder.defineMacro("_CPPRTTI");
730
Reid Kleckner16514352015-01-30 21:42:55 +0000731 if (Opts.CXXExceptions)
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000732 Builder.defineMacro("_CPPUNWIND");
733 }
734
David Majnemer6a658902015-07-22 22:36:26 +0000735 if (Opts.Bool)
736 Builder.defineMacro("__BOOL_DEFINED");
737
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000738 if (!Opts.CharIsSigned)
739 Builder.defineMacro("_CHAR_UNSIGNED");
740
741 // FIXME: POSIXThreads isn't exactly the option this should be defined for,
742 // but it works for now.
743 if (Opts.POSIXThreads)
744 Builder.defineMacro("_MT");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +0000745
Saleem Abdulrasoolc68237b2014-07-16 03:13:50 +0000746 if (Opts.MSCompatibilityVersion) {
747 Builder.defineMacro("_MSC_VER",
748 Twine(Opts.MSCompatibilityVersion / 100000));
749 Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000750 // FIXME We cannot encode the revision information into 32-bits
751 Builder.defineMacro("_MSC_BUILD", Twine(1));
David Majnemeraaf2b842015-03-18 07:53:18 +0000752
David Majnemerb710a932015-05-11 03:57:49 +0000753 if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
David Majnemeraaf2b842015-03-18 07:53:18 +0000754 Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
David Majnemer017cf352016-06-28 03:13:16 +0000755
756 if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
757 if (Opts.CPlusPlus1z)
758 Builder.defineMacro("_MSVC_LANG", "201403L");
759 else if (Opts.CPlusPlus14)
760 Builder.defineMacro("_MSVC_LANG", "201402L");
761 }
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +0000762 }
Reid Kleckner6f6e76d2014-04-16 20:10:16 +0000763
764 if (Opts.MicrosoftExt) {
765 Builder.defineMacro("_MSC_EXTENSIONS");
766
767 if (Opts.CPlusPlus11) {
768 Builder.defineMacro("_RVALUE_REFERENCES_V2_SUPPORTED");
769 Builder.defineMacro("_RVALUE_REFERENCES_SUPPORTED");
770 Builder.defineMacro("_NATIVE_NULLPTR_SUPPORTED");
771 }
772 }
773
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000774 Builder.defineMacro("_INTEGRAL_MAX_BITS", "64");
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000775 }
776
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000777public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000778 WindowsTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
779 : OSTargetInfo<Target>(Triple, Opts) {}
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +0000780};
781
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000782template <typename Target>
783class NaClTargetInfo : public OSTargetInfo<Target> {
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000784protected:
Craig Topper3164f332014-03-11 03:39:26 +0000785 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
786 MacroBuilder &Builder) const override {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000787 if (Opts.POSIXThreads)
788 Builder.defineMacro("_REENTRANT");
789 if (Opts.CPlusPlus)
790 Builder.defineMacro("_GNU_SOURCE");
791
Saleem Abdulrasool56027092017-02-07 19:00:06 +0000792 DefineStd(Builder, "unix", Opts);
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000793 Builder.defineMacro("__ELF__");
794 Builder.defineMacro("__native_client__");
795 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +0000796
797public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000798 NaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
799 : OSTargetInfo<Target>(Triple, Opts) {
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000800 this->LongAlign = 32;
801 this->LongWidth = 32;
802 this->PointerAlign = 32;
803 this->PointerWidth = 32;
804 this->IntMaxType = TargetInfo::SignedLongLong;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000805 this->Int64Type = TargetInfo::SignedLongLong;
806 this->DoubleAlign = 64;
807 this->LongDoubleWidth = 64;
808 this->LongDoubleAlign = 64;
Jan Wen Voung1f9c4ee2014-01-15 21:42:41 +0000809 this->LongLongWidth = 64;
810 this->LongLongAlign = 64;
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000811 this->SizeType = TargetInfo::UnsignedInt;
812 this->PtrDiffType = TargetInfo::SignedInt;
813 this->IntPtrType = TargetInfo::SignedInt;
Guy Blank294cbbd2016-08-18 08:44:33 +0000814 // RegParmMax is inherited from the underlying architecture.
Stephan Bergmann17c7f702016-12-14 11:57:17 +0000815 this->LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Rafael Espindola1c09b262013-12-18 23:41:04 +0000816 if (Triple.getArch() == llvm::Triple::arm) {
Derek Schuff6ab52fa2015-03-30 20:31:33 +0000817 // Handled in ARM's setABI().
Rafael Espindola1c09b262013-12-18 23:41:04 +0000818 } else if (Triple.getArch() == llvm::Triple::x86) {
James Y Knightb214cbc2016-03-04 19:00:41 +0000819 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32-S128");
Rafael Espindola1c09b262013-12-18 23:41:04 +0000820 } else if (Triple.getArch() == llvm::Triple::x86_64) {
James Y Knightb214cbc2016-03-04 19:00:41 +0000821 this->resetDataLayout("e-m:e-p:32:32-i64:64-n8:16:32:64-S128");
Rafael Espindola1c09b262013-12-18 23:41:04 +0000822 } else if (Triple.getArch() == llvm::Triple::mipsel) {
James Y Knightb214cbc2016-03-04 19:00:41 +0000823 // Handled on mips' setDataLayout.
Rafael Espindola1c09b262013-12-18 23:41:04 +0000824 } else {
825 assert(Triple.getArch() == llvm::Triple::le32);
James Y Knightb214cbc2016-03-04 19:00:41 +0000826 this->resetDataLayout("e-p:32:32-i64:64");
Rafael Espindola1c09b262013-12-18 23:41:04 +0000827 }
Derek Schuff57b7e8f2012-10-11 16:55:58 +0000828 }
829};
Torok Edwinb2b37c62009-06-30 17:10:35 +0000830
Petr Hosek62e1d232016-10-06 06:08:09 +0000831// Fuchsia Target
832template<typename Target>
833class FuchsiaTargetInfo : public OSTargetInfo<Target> {
834protected:
835 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
836 MacroBuilder &Builder) const override {
837 Builder.defineMacro("__Fuchsia__");
838 Builder.defineMacro("__ELF__");
839 if (Opts.POSIXThreads)
840 Builder.defineMacro("_REENTRANT");
841 // Required by the libc++ locale support.
842 if (Opts.CPlusPlus)
843 Builder.defineMacro("_GNU_SOURCE");
844 }
845public:
846 FuchsiaTargetInfo(const llvm::Triple &Triple,
847 const TargetOptions &Opts)
848 : OSTargetInfo<Target>(Triple, Opts) {
849 this->MCountName = "__mcount";
850 }
851};
852
Dan Gohmanc2853072015-09-03 22:51:53 +0000853// WebAssembly target
854template <typename Target>
855class WebAssemblyOSTargetInfo : public OSTargetInfo<Target> {
856 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
Hans Wennborg7eb54642015-09-10 17:07:54 +0000857 MacroBuilder &Builder) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +0000858 // A common platform macro.
859 if (Opts.POSIXThreads)
860 Builder.defineMacro("_REENTRANT");
861 // Follow g++ convention and predefine _GNU_SOURCE for C++.
862 if (Opts.CPlusPlus)
863 Builder.defineMacro("_GNU_SOURCE");
864 }
865
866 // As an optimization, group static init code together in a section.
Hans Wennborg7eb54642015-09-10 17:07:54 +0000867 const char *getStaticInitSectionSpecifier() const final {
Dan Gohmanc2853072015-09-03 22:51:53 +0000868 return ".text.__startup";
869 }
870
871public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000872 explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple,
873 const TargetOptions &Opts)
874 : OSTargetInfo<Target>(Triple, Opts) {
Dan Gohmanc2853072015-09-03 22:51:53 +0000875 this->MCountName = "__mcount";
Dan Gohmanc2853072015-09-03 22:51:53 +0000876 this->TheCXXABI.set(TargetCXXABI::WebAssembly);
877 }
878};
Dan Gohmanc2853072015-09-03 22:51:53 +0000879
Chris Lattner09d98f52008-10-05 21:50:58 +0000880//===----------------------------------------------------------------------===//
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000881// Specific target implementations.
882//===----------------------------------------------------------------------===//
Anders Carlssona7408e72007-10-13 00:45:48 +0000883
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000884// PPC abstract base class
885class PPCTargetInfo : public TargetInfo {
886 static const Builtin::Info BuiltinInfo[];
887 static const char * const GCCRegNames[];
888 static const TargetInfo::GCCRegAlias GCCRegAliases[];
Hal Finkel8eb59282012-06-11 22:35:19 +0000889 std::string CPU;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000890
891 // Target cpu features.
Eric Christopher758aad72017-03-21 22:06:18 +0000892 bool HasAltivec;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000893 bool HasVSX;
Bill Schmidt8c184e32014-10-10 17:21:23 +0000894 bool HasP8Vector;
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +0000895 bool HasP8Crypto;
Nemanja Ivanovic35458c22015-04-11 10:43:36 +0000896 bool HasDirectMove;
Hal Finkel0d0a1a52015-03-11 19:14:15 +0000897 bool HasQPX;
Kit Barton8246f282015-03-25 19:41:41 +0000898 bool HasHTM;
Nemanja Ivanovic239eec72015-04-09 23:58:16 +0000899 bool HasBPERMD;
900 bool HasExtDiv;
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +0000901 bool HasP9Vector;
Eric Christopher2fe3b4a2013-10-16 21:19:26 +0000902
Ulrich Weigand8afad612014-07-28 13:17:52 +0000903protected:
904 std::string ABI;
905
Eli Friedmanb9e5bed2008-08-20 23:11:40 +0000906public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +0000907 PPCTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
Eric Christopher758aad72017-03-21 22:06:18 +0000908 : TargetInfo(Triple), HasAltivec(false), HasVSX(false), HasP8Vector(false),
Saleem Abdulrasool10a49722016-04-08 16:52:00 +0000909 HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false),
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +0000910 HasBPERMD(false), HasExtDiv(false), HasP9Vector(false) {
Eric Christopher153dad42017-03-25 02:55:21 +0000911 SuitableAlign = 128;
Alexey Bataev00396512015-07-02 03:40:19 +0000912 SimdDefaultAlign = 128;
Nico Weber3435ede2012-01-31 02:07:33 +0000913 LongDoubleWidth = LongDoubleAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +0000914 LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
Nico Weber3435ede2012-01-31 02:07:33 +0000915 }
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000916
Hal Finkel6b984f02012-07-03 16:51:04 +0000917 /// \brief Flags for architecture specific defines.
918 typedef enum {
919 ArchDefineNone = 0,
920 ArchDefineName = 1 << 0, // <name> is substituted for arch name.
921 ArchDefinePpcgr = 1 << 1,
922 ArchDefinePpcsq = 1 << 2,
923 ArchDefine440 = 1 << 3,
924 ArchDefine603 = 1 << 4,
925 ArchDefine604 = 1 << 5,
926 ArchDefinePwr4 = 1 << 6,
Bill Schmidt38378a02013-02-01 20:23:10 +0000927 ArchDefinePwr5 = 1 << 7,
928 ArchDefinePwr5x = 1 << 8,
929 ArchDefinePwr6 = 1 << 9,
930 ArchDefinePwr6x = 1 << 10,
931 ArchDefinePwr7 = 1 << 11,
Will Schmidtf0487512014-06-26 13:34:10 +0000932 ArchDefinePwr8 = 1 << 12,
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +0000933 ArchDefinePwr9 = 1 << 13,
934 ArchDefineA2 = 1 << 14,
935 ArchDefineA2q = 1 << 15
Hal Finkel6b984f02012-07-03 16:51:04 +0000936 } ArchDefineTypes;
937
Eric Christopher3646e622017-03-22 06:36:09 +0000938 // Set the language option for altivec based on our value.
939 void adjust(LangOptions &Opts) override {
940 if (HasAltivec)
941 Opts.AltiVec = 1;
942 TargetInfo::adjust(Opts);
943 }
944
Bill Schmidt38378a02013-02-01 20:23:10 +0000945 // Note: GCC recognizes the following additional cpus:
946 // 401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
947 // 821, 823, 8540, 8548, e300c2, e300c3, e500mc64, e6500, 860, cell,
948 // titan, rs64.
Craig Topper3164f332014-03-11 03:39:26 +0000949 bool setCPU(const std::string &Name) override {
Hal Finkel8eb59282012-06-11 22:35:19 +0000950 bool CPUKnown = llvm::StringSwitch<bool>(Name)
951 .Case("generic", true)
952 .Case("440", true)
953 .Case("450", true)
954 .Case("601", true)
955 .Case("602", true)
956 .Case("603", true)
957 .Case("603e", true)
958 .Case("603ev", true)
959 .Case("604", true)
960 .Case("604e", true)
961 .Case("620", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000962 .Case("630", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000963 .Case("g3", true)
964 .Case("7400", true)
965 .Case("g4", true)
966 .Case("7450", true)
967 .Case("g4+", true)
968 .Case("750", true)
969 .Case("970", true)
970 .Case("g5", true)
971 .Case("a2", true)
Hal Finkeldf1e4bf2013-02-01 05:53:33 +0000972 .Case("a2q", true)
Hal Finkelf6d6cb02012-09-18 22:25:03 +0000973 .Case("e500mc", true)
974 .Case("e5500", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000975 .Case("power3", true)
976 .Case("pwr3", true)
977 .Case("power4", true)
978 .Case("pwr4", true)
979 .Case("power5", true)
980 .Case("pwr5", true)
981 .Case("power5x", true)
982 .Case("pwr5x", true)
983 .Case("power6", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000984 .Case("pwr6", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000985 .Case("power6x", true)
986 .Case("pwr6x", true)
987 .Case("power7", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000988 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +0000989 .Case("power8", true)
990 .Case("pwr8", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +0000991 .Case("power9", true)
992 .Case("pwr9", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000993 .Case("powerpc", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000994 .Case("ppc", true)
Bill Schmidt38378a02013-02-01 20:23:10 +0000995 .Case("powerpc64", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000996 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +0000997 .Case("powerpc64le", true)
998 .Case("ppc64le", true)
Hal Finkel8eb59282012-06-11 22:35:19 +0000999 .Default(false);
1000
1001 if (CPUKnown)
1002 CPU = Name;
1003
1004 return CPUKnown;
1005 }
1006
Ulrich Weigand8afad612014-07-28 13:17:52 +00001007
1008 StringRef getABI() const override { return ABI; }
1009
Craig Topper6c03a542015-10-19 04:51:35 +00001010 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
1011 return llvm::makeArrayRef(BuiltinInfo,
1012 clang::PPC::LastTSBuiltin-Builtin::FirstTSBuiltin);
Chris Lattner10a5b382007-01-29 05:24:35 +00001013 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001014
Craig Topper3164f332014-03-11 03:39:26 +00001015 bool isCLZForZeroUndef() const override { return false; }
Bob Wilson19a2f2b2012-01-28 18:02:29 +00001016
Craig Topper3164f332014-03-11 03:39:26 +00001017 void getTargetDefines(const LangOptions &Opts,
1018 MacroBuilder &Builder) const override;
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001019
Eric Christopher8c47b422015-10-09 18:39:55 +00001020 bool
1021 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
1022 StringRef CPU,
1023 const std::vector<std::string> &FeaturesVec) const override;
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001024
Craig Topper3164f332014-03-11 03:39:26 +00001025 bool handleTargetFeatures(std::vector<std::string> &Features,
1026 DiagnosticsEngine &Diags) override;
1027 bool hasFeature(StringRef Feature) const override;
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001028 void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
1029 bool Enabled) const override;
Craig Topper3164f332014-03-11 03:39:26 +00001030
Craig Topperf054e3a2015-10-19 03:52:27 +00001031 ArrayRef<const char *> getGCCRegNames() const override;
1032 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00001033 bool validateAsmConstraint(const char *&Name,
1034 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00001035 switch (*Name) {
Anders Carlssonf511f642007-11-27 04:11:28 +00001036 default: return false;
1037 case 'O': // Zero
John Thompson07a61a42010-06-24 22:44:13 +00001038 break;
Anders Carlssonf511f642007-11-27 04:11:28 +00001039 case 'b': // Base register
1040 case 'f': // Floating point register
Chris Lattnerd9725f72009-04-26 07:16:29 +00001041 Info.setAllowsRegister();
John Thompson07a61a42010-06-24 22:44:13 +00001042 break;
1043 // FIXME: The following are added to allow parsing.
1044 // I just took a guess at what the actions should be.
1045 // Also, is more specific checking needed? I.e. specific registers?
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001046 case 'd': // Floating point register (containing 64-bit value)
John Thompson07a61a42010-06-24 22:44:13 +00001047 case 'v': // Altivec vector register
1048 Info.setAllowsRegister();
1049 break;
1050 case 'w':
1051 switch (Name[1]) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001052 case 'd':// VSX vector register to hold vector double data
1053 case 'f':// VSX vector register to hold vector float data
1054 case 's':// VSX vector register to hold scalar float data
1055 case 'a':// Any VSX register
Hal Finkelf7a07a52014-03-02 18:24:18 +00001056 case 'c':// An individual CR bit
John Thompson07a61a42010-06-24 22:44:13 +00001057 break;
1058 default:
1059 return false;
1060 }
1061 Info.setAllowsRegister();
1062 Name++; // Skip over 'w'.
1063 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001064 case 'h': // `MQ', `CTR', or `LINK' register
1065 case 'q': // `MQ' register
1066 case 'c': // `CTR' register
1067 case 'l': // `LINK' register
1068 case 'x': // `CR' register (condition register) number 0
1069 case 'y': // `CR' register (condition register)
1070 case 'z': // `XER[CA]' carry bit (part of the XER register)
John Thompson07a61a42010-06-24 22:44:13 +00001071 Info.setAllowsRegister();
1072 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001073 case 'I': // Signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +00001074 case 'J': // Unsigned 16-bit constant shifted left 16 bits
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001075 // (use `L' instead for SImode constants)
1076 case 'K': // Unsigned 16-bit constant
1077 case 'L': // Signed 16-bit constant shifted left 16 bits
1078 case 'M': // Constant larger than 31
1079 case 'N': // Exact power of 2
1080 case 'P': // Constant whose negation is a signed 16-bit constant
John Thompson07a61a42010-06-24 22:44:13 +00001081 case 'G': // Floating point constant that can be loaded into a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001082 // register with one instruction per word
John Thompson07a61a42010-06-24 22:44:13 +00001083 case 'H': // Integer/Floating point constant that can be loaded
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001084 // into a register using three instructions
John Thompson07a61a42010-06-24 22:44:13 +00001085 break;
1086 case 'm': // Memory operand. Note that on PowerPC targets, m can
1087 // include addresses that update the base register. It
1088 // is therefore only safe to use `m' in an asm statement
1089 // if that asm statement accesses the operand exactly once.
1090 // The asm statement must also use `%U<opno>' as a
Sebastian Redldd008712010-08-17 22:42:34 +00001091 // placeholder for the "update" flag in the corresponding
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001092 // load or store instruction. For example:
John Thompson07a61a42010-06-24 22:44:13 +00001093 // asm ("st%U0 %1,%0" : "=m" (mem) : "r" (val));
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001094 // is correct but:
John Thompson07a61a42010-06-24 22:44:13 +00001095 // asm ("st %1,%0" : "=m" (mem) : "r" (val));
1096 // is not. Use es rather than m if you don't want the base
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001097 // register to be updated.
1098 case 'e':
John Thompsonceebdf12010-06-25 00:02:05 +00001099 if (Name[1] != 's')
1100 return false;
Sebastian Redldd008712010-08-17 22:42:34 +00001101 // es: A "stable" memory operand; that is, one which does not
John Thompson07a61a42010-06-24 22:44:13 +00001102 // include any automodification of the base register. Unlike
1103 // `m', this constraint can be used in asm statements that
1104 // might access the operand several times, or that might not
John Thompsonceebdf12010-06-25 00:02:05 +00001105 // access it at all.
John Thompson07a61a42010-06-24 22:44:13 +00001106 Info.setAllowsMemory();
John Thompsonceebdf12010-06-25 00:02:05 +00001107 Name++; // Skip over 'e'.
John Thompson07a61a42010-06-24 22:44:13 +00001108 break;
1109 case 'Q': // Memory operand that is an offset from a register (it is
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001110 // usually better to use `m' or `es' in asm statements)
John Thompson07a61a42010-06-24 22:44:13 +00001111 case 'Z': // Memory operand that is an indexed or indirect from a
1112 // register (it is usually better to use `m' or `es' in
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001113 // asm statements)
John Thompson07a61a42010-06-24 22:44:13 +00001114 Info.setAllowsMemory();
1115 Info.setAllowsRegister();
1116 break;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001117 case 'R': // AIX TOC entry
John Thompson07a61a42010-06-24 22:44:13 +00001118 case 'a': // Address operand that is an indexed or indirect from a
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001119 // register (`p' is preferable for asm statements)
1120 case 'S': // Constant suitable as a 64-bit mask operand
1121 case 'T': // Constant suitable as a 32-bit mask operand
1122 case 'U': // System V Release 4 small data area reference
John Thompson07a61a42010-06-24 22:44:13 +00001123 case 't': // AND masks that can be performed by two rldic{l, r}
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001124 // instructions
1125 case 'W': // Vector constant that does not require memory
1126 case 'j': // Vector constant that is all zeros.
John Thompson07a61a42010-06-24 22:44:13 +00001127 break;
1128 // End FIXME.
Anders Carlssonf511f642007-11-27 04:11:28 +00001129 }
John Thompson07a61a42010-06-24 22:44:13 +00001130 return true;
Anders Carlssonf511f642007-11-27 04:11:28 +00001131 }
Craig Topper3164f332014-03-11 03:39:26 +00001132 std::string convertConstraint(const char *&Constraint) const override {
Hal Finkelf7a07a52014-03-02 18:24:18 +00001133 std::string R;
1134 switch (*Constraint) {
1135 case 'e':
1136 case 'w':
1137 // Two-character constraint; add "^" hint for later parsing.
1138 R = std::string("^") + std::string(Constraint, 2);
1139 Constraint++;
1140 break;
1141 default:
1142 return TargetInfo::convertConstraint(Constraint);
1143 }
1144 return R;
1145 }
Craig Topper3164f332014-03-11 03:39:26 +00001146 const char *getClobbers() const override {
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001147 return "";
Anders Carlssonf511f642007-11-27 04:11:28 +00001148 }
Craig Topper3164f332014-03-11 03:39:26 +00001149 int getEHDataRegisterNumber(unsigned RegNo) const override {
Adhemerval Zanella5d874ae2013-01-22 20:02:45 +00001150 if (RegNo == 0) return 3;
1151 if (RegNo == 1) return 4;
1152 return -1;
1153 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +00001154
1155 bool hasSjLjLowering() const override {
1156 return true;
1157 }
David Majnemer2617ea62015-06-09 18:05:33 +00001158
1159 bool useFloat128ManglingForLongDouble() const override {
1160 return LongDoubleWidth == 128 &&
Stephan Bergmann17c7f702016-12-14 11:57:17 +00001161 LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble() &&
David Majnemer2617ea62015-06-09 18:05:33 +00001162 getTriple().isOSBinFormatELF();
1163 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001164};
Anders Carlssonf511f642007-11-27 04:11:28 +00001165
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001166const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00001167#define BUILTIN(ID, TYPE, ATTRS) \
1168 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
1169#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
1170 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Chris Lattner5abdec72009-06-14 01:05:48 +00001171#include "clang/Basic/BuiltinsPPC.def"
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001172};
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001173
Eric Christopher917e9522014-11-18 22:36:15 +00001174/// handleTargetFeatures - Perform initialization based on the user
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001175/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00001176bool PPCTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001177 DiagnosticsEngine &Diags) {
Eric Christopher610fe112015-08-26 08:21:55 +00001178 for (const auto &Feature : Features) {
Eric Christopher758aad72017-03-21 22:06:18 +00001179 if (Feature == "+altivec") {
1180 HasAltivec = true;
1181 } else if (Feature == "+vsx") {
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001182 HasVSX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001183 } else if (Feature == "+bpermd") {
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001184 HasBPERMD = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001185 } else if (Feature == "+extdiv") {
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001186 HasExtDiv = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001187 } else if (Feature == "+power8-vector") {
Bill Schmidt8c184e32014-10-10 17:21:23 +00001188 HasP8Vector = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001189 } else if (Feature == "+crypto") {
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001190 HasP8Crypto = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001191 } else if (Feature == "+direct-move") {
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001192 HasDirectMove = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001193 } else if (Feature == "+qpx") {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001194 HasQPX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00001195 } else if (Feature == "+htm") {
Kit Barton8246f282015-03-25 19:41:41 +00001196 HasHTM = true;
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +00001197 } else if (Feature == "+float128") {
1198 HasFloat128 = true;
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001199 } else if (Feature == "+power9-vector") {
1200 HasP9Vector = true;
Kit Barton8246f282015-03-25 19:41:41 +00001201 }
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001202 // TODO: Finish this list and add an assert that we've handled them
1203 // all.
1204 }
Eric Christopher02c33352015-08-25 00:59:11 +00001205
Eric Christopherf0c2dd02015-08-25 13:45:28 +00001206 return true;
1207}
1208
Chris Lattnerecd49032009-03-02 22:27:17 +00001209/// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
1210/// #defines that are not tied to a specific subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00001211void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001212 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00001213 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001214 Builder.defineMacro("__ppc__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001215 Builder.defineMacro("__PPC__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001216 Builder.defineMacro("_ARCH_PPC");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001217 Builder.defineMacro("__powerpc__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001218 Builder.defineMacro("__POWERPC__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001219 if (PointerWidth == 64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001220 Builder.defineMacro("_ARCH_PPC64");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001221 Builder.defineMacro("__powerpc64__");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001222 Builder.defineMacro("__ppc64__");
Chandler Carruth6aa92ad2013-06-25 11:13:47 +00001223 Builder.defineMacro("__PPC64__");
Chris Lattnerecd49032009-03-02 22:27:17 +00001224 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001225
Chris Lattnerecd49032009-03-02 22:27:17 +00001226 // Target properties.
Bill Schmidt778d3872013-07-26 01:36:11 +00001227 if (getTriple().getArch() == llvm::Triple::ppc64le) {
1228 Builder.defineMacro("_LITTLE_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001229 } else {
1230 if (getTriple().getOS() != llvm::Triple::NetBSD &&
1231 getTriple().getOS() != llvm::Triple::OpenBSD)
1232 Builder.defineMacro("_BIG_ENDIAN");
Bill Schmidt778d3872013-07-26 01:36:11 +00001233 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001234
Ulrich Weigand8afad612014-07-28 13:17:52 +00001235 // ABI options.
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001236 if (ABI == "elfv1" || ABI == "elfv1-qpx")
Ulrich Weigand8afad612014-07-28 13:17:52 +00001237 Builder.defineMacro("_CALL_ELF", "1");
1238 if (ABI == "elfv2")
1239 Builder.defineMacro("_CALL_ELF", "2");
1240
Eric Christopher2fd2eda2017-03-25 03:33:59 +00001241 // This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but
Eric Christopher1e6fedb2017-03-25 19:26:04 +00001242 // our suppport post-dates this and it should work on all 64-bit ppc linux
1243 // platforms. It is guaranteed to work on all elfv2 platforms.
1244 if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64)
Eric Christopher2fd2eda2017-03-25 03:33:59 +00001245 Builder.defineMacro("_CALL_LINUX", "1");
1246
Chris Lattnerecd49032009-03-02 22:27:17 +00001247 // Subtarget options.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00001248 Builder.defineMacro("__NATURAL_ALIGNMENT__");
1249 Builder.defineMacro("__REGISTER_PREFIX__", "");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00001250
Chris Lattnerecd49032009-03-02 22:27:17 +00001251 // FIXME: Should be controlled by command line option.
Eric Christopheree214102017-03-25 06:37:23 +00001252 if (LongDoubleWidth == 128) {
Roman Divacky13b586f2013-07-03 19:45:54 +00001253 Builder.defineMacro("__LONG_DOUBLE_128__");
Eric Christopheree214102017-03-25 06:37:23 +00001254 Builder.defineMacro("__LONGDOUBLE128");
1255 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001256
Eric Christopher32ac5e42017-02-15 07:50:11 +00001257 // Define this for elfv2 (64-bit only) or 64-bit darwin.
1258 if (ABI == "elfv2" ||
1259 (getTriple().getOS() == llvm::Triple::Darwin && PointerWidth == 64))
1260 Builder.defineMacro("__STRUCT_PARM_ALIGN__", "16");
1261
Hal Finkel8eb59282012-06-11 22:35:19 +00001262 // CPU identification.
Eric Christopherb70819e2017-03-25 02:29:18 +00001263 ArchDefineTypes defs =
1264 (ArchDefineTypes)llvm::StringSwitch<int>(CPU)
1265 .Case("440", ArchDefineName)
1266 .Case("450", ArchDefineName | ArchDefine440)
1267 .Case("601", ArchDefineName)
1268 .Case("602", ArchDefineName | ArchDefinePpcgr)
1269 .Case("603", ArchDefineName | ArchDefinePpcgr)
1270 .Case("603e", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1271 .Case("603ev", ArchDefineName | ArchDefine603 | ArchDefinePpcgr)
1272 .Case("604", ArchDefineName | ArchDefinePpcgr)
1273 .Case("604e", ArchDefineName | ArchDefine604 | ArchDefinePpcgr)
1274 .Case("620", ArchDefineName | ArchDefinePpcgr)
1275 .Case("630", ArchDefineName | ArchDefinePpcgr)
1276 .Case("7400", ArchDefineName | ArchDefinePpcgr)
1277 .Case("7450", ArchDefineName | ArchDefinePpcgr)
1278 .Case("750", ArchDefineName | ArchDefinePpcgr)
1279 .Case("970", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr |
1280 ArchDefinePpcsq)
1281 .Case("a2", ArchDefineA2)
1282 .Case("a2q", ArchDefineName | ArchDefineA2 | ArchDefineA2q)
1283 .Case("pwr3", ArchDefinePpcgr)
1284 .Case("pwr4", ArchDefineName | ArchDefinePpcgr | ArchDefinePpcsq)
1285 .Case("pwr5", ArchDefineName | ArchDefinePwr4 | ArchDefinePpcgr |
1286 ArchDefinePpcsq)
1287 .Case("pwr5x", ArchDefineName | ArchDefinePwr5 | ArchDefinePwr4 |
1288 ArchDefinePpcgr | ArchDefinePpcsq)
1289 .Case("pwr6", ArchDefineName | ArchDefinePwr5x | ArchDefinePwr5 |
1290 ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1291 .Case("pwr6x", ArchDefineName | ArchDefinePwr6 | ArchDefinePwr5x |
1292 ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr |
1293 ArchDefinePpcsq)
1294 .Case("pwr7", ArchDefineName | ArchDefinePwr6x | ArchDefinePwr6 |
1295 ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 |
1296 ArchDefinePpcgr | ArchDefinePpcsq)
1297 .Case("pwr8", ArchDefineName | ArchDefinePwr7 | ArchDefinePwr6x |
1298 ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 |
1299 ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1300 .Case("pwr9", ArchDefineName | ArchDefinePwr8 | ArchDefinePwr7 |
1301 ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x |
1302 ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr |
1303 ArchDefinePpcsq)
1304 .Case("power3", ArchDefinePpcgr)
1305 .Case("power4", ArchDefinePwr4 | ArchDefinePpcgr | ArchDefinePpcsq)
1306 .Case("power5", ArchDefinePwr5 | ArchDefinePwr4 | ArchDefinePpcgr |
1307 ArchDefinePpcsq)
1308 .Case("power5x", ArchDefinePwr5x | ArchDefinePwr5 | ArchDefinePwr4 |
1309 ArchDefinePpcgr | ArchDefinePpcsq)
1310 .Case("power6", ArchDefinePwr6 | ArchDefinePwr5x | ArchDefinePwr5 |
1311 ArchDefinePwr4 | ArchDefinePpcgr |
1312 ArchDefinePpcsq)
1313 .Case("power6x", ArchDefinePwr6x | ArchDefinePwr6 | ArchDefinePwr5x |
1314 ArchDefinePwr5 | ArchDefinePwr4 |
1315 ArchDefinePpcgr | ArchDefinePpcsq)
1316 .Case("power7", ArchDefinePwr7 | ArchDefinePwr6x | ArchDefinePwr6 |
1317 ArchDefinePwr5x | ArchDefinePwr5 |
1318 ArchDefinePwr4 | ArchDefinePpcgr |
1319 ArchDefinePpcsq)
1320 .Case("power8", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x |
1321 ArchDefinePwr6 | ArchDefinePwr5x |
1322 ArchDefinePwr5 | ArchDefinePwr4 |
1323 ArchDefinePpcgr | ArchDefinePpcsq)
1324 .Case("power9", ArchDefinePwr9 | ArchDefinePwr8 | ArchDefinePwr7 |
1325 ArchDefinePwr6x | ArchDefinePwr6 |
1326 ArchDefinePwr5x | ArchDefinePwr5 |
1327 ArchDefinePwr4 | ArchDefinePpcgr |
1328 ArchDefinePpcsq)
1329 // powerpc64le automatically defaults to at least power8.
1330 .Case("ppc64le", ArchDefinePwr8 | ArchDefinePwr7 | ArchDefinePwr6x |
1331 ArchDefinePwr6 | ArchDefinePwr5x |
1332 ArchDefinePwr5 | ArchDefinePwr4 |
1333 ArchDefinePpcgr | ArchDefinePpcsq)
1334 .Default(ArchDefineNone);
Hal Finkel6b984f02012-07-03 16:51:04 +00001335
1336 if (defs & ArchDefineName)
1337 Builder.defineMacro(Twine("_ARCH_", StringRef(CPU).upper()));
1338 if (defs & ArchDefinePpcgr)
1339 Builder.defineMacro("_ARCH_PPCGR");
1340 if (defs & ArchDefinePpcsq)
1341 Builder.defineMacro("_ARCH_PPCSQ");
1342 if (defs & ArchDefine440)
Hal Finkel8eb59282012-06-11 22:35:19 +00001343 Builder.defineMacro("_ARCH_440");
Hal Finkel6b984f02012-07-03 16:51:04 +00001344 if (defs & ArchDefine603)
1345 Builder.defineMacro("_ARCH_603");
1346 if (defs & ArchDefine604)
1347 Builder.defineMacro("_ARCH_604");
Bill Schmidt38378a02013-02-01 20:23:10 +00001348 if (defs & ArchDefinePwr4)
Hal Finkel6b984f02012-07-03 16:51:04 +00001349 Builder.defineMacro("_ARCH_PWR4");
Bill Schmidt38378a02013-02-01 20:23:10 +00001350 if (defs & ArchDefinePwr5)
Hal Finkel6b984f02012-07-03 16:51:04 +00001351 Builder.defineMacro("_ARCH_PWR5");
Bill Schmidt38378a02013-02-01 20:23:10 +00001352 if (defs & ArchDefinePwr5x)
1353 Builder.defineMacro("_ARCH_PWR5X");
1354 if (defs & ArchDefinePwr6)
Hal Finkel8eb59282012-06-11 22:35:19 +00001355 Builder.defineMacro("_ARCH_PWR6");
Bill Schmidt38378a02013-02-01 20:23:10 +00001356 if (defs & ArchDefinePwr6x)
1357 Builder.defineMacro("_ARCH_PWR6X");
1358 if (defs & ArchDefinePwr7)
1359 Builder.defineMacro("_ARCH_PWR7");
Will Schmidtf0487512014-06-26 13:34:10 +00001360 if (defs & ArchDefinePwr8)
1361 Builder.defineMacro("_ARCH_PWR8");
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001362 if (defs & ArchDefinePwr9)
1363 Builder.defineMacro("_ARCH_PWR9");
Hal Finkeldf1e4bf2013-02-01 05:53:33 +00001364 if (defs & ArchDefineA2)
1365 Builder.defineMacro("_ARCH_A2");
1366 if (defs & ArchDefineA2q) {
1367 Builder.defineMacro("_ARCH_A2Q");
1368 Builder.defineMacro("_ARCH_QP");
1369 }
1370
1371 if (getTriple().getVendor() == llvm::Triple::BGQ) {
1372 Builder.defineMacro("__bg__");
1373 Builder.defineMacro("__THW_BLUEGENE__");
1374 Builder.defineMacro("__bgq__");
1375 Builder.defineMacro("__TOS_BGQ__");
1376 }
Bill Schmidt38378a02013-02-01 20:23:10 +00001377
Eric Christopher758aad72017-03-21 22:06:18 +00001378 if (HasAltivec) {
1379 Builder.defineMacro("__VEC__", "10206");
1380 Builder.defineMacro("__ALTIVEC__");
1381 }
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001382 if (HasVSX)
1383 Builder.defineMacro("__VSX__");
Bill Schmidt8c184e32014-10-10 17:21:23 +00001384 if (HasP8Vector)
Bill Schmidt59eb7672014-10-10 15:09:43 +00001385 Builder.defineMacro("__POWER8_VECTOR__");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001386 if (HasP8Crypto)
1387 Builder.defineMacro("__CRYPTO__");
Kit Barton8246f282015-03-25 19:41:41 +00001388 if (HasHTM)
1389 Builder.defineMacro("__HTM__");
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +00001390 if (HasFloat128)
1391 Builder.defineMacro("__FLOAT128__");
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001392 if (HasP9Vector)
1393 Builder.defineMacro("__POWER9_VECTOR__");
Hal Finkela57b8902015-10-01 13:39:49 +00001394
1395 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
1396 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
1397 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
1398 if (PointerWidth == 64)
1399 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Eric Christopher2fe3b4a2013-10-16 21:19:26 +00001400
Eric Christopher0d361162017-03-25 05:40:13 +00001401 // We have support for the bswap intrinsics so we can define this.
1402 Builder.defineMacro("__HAVE_BSWAP__", "1");
1403
Bill Schmidt38378a02013-02-01 20:23:10 +00001404 // FIXME: The following are not yet generated here by Clang, but are
1405 // generated by GCC:
1406 //
1407 // _SOFT_FLOAT_
1408 // __RECIP_PRECISION__
1409 // __APPLE_ALTIVEC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001410 // __RECIP__
1411 // __RECIPF__
1412 // __RSQRTE__
1413 // __RSQRTEF__
1414 // _SOFT_DOUBLE_
1415 // __NO_LWSYNC__
Bill Schmidt38378a02013-02-01 20:23:10 +00001416 // __CMODEL_MEDIUM__
1417 // __CMODEL_LARGE__
1418 // _CALL_SYSV
1419 // _CALL_DARWIN
1420 // __NO_FPRS__
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001421}
1422
Eric Christophera8a14c32015-08-31 18:39:16 +00001423// Handle explicit options being passed to the compiler here: if we've
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001424// explicitly turned off vsx and turned on any of:
1425// - power8-vector
1426// - direct-move
1427// - float128
1428// - power9-vector
1429// then go ahead and error since the customer has expressed an incompatible
Eric Christophera8a14c32015-08-31 18:39:16 +00001430// set of options.
1431static bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags,
Eric Christopher8c47b422015-10-09 18:39:55 +00001432 const std::vector<std::string> &FeaturesVec) {
Eric Christophera8a14c32015-08-31 18:39:16 +00001433
1434 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "-vsx") !=
1435 FeaturesVec.end()) {
1436 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+power8-vector") !=
1437 FeaturesVec.end()) {
1438 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower8-vector"
1439 << "-mno-vsx";
1440 return false;
1441 }
1442
1443 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+direct-move") !=
1444 FeaturesVec.end()) {
1445 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mdirect-move"
1446 << "-mno-vsx";
1447 return false;
1448 }
Nemanja Ivanovicbb1ea2d2016-05-09 08:52:33 +00001449
1450 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+float128") !=
1451 FeaturesVec.end()) {
1452 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfloat128"
1453 << "-mno-vsx";
1454 return false;
1455 }
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001456
1457 if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+power9-vector") !=
1458 FeaturesVec.end()) {
1459 Diags.Report(diag::err_opt_not_valid_with_opt) << "-mpower9-vector"
1460 << "-mno-vsx";
1461 return false;
1462 }
Eric Christophera8a14c32015-08-31 18:39:16 +00001463 }
1464
1465 return true;
1466}
1467
Eric Christopher8c47b422015-10-09 18:39:55 +00001468bool PPCTargetInfo::initFeatureMap(
1469 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
1470 const std::vector<std::string> &FeaturesVec) const {
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001471 Features["altivec"] = llvm::StringSwitch<bool>(CPU)
1472 .Case("7400", true)
1473 .Case("g4", true)
1474 .Case("7450", true)
1475 .Case("g4+", true)
1476 .Case("970", true)
1477 .Case("g5", true)
1478 .Case("pwr6", true)
1479 .Case("pwr7", true)
Will Schmidtf0487512014-06-26 13:34:10 +00001480 .Case("pwr8", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001481 .Case("pwr9", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001482 .Case("ppc64", true)
Bill Schmidt778d3872013-07-26 01:36:11 +00001483 .Case("ppc64le", true)
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001484 .Default(false);
Hal Finkelb58ce852013-02-01 18:44:19 +00001485
1486 Features["qpx"] = (CPU == "a2q");
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001487 Features["power9-vector"] = (CPU == "pwr9");
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001488 Features["crypto"] = llvm::StringSwitch<bool>(CPU)
1489 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001490 .Case("pwr9", true)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001491 .Case("pwr8", true)
1492 .Default(false);
1493 Features["power8-vector"] = llvm::StringSwitch<bool>(CPU)
1494 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001495 .Case("pwr9", true)
Nemanja Ivanovic55e757d2015-03-04 21:48:22 +00001496 .Case("pwr8", true)
1497 .Default(false);
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001498 Features["bpermd"] = llvm::StringSwitch<bool>(CPU)
1499 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001500 .Case("pwr9", true)
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001501 .Case("pwr8", true)
1502 .Case("pwr7", true)
1503 .Default(false);
1504 Features["extdiv"] = llvm::StringSwitch<bool>(CPU)
1505 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001506 .Case("pwr9", true)
Nemanja Ivanovic239eec72015-04-09 23:58:16 +00001507 .Case("pwr8", true)
1508 .Case("pwr7", true)
1509 .Default(false);
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001510 Features["direct-move"] = llvm::StringSwitch<bool>(CPU)
1511 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001512 .Case("pwr9", true)
Nemanja Ivanovic35458c22015-04-11 10:43:36 +00001513 .Case("pwr8", true)
1514 .Default(false);
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001515 Features["vsx"] = llvm::StringSwitch<bool>(CPU)
1516 .Case("ppc64le", true)
Nemanja Ivanovicd99f21b2016-05-09 18:58:02 +00001517 .Case("pwr9", true)
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001518 .Case("pwr8", true)
1519 .Case("pwr7", true)
1520 .Default(false);
Eric Christopher74fa24f2017-03-20 21:12:53 +00001521 Features["htm"] = llvm::StringSwitch<bool>(CPU)
1522 .Case("ppc64le", true)
1523 .Case("pwr9", true)
1524 .Case("pwr8", true)
1525 .Default(false);
Eric Christopheref1e2952015-08-28 02:13:58 +00001526
Eric Christophera8a14c32015-08-31 18:39:16 +00001527 if (!ppcUserFeaturesCheck(Diags, FeaturesVec))
1528 return false;
Eric Christopher007b0a02015-08-28 22:32:01 +00001529
Eric Christopher007b0a02015-08-28 22:32:01 +00001530 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Bill Schmidt2fe4c672013-02-01 02:14:03 +00001531}
1532
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001533bool PPCTargetInfo::hasFeature(StringRef Feature) const {
Bill Schmidte6e9d152014-11-02 14:56:41 +00001534 return llvm::StringSwitch<bool>(Feature)
Eric Christopher758aad72017-03-21 22:06:18 +00001535 .Case("powerpc", true)
1536 .Case("altivec", HasAltivec)
1537 .Case("vsx", HasVSX)
1538 .Case("power8-vector", HasP8Vector)
1539 .Case("crypto", HasP8Crypto)
1540 .Case("direct-move", HasDirectMove)
1541 .Case("qpx", HasQPX)
1542 .Case("htm", HasHTM)
1543 .Case("bpermd", HasBPERMD)
1544 .Case("extdiv", HasExtDiv)
1545 .Case("float128", HasFloat128)
1546 .Case("power9-vector", HasP9Vector)
1547 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00001548}
Chris Lattner17df24e2008-04-21 18:56:49 +00001549
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001550void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
1551 StringRef Name, bool Enabled) const {
Eric Christopherf0c2dd02015-08-25 13:45:28 +00001552 if (Enabled) {
Eric Christopherd26d8832017-04-15 06:15:00 +00001553 // If we're enabling any of the vsx based features then enable vsx and
1554 // altivec. We'll diagnose any problems later.
1555 bool FeatureHasVSX = llvm::StringSwitch<bool>(Name)
1556 .Case("vsx", true)
1557 .Case("direct-move", true)
1558 .Case("power8-vector", true)
1559 .Case("power9-vector", true)
1560 .Case("float128", true)
1561 .Default(false);
1562 if (FeatureHasVSX)
1563 Features["vsx"] = Features["altivec"] = true;
1564 if (Name == "power9-vector")
1565 Features["power8-vector"] = true;
1566 Features[Name] = true;
Eric Christopherf0c2dd02015-08-25 13:45:28 +00001567 } else {
Eric Christopherd26d8832017-04-15 06:15:00 +00001568 // If we're disabling altivec or vsx go ahead and disable all of the vsx
1569 // features.
1570 if ((Name == "altivec") || (Name == "vsx"))
1571 Features["vsx"] = Features["direct-move"] = Features["power8-vector"] =
Nemanja Ivanovic10e2b5d2016-09-27 10:45:22 +00001572 Features["float128"] = Features["power9-vector"] = false;
Eric Christopherd26d8832017-04-15 06:15:00 +00001573 if (Name == "power8-vector")
1574 Features["power9-vector"] = false;
1575 Features[Name] = false;
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001576 }
Nemanja Ivanovic26c35342015-07-10 13:11:34 +00001577}
1578
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001579const char * const PPCTargetInfo::GCCRegNames[] = {
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001580 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
1581 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
1582 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
1583 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
1584 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7",
1585 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15",
1586 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",
1587 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001588 "mq", "lr", "ctr", "ap",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001589 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001590 "xer",
Chris Lattnerf7ff53d2009-09-16 05:05:27 +00001591 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
1592 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
1593 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
1594 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001595 "vrsave", "vscr",
1596 "spe_acc", "spefscr",
1597 "sfp"
1598};
Chris Lattner10a5b382007-01-29 05:24:35 +00001599
Craig Topperf054e3a2015-10-19 03:52:27 +00001600ArrayRef<const char*> PPCTargetInfo::getGCCRegNames() const {
1601 return llvm::makeArrayRef(GCCRegNames);
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001602}
Chris Lattner5ba61f02006-10-14 07:39:34 +00001603
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001604const TargetInfo::GCCRegAlias PPCTargetInfo::GCCRegAliases[] = {
1605 // While some of these aliases do map to different registers
1606 // they still share the same register name.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001607 { { "0" }, "r0" },
1608 { { "1"}, "r1" },
1609 { { "2" }, "r2" },
1610 { { "3" }, "r3" },
1611 { { "4" }, "r4" },
1612 { { "5" }, "r5" },
1613 { { "6" }, "r6" },
1614 { { "7" }, "r7" },
1615 { { "8" }, "r8" },
1616 { { "9" }, "r9" },
1617 { { "10" }, "r10" },
1618 { { "11" }, "r11" },
1619 { { "12" }, "r12" },
1620 { { "13" }, "r13" },
1621 { { "14" }, "r14" },
1622 { { "15" }, "r15" },
1623 { { "16" }, "r16" },
1624 { { "17" }, "r17" },
1625 { { "18" }, "r18" },
1626 { { "19" }, "r19" },
1627 { { "20" }, "r20" },
1628 { { "21" }, "r21" },
1629 { { "22" }, "r22" },
1630 { { "23" }, "r23" },
1631 { { "24" }, "r24" },
1632 { { "25" }, "r25" },
1633 { { "26" }, "r26" },
1634 { { "27" }, "r27" },
1635 { { "28" }, "r28" },
1636 { { "29" }, "r29" },
1637 { { "30" }, "r30" },
1638 { { "31" }, "r31" },
1639 { { "fr0" }, "f0" },
1640 { { "fr1" }, "f1" },
1641 { { "fr2" }, "f2" },
1642 { { "fr3" }, "f3" },
1643 { { "fr4" }, "f4" },
1644 { { "fr5" }, "f5" },
1645 { { "fr6" }, "f6" },
1646 { { "fr7" }, "f7" },
1647 { { "fr8" }, "f8" },
1648 { { "fr9" }, "f9" },
Mike Stumpfaacf012009-09-17 21:15:00 +00001649 { { "fr10" }, "f10" },
Daniel Dunbar1da76c42009-09-17 07:03:19 +00001650 { { "fr11" }, "f11" },
1651 { { "fr12" }, "f12" },
1652 { { "fr13" }, "f13" },
1653 { { "fr14" }, "f14" },
1654 { { "fr15" }, "f15" },
1655 { { "fr16" }, "f16" },
1656 { { "fr17" }, "f17" },
1657 { { "fr18" }, "f18" },
1658 { { "fr19" }, "f19" },
1659 { { "fr20" }, "f20" },
1660 { { "fr21" }, "f21" },
1661 { { "fr22" }, "f22" },
1662 { { "fr23" }, "f23" },
1663 { { "fr24" }, "f24" },
1664 { { "fr25" }, "f25" },
1665 { { "fr26" }, "f26" },
1666 { { "fr27" }, "f27" },
1667 { { "fr28" }, "f28" },
1668 { { "fr29" }, "f29" },
1669 { { "fr30" }, "f30" },
1670 { { "fr31" }, "f31" },
1671 { { "cc" }, "cr0" },
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001672};
1673
Craig Topperf054e3a2015-10-19 03:52:27 +00001674ArrayRef<TargetInfo::GCCRegAlias> PPCTargetInfo::getGCCRegAliases() const {
1675 return llvm::makeArrayRef(GCCRegAliases);
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001676}
Chris Lattner02dffbd2006-10-14 07:50:21 +00001677
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001678class PPC32TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001679public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001680 PPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1681 : PPCTargetInfo(Triple, Opts) {
James Y Knightb214cbc2016-03-04 19:00:41 +00001682 resetDataLayout("E-m:e-p:32:32-i64:64-n32");
Chris Lattnerdb5c16b2010-02-16 18:14:57 +00001683
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001684 switch (getTriple().getOS()) {
Nico Weber3435ede2012-01-31 02:07:33 +00001685 case llvm::Triple::Linux:
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001686 case llvm::Triple::FreeBSD:
1687 case llvm::Triple::NetBSD:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001688 SizeType = UnsignedInt;
Hal Finkel26908382012-03-02 20:54:36 +00001689 PtrDiffType = SignedInt;
1690 IntPtrType = SignedInt;
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001691 break;
Joerg Sonnenbergerf031fd92011-07-04 23:11:58 +00001692 default:
Joerg Sonnenbergera6d11772011-07-05 14:54:41 +00001693 break;
Joerg Sonnenbergere72d9b12011-07-04 21:57:55 +00001694 }
Roman Divacky816dcd12012-03-13 16:53:54 +00001695
Roman Divacky3ffe7462012-03-13 19:20:17 +00001696 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
1697 LongDoubleWidth = LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00001698 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Roman Divacky3ffe7462012-03-13 19:20:17 +00001699 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001700
1701 // PPC32 supports atomics up to 4 bytes.
1702 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
Roman Divacky965b0b72011-01-06 08:27:10 +00001703 }
1704
Craig Topper3164f332014-03-11 03:39:26 +00001705 BuiltinVaListKind getBuiltinVaListKind() const override {
Roman Divacky965b0b72011-01-06 08:27:10 +00001706 // This is the ELF definition, and is overridden by the Darwin sub-target
Meador Inge5d3fb222012-06-16 03:34:49 +00001707 return TargetInfo::PowerABIBuiltinVaList;
Eli Friedman873f65a2008-08-21 00:13:15 +00001708 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00001709};
Chris Lattner5ba61f02006-10-14 07:39:34 +00001710
Bill Schmidt778d3872013-07-26 01:36:11 +00001711// Note: ABI differences may eventually require us to have a separate
1712// TargetInfo for little endian.
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001713class PPC64TargetInfo : public PPCTargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00001714public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001715 PPC64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1716 : PPCTargetInfo(Triple, Opts) {
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001717 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001718 IntMaxType = SignedLong;
Eli Friedman2857ccb2009-07-01 03:36:11 +00001719 Int64Type = SignedLong;
Roman Divacky816dcd12012-03-13 16:53:54 +00001720
Eric Christopherf6ee1f32017-02-10 04:35:21 +00001721 if ((Triple.getArch() == llvm::Triple::ppc64le)) {
1722 resetDataLayout("e-m:e-i64:64-n32:64");
Eric Christopher4855ba82017-02-10 03:32:34 +00001723 ABI = "elfv2";
Eric Christopherf6ee1f32017-02-10 04:35:21 +00001724 } else {
1725 resetDataLayout("E-m:e-i64:64-n32:64");
Eric Christopher4855ba82017-02-10 03:32:34 +00001726 ABI = "elfv1";
Eric Christopherf6ee1f32017-02-10 04:35:21 +00001727 }
Eric Christopher4855ba82017-02-10 03:32:34 +00001728
Eric Christopherf6ee1f32017-02-10 04:35:21 +00001729 switch (getTriple().getOS()) {
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001730 case llvm::Triple::FreeBSD:
Roman Divacky3ffe7462012-03-13 19:20:17 +00001731 LongDoubleWidth = LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00001732 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001733 break;
Joerg Sonnenbergeraac82c42014-10-15 19:52:03 +00001734 case llvm::Triple::NetBSD:
1735 IntMaxType = SignedLongLong;
1736 Int64Type = SignedLongLong;
1737 break;
Joerg Sonnenberger3f1a9352014-10-15 19:47:15 +00001738 default:
1739 break;
Ulrich Weigand8afad612014-07-28 13:17:52 +00001740 }
Benjamin Kramer37196de2012-11-17 17:30:55 +00001741
1742 // PPC64 supports atomics up to 8 bytes.
1743 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Chris Lattnerba7a6c12008-05-09 06:17:04 +00001744 }
Craig Topper3164f332014-03-11 03:39:26 +00001745 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001746 return TargetInfo::CharPtrBuiltinVaList;
Roman Divacky965b0b72011-01-06 08:27:10 +00001747 }
Eric Christophere6b7cf42015-07-10 18:25:52 +00001748 // PPC64 Linux-specific ABI options.
Ulrich Weigand8afad612014-07-28 13:17:52 +00001749 bool setABI(const std::string &Name) override {
Hal Finkel0d0a1a52015-03-11 19:14:15 +00001750 if (Name == "elfv1" || Name == "elfv1-qpx" || Name == "elfv2") {
Ulrich Weigand8afad612014-07-28 13:17:52 +00001751 ABI = Name;
1752 return true;
1753 }
1754 return false;
1755 }
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001756};
Eli Friedmanb9e5bed2008-08-20 23:11:40 +00001757
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001758class DarwinPPC32TargetInfo : public DarwinTargetInfo<PPC32TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001759public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001760 DarwinPPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1761 : DarwinTargetInfo<PPC32TargetInfo>(Triple, Opts) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001762 HasAlignMac68kSupport = true;
Roman Divacky965b0b72011-01-06 08:27:10 +00001763 BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
Eric Christopher917e9522014-11-18 22:36:15 +00001764 PtrDiffType = SignedInt; // for http://llvm.org/bugs/show_bug.cgi?id=15726
Anton Yartsev68d773c2012-01-17 22:40:00 +00001765 LongLongAlign = 32;
James Y Knightb214cbc2016-03-04 19:00:41 +00001766 resetDataLayout("E-m:o-p:32:32-f64:32:64-n32");
Roman Divacky965b0b72011-01-06 08:27:10 +00001767 }
Craig Topper3164f332014-03-11 03:39:26 +00001768 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00001769 return TargetInfo::CharPtrBuiltinVaList;
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001770 }
1771};
1772
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001773class DarwinPPC64TargetInfo : public DarwinTargetInfo<PPC64TargetInfo> {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001774public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001775 DarwinPPC64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
1776 : DarwinTargetInfo<PPC64TargetInfo>(Triple, Opts) {
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001777 HasAlignMac68kSupport = true;
James Y Knightb214cbc2016-03-04 19:00:41 +00001778 resetDataLayout("E-m:o-i64:64-n32:64");
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001779 }
1780};
Daniel Dunbar0e15c9a2010-05-30 00:07:30 +00001781
Eric Christopherc48497a2015-09-18 21:26:24 +00001782static const unsigned NVPTXAddrSpaceMap[] = {
Yaxun Liub34ec822017-04-11 17:24:23 +00001783 0, // Default
Eric Christopherc48497a2015-09-18 21:26:24 +00001784 1, // opencl_global
1785 3, // opencl_local
1786 4, // opencl_constant
Anastasia Stulova2c8dcfb2014-11-26 14:10:06 +00001787 // FIXME: generic has to be added to the target
Eric Christopherc48497a2015-09-18 21:26:24 +00001788 0, // opencl_generic
1789 1, // cuda_device
1790 4, // cuda_constant
1791 3, // cuda_shared
1792};
1793
1794class NVPTXTargetInfo : public TargetInfo {
1795 static const char *const GCCRegNames[];
1796 static const Builtin::Info BuiltinInfo[];
Justin Lebar62907612016-07-06 21:21:39 +00001797 CudaArch GPU;
Justin Lebarb6626592017-01-05 16:53:21 +00001798 std::unique_ptr<TargetInfo> HostTarget;
Reid Klecknerbbc01782014-12-03 21:53:36 +00001799
Eric Christopherc48497a2015-09-18 21:26:24 +00001800public:
Justin Lebarb6626592017-01-05 16:53:21 +00001801 NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts,
1802 unsigned TargetPointerWidth)
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00001803 : TargetInfo(Triple) {
Justin Lebarb6626592017-01-05 16:53:21 +00001804 assert((TargetPointerWidth == 32 || TargetPointerWidth == 64) &&
1805 "NVPTX only supports 32- and 64-bit modes.");
1806
Eric Christopherc48497a2015-09-18 21:26:24 +00001807 TLSSupported = false;
Eric Christopherc48497a2015-09-18 21:26:24 +00001808 AddrSpaceMap = &NVPTXAddrSpaceMap;
1809 UseAddrSpaceMapMangling = true;
Justin Lebarb6626592017-01-05 16:53:21 +00001810
Eric Christopherc48497a2015-09-18 21:26:24 +00001811 // Define available target features
1812 // These must be defined in sorted order!
1813 NoAsmVariants = true;
Justin Lebar62907612016-07-06 21:21:39 +00001814 GPU = CudaArch::SM_20;
Justin Lebar76945b22016-04-29 23:05:19 +00001815
Justin Lebarb6626592017-01-05 16:53:21 +00001816 if (TargetPointerWidth == 32)
1817 resetDataLayout("e-p:32:32-i64:64-v16:16-v32:32-n16:32:64");
1818 else
1819 resetDataLayout("e-i64:64-v16:16-v32:32-n16:32:64");
1820
Justin Lebar76945b22016-04-29 23:05:19 +00001821 // If possible, get a TargetInfo for our host triple, so we can match its
1822 // types.
1823 llvm::Triple HostTriple(Opts.HostTriple);
Justin Lebarb6626592017-01-05 16:53:21 +00001824 if (!HostTriple.isNVPTX())
1825 HostTarget.reset(AllocateTarget(llvm::Triple(Opts.HostTriple), Opts));
1826
1827 // If no host target, make some guesses about the data layout and return.
Justin Lebar76945b22016-04-29 23:05:19 +00001828 if (!HostTarget) {
Justin Lebarb6626592017-01-05 16:53:21 +00001829 LongWidth = LongAlign = TargetPointerWidth;
1830 PointerWidth = PointerAlign = TargetPointerWidth;
1831 switch (TargetPointerWidth) {
1832 case 32:
1833 SizeType = TargetInfo::UnsignedInt;
1834 PtrDiffType = TargetInfo::SignedInt;
1835 IntPtrType = TargetInfo::SignedInt;
1836 break;
1837 case 64:
1838 SizeType = TargetInfo::UnsignedLong;
1839 PtrDiffType = TargetInfo::SignedLong;
1840 IntPtrType = TargetInfo::SignedLong;
1841 break;
1842 default:
1843 llvm_unreachable("TargetPointerWidth must be 32 or 64");
1844 }
Justin Lebar76945b22016-04-29 23:05:19 +00001845 return;
1846 }
1847
Justin Lebarb6626592017-01-05 16:53:21 +00001848 // Copy properties from host target.
Justin Lebar76945b22016-04-29 23:05:19 +00001849 PointerWidth = HostTarget->getPointerWidth(/* AddrSpace = */ 0);
1850 PointerAlign = HostTarget->getPointerAlign(/* AddrSpace = */ 0);
1851 BoolWidth = HostTarget->getBoolWidth();
1852 BoolAlign = HostTarget->getBoolAlign();
1853 IntWidth = HostTarget->getIntWidth();
1854 IntAlign = HostTarget->getIntAlign();
1855 HalfWidth = HostTarget->getHalfWidth();
1856 HalfAlign = HostTarget->getHalfAlign();
1857 FloatWidth = HostTarget->getFloatWidth();
1858 FloatAlign = HostTarget->getFloatAlign();
1859 DoubleWidth = HostTarget->getDoubleWidth();
1860 DoubleAlign = HostTarget->getDoubleAlign();
1861 LongWidth = HostTarget->getLongWidth();
1862 LongAlign = HostTarget->getLongAlign();
1863 LongLongWidth = HostTarget->getLongLongWidth();
1864 LongLongAlign = HostTarget->getLongLongAlign();
1865 MinGlobalAlign = HostTarget->getMinGlobalAlign();
Richard Smith59139022016-09-30 22:41:36 +00001866 NewAlign = HostTarget->getNewAlign();
Justin Lebar76945b22016-04-29 23:05:19 +00001867 DefaultAlignForAttributeAligned =
1868 HostTarget->getDefaultAlignForAttributeAligned();
1869 SizeType = HostTarget->getSizeType();
1870 IntMaxType = HostTarget->getIntMaxType();
1871 PtrDiffType = HostTarget->getPtrDiffType(/* AddrSpace = */ 0);
1872 IntPtrType = HostTarget->getIntPtrType();
1873 WCharType = HostTarget->getWCharType();
1874 WIntType = HostTarget->getWIntType();
1875 Char16Type = HostTarget->getChar16Type();
1876 Char32Type = HostTarget->getChar32Type();
1877 Int64Type = HostTarget->getInt64Type();
1878 SigAtomicType = HostTarget->getSigAtomicType();
1879 ProcessIDType = HostTarget->getProcessIDType();
1880
1881 UseBitFieldTypeAlignment = HostTarget->useBitFieldTypeAlignment();
1882 UseZeroLengthBitfieldAlignment =
1883 HostTarget->useZeroLengthBitfieldAlignment();
1884 UseExplicitBitFieldAlignment = HostTarget->useExplicitBitFieldAlignment();
1885 ZeroLengthBitfieldBoundary = HostTarget->getZeroLengthBitfieldBoundary();
1886
Justin Lebar5057f172016-09-09 20:35:43 +00001887 // This is a bit of a lie, but it controls __GCC_ATOMIC_XXX_LOCK_FREE, and
1888 // we need those macros to be identical on host and device, because (among
1889 // other things) they affect which standard library classes are defined, and
1890 // we need all classes to be defined on both the host and device.
1891 MaxAtomicInlineWidth = HostTarget->getMaxAtomicInlineWidth();
1892
Justin Lebar76945b22016-04-29 23:05:19 +00001893 // Properties intentionally not copied from host:
1894 // - LargeArrayMinWidth, LargeArrayAlign: Not visible across the
1895 // host/device boundary.
1896 // - SuitableAlign: Not visible across the host/device boundary, and may
1897 // correctly be different on host/device, e.g. if host has wider vector
1898 // types than device.
1899 // - LongDoubleWidth, LongDoubleAlign: nvptx's long double type is the same
1900 // as its double type, but that's not necessarily true on the host.
1901 // TODO: nvcc emits a warning when using long double on device; we should
1902 // do the same.
Eric Christopherc48497a2015-09-18 21:26:24 +00001903 }
1904 void getTargetDefines(const LangOptions &Opts,
1905 MacroBuilder &Builder) const override {
1906 Builder.defineMacro("__PTX__");
1907 Builder.defineMacro("__NVPTX__");
1908 if (Opts.CUDAIsDevice) {
1909 // Set __CUDA_ARCH__ for the GPU specified.
Justin Lebaref1aaac2016-07-06 21:21:14 +00001910 std::string CUDAArchCode = [this] {
1911 switch (GPU) {
Simon Pilgrim13dff572016-07-07 22:32:26 +00001912 case CudaArch::UNKNOWN:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001913 assert(false && "No GPU arch when compiling CUDA device code.");
1914 return "";
Justin Lebar62907612016-07-06 21:21:39 +00001915 case CudaArch::SM_20:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001916 return "200";
Justin Lebar62907612016-07-06 21:21:39 +00001917 case CudaArch::SM_21:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001918 return "210";
Justin Lebar62907612016-07-06 21:21:39 +00001919 case CudaArch::SM_30:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001920 return "300";
Justin Lebar62907612016-07-06 21:21:39 +00001921 case CudaArch::SM_32:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001922 return "320";
Justin Lebar62907612016-07-06 21:21:39 +00001923 case CudaArch::SM_35:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001924 return "350";
Justin Lebar62907612016-07-06 21:21:39 +00001925 case CudaArch::SM_37:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001926 return "370";
Justin Lebar62907612016-07-06 21:21:39 +00001927 case CudaArch::SM_50:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001928 return "500";
Justin Lebar62907612016-07-06 21:21:39 +00001929 case CudaArch::SM_52:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001930 return "520";
Justin Lebar62907612016-07-06 21:21:39 +00001931 case CudaArch::SM_53:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001932 return "530";
Justin Lebar62907612016-07-06 21:21:39 +00001933 case CudaArch::SM_60:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001934 return "600";
Justin Lebar62907612016-07-06 21:21:39 +00001935 case CudaArch::SM_61:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001936 return "610";
Justin Lebar62907612016-07-06 21:21:39 +00001937 case CudaArch::SM_62:
Justin Lebaref1aaac2016-07-06 21:21:14 +00001938 return "620";
1939 }
Simon Pilgrim13dff572016-07-07 22:32:26 +00001940 llvm_unreachable("unhandled CudaArch");
Justin Lebaref1aaac2016-07-06 21:21:14 +00001941 }();
Eric Christopherc48497a2015-09-18 21:26:24 +00001942 Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
Peter Collingbournec947aae2012-05-20 23:28:41 +00001943 }
Eric Christopherc48497a2015-09-18 21:26:24 +00001944 }
Craig Topper6c03a542015-10-19 04:51:35 +00001945 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
1946 return llvm::makeArrayRef(BuiltinInfo,
1947 clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
Eric Christopherc48497a2015-09-18 21:26:24 +00001948 }
Artem Belevichfda99052016-09-28 17:47:35 +00001949 bool
1950 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
1951 StringRef CPU,
1952 const std::vector<std::string> &FeaturesVec) const override {
1953 Features["satom"] = GPU >= CudaArch::SM_60;
1954 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
1955 }
1956
Eric Christopherc48497a2015-09-18 21:26:24 +00001957 bool hasFeature(StringRef Feature) const override {
Artem Belevichfda99052016-09-28 17:47:35 +00001958 return llvm::StringSwitch<bool>(Feature)
1959 .Cases("ptx", "nvptx", true)
1960 .Case("satom", GPU >= CudaArch::SM_60) // Atomics w/ scope.
1961 .Default(false);
Peter Collingbournec947aae2012-05-20 23:28:41 +00001962 }
1963
Craig Topperf054e3a2015-10-19 03:52:27 +00001964 ArrayRef<const char *> getGCCRegNames() const override;
1965 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00001966 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00001967 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00001968 }
1969 bool validateAsmConstraint(const char *&Name,
1970 TargetInfo::ConstraintInfo &Info) const override {
1971 switch (*Name) {
1972 default:
1973 return false;
1974 case 'c':
1975 case 'h':
1976 case 'r':
1977 case 'l':
1978 case 'f':
1979 case 'd':
1980 Info.setAllowsRegister();
1981 return true;
Eli Bendersky13467172015-04-01 20:29:18 +00001982 }
Eric Christopherc48497a2015-09-18 21:26:24 +00001983 }
1984 const char *getClobbers() const override {
1985 // FIXME: Is this really right?
1986 return "";
1987 }
1988 BuiltinVaListKind getBuiltinVaListKind() const override {
1989 // FIXME: implement
1990 return TargetInfo::CharPtrBuiltinVaList;
1991 }
1992 bool setCPU(const std::string &Name) override {
Justin Lebar62907612016-07-06 21:21:39 +00001993 GPU = StringToCudaArch(Name);
1994 return GPU != CudaArch::UNKNOWN;
Eric Christopherc48497a2015-09-18 21:26:24 +00001995 }
Jan Vesely9674bd42016-06-17 19:02:14 +00001996 void setSupportedOpenCLOpts() override {
1997 auto &Opts = getSupportedOpenCLOpts();
Yaxun Liu5b746652016-12-18 05:18:55 +00001998 Opts.support("cl_clang_storage_class_specifiers");
1999 Opts.support("cl_khr_gl_sharing");
2000 Opts.support("cl_khr_icd");
Jan Vesely9674bd42016-06-17 19:02:14 +00002001
Yaxun Liu5b746652016-12-18 05:18:55 +00002002 Opts.support("cl_khr_fp64");
2003 Opts.support("cl_khr_byte_addressable_store");
2004 Opts.support("cl_khr_global_int32_base_atomics");
2005 Opts.support("cl_khr_global_int32_extended_atomics");
2006 Opts.support("cl_khr_local_int32_base_atomics");
2007 Opts.support("cl_khr_local_int32_extended_atomics");
Jan Vesely9674bd42016-06-17 19:02:14 +00002008 }
Justin Lebar86c4e632017-01-05 16:53:38 +00002009
2010 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
2011 // CUDA compilations support all of the host's calling conventions.
2012 //
2013 // TODO: We should warn if you apply a non-default CC to anything other than
2014 // a host function.
2015 if (HostTarget)
2016 return HostTarget->checkCallingConvention(CC);
2017 return CCCR_Warning;
2018 }
Eric Christopherc48497a2015-09-18 21:26:24 +00002019};
2020
2021const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
2022#define BUILTIN(ID, TYPE, ATTRS) \
2023 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
2024#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
2025 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Artem Belevichfda99052016-09-28 17:47:35 +00002026#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
2027 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Eric Christopherc48497a2015-09-18 21:26:24 +00002028#include "clang/Basic/BuiltinsNVPTX.def"
2029};
2030
2031const char *const NVPTXTargetInfo::GCCRegNames[] = {"r0"};
2032
Craig Topperf054e3a2015-10-19 03:52:27 +00002033ArrayRef<const char *> NVPTXTargetInfo::getGCCRegNames() const {
2034 return llvm::makeArrayRef(GCCRegNames);
Eric Christopherc48497a2015-09-18 21:26:24 +00002035}
2036
Yaxun Liu6d96f1632017-05-18 18:51:09 +00002037static const LangAS::Map AMDGPUNonOpenCLPrivateIsZeroMap = {
2038 4, // Default
2039 1, // opencl_global
2040 3, // opencl_local
2041 2, // opencl_constant
2042 4, // opencl_generic
2043 1, // cuda_device
2044 2, // cuda_constant
2045 3 // cuda_shared
Yaxun Liu3464f922017-03-25 03:46:25 +00002046};
Yaxun Liu6d96f1632017-05-18 18:51:09 +00002047static const LangAS::Map AMDGPUNonOpenCLGenericIsZeroMap = {
2048 0, // Default
2049 1, // opencl_global
2050 3, // opencl_local
2051 2, // opencl_constant
2052 0, // opencl_generic
2053 1, // cuda_device
2054 2, // cuda_constant
2055 3 // cuda_shared
2056};
2057static const LangAS::Map AMDGPUOpenCLPrivateIsZeroMap = {
2058 0, // Default
2059 1, // opencl_global
2060 3, // opencl_local
2061 2, // opencl_constant
2062 4, // opencl_generic
2063 1, // cuda_device
2064 2, // cuda_constant
2065 3 // cuda_shared
2066};
2067static const LangAS::Map AMDGPUOpenCLGenericIsZeroMap = {
2068 5, // Default
2069 1, // opencl_global
2070 3, // opencl_local
2071 2, // opencl_constant
2072 0, // opencl_generic
2073 1, // cuda_device
2074 2, // cuda_constant
2075 3 // cuda_shared
Eli Friedmand13b41e2012-10-12 23:32:00 +00002076};
2077
Tom Stellarda96344b2014-08-21 13:58:40 +00002078// If you edit the description strings, make sure you update
2079// getPointerWidthV().
2080
Craig Topper273dbc62015-10-18 05:29:26 +00002081static const char *const DataLayoutStringR600 =
Rafael Espindola29db13a2014-01-03 18:13:17 +00002082 "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
2083 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00002084
Yaxun Liu3464f922017-03-25 03:46:25 +00002085static const char *const DataLayoutStringSIPrivateIsZero =
Matt Arsenault6dc455f2016-05-31 16:58:18 +00002086 "e-p:32:32-p1:64:64-p2:64:64-p3:32:32-p4:64:64-p5:32:32"
Rafael Espindola29db13a2014-01-03 18:13:17 +00002087 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
2088 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64";
Tom Stellardc74b1e02013-03-04 17:40:53 +00002089
Yaxun Liu3464f922017-03-25 03:46:25 +00002090static const char *const DataLayoutStringSIGenericIsZero =
Yaxun Liub122ed92017-04-06 19:18:36 +00002091 "e-p:64:64-p1:64:64-p2:64:64-p3:32:32-p4:32:32-p5:32:32"
Yaxun Liu3464f922017-03-25 03:46:25 +00002092 "-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128"
Yaxun Liub34ec822017-04-11 17:24:23 +00002093 "-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-A5";
Yaxun Liu3464f922017-03-25 03:46:25 +00002094
Matt Arsenault250024f2016-06-08 01:56:42 +00002095class AMDGPUTargetInfo final : public TargetInfo {
Matt Arsenault56f008d2014-06-24 20:45:01 +00002096 static const Builtin::Info BuiltinInfo[];
Tom Stellard7b1059b2015-04-14 14:36:56 +00002097 static const char * const GCCRegNames[];
Matt Arsenault56f008d2014-06-24 20:45:01 +00002098
Yaxun Liu3464f922017-03-25 03:46:25 +00002099 struct AddrSpace {
2100 unsigned Generic, Global, Local, Constant, Private;
2101 AddrSpace(bool IsGenericZero_ = false){
2102 if (IsGenericZero_) {
2103 Generic = 0;
2104 Global = 1;
2105 Local = 3;
Yaxun Liub122ed92017-04-06 19:18:36 +00002106 Constant = 2;
Yaxun Liu3464f922017-03-25 03:46:25 +00002107 Private = 5;
2108 } else {
2109 Generic = 4;
2110 Global = 1;
2111 Local = 3;
2112 Constant = 2;
2113 Private = 0;
2114 }
2115 }
2116 };
2117
Matt Arsenault3ea39f92015-06-19 17:54:10 +00002118 /// \brief The GPU profiles supported by the AMDGPU target.
Tom Stellardc74b1e02013-03-04 17:40:53 +00002119 enum GPUKind {
2120 GK_NONE,
2121 GK_R600,
2122 GK_R600_DOUBLE_OPS,
2123 GK_R700,
2124 GK_R700_DOUBLE_OPS,
2125 GK_EVERGREEN,
2126 GK_EVERGREEN_DOUBLE_OPS,
2127 GK_NORTHERN_ISLANDS,
2128 GK_CAYMAN,
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002129 GK_GFX6,
2130 GK_GFX7,
Matt Arsenaulteb952fd2017-02-18 19:02:41 +00002131 GK_GFX8,
2132 GK_GFX9
Tom Stellardc74b1e02013-03-04 17:40:53 +00002133 } GPU;
2134
Jan Veselyeebeaea2015-05-04 19:53:36 +00002135 bool hasFP64:1;
2136 bool hasFMAF:1;
2137 bool hasLDEXPF:1;
Yaxun Liu354097b2017-03-25 11:34:41 +00002138 const AddrSpace AS;
Jan Veselya3abd6d2015-05-01 17:38:13 +00002139
Konstantin Zhuravlyove668b1c2017-04-14 05:33:57 +00002140 static bool hasFullSpeedFMAF32(StringRef GPUName) {
2141 return parseAMDGCNName(GPUName) >= GK_GFX9;
2142 }
2143
Matt Arsenault250024f2016-06-08 01:56:42 +00002144 static bool isAMDGCN(const llvm::Triple &TT) {
2145 return TT.getArch() == llvm::Triple::amdgcn;
2146 }
2147
Yaxun Liu3464f922017-03-25 03:46:25 +00002148 static bool isGenericZero(const llvm::Triple &TT) {
2149 return TT.getEnvironmentName() == "amdgiz" ||
2150 TT.getEnvironmentName() == "amdgizcl";
2151 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00002152public:
Yaxun Liu2c17e822016-08-09 19:43:38 +00002153 AMDGPUTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Matt Arsenault250024f2016-06-08 01:56:42 +00002154 : TargetInfo(Triple) ,
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002155 GPU(isAMDGCN(Triple) ? GK_GFX6 : GK_R600),
Matt Arsenault250024f2016-06-08 01:56:42 +00002156 hasFP64(false),
2157 hasFMAF(false),
Yaxun Liu2c17e822016-08-09 19:43:38 +00002158 hasLDEXPF(false),
Yaxun Liu3464f922017-03-25 03:46:25 +00002159 AS(isGenericZero(Triple)){
Matt Arsenault250024f2016-06-08 01:56:42 +00002160 if (getTriple().getArch() == llvm::Triple::amdgcn) {
Jan Veselya3abd6d2015-05-01 17:38:13 +00002161 hasFP64 = true;
Jan Veselyeebeaea2015-05-04 19:53:36 +00002162 hasFMAF = true;
2163 hasLDEXPF = true;
Tom Stellardd99fb952015-01-28 15:38:44 +00002164 }
Yaxun Liu3464f922017-03-25 03:46:25 +00002165 auto IsGenericZero = isGenericZero(Triple);
Matt Arsenault250024f2016-06-08 01:56:42 +00002166 resetDataLayout(getTriple().getArch() == llvm::Triple::amdgcn ?
Yaxun Liu3464f922017-03-25 03:46:25 +00002167 (IsGenericZero ? DataLayoutStringSIGenericIsZero :
2168 DataLayoutStringSIPrivateIsZero)
2169 : DataLayoutStringR600);
Yaxun Liub34ec822017-04-11 17:24:23 +00002170 assert(DataLayout->getAllocaAddrSpace() == AS.Private);
Matt Arsenault250024f2016-06-08 01:56:42 +00002171
David Tweed31d09b02013-09-13 12:04:22 +00002172 UseAddrSpaceMapMangling = true;
Eli Friedmand13b41e2012-10-12 23:32:00 +00002173 }
2174
Yaxun Liuaf3d4db2017-05-23 16:15:53 +00002175 void adjust(LangOptions &Opts) override {
2176 TargetInfo::adjust(Opts);
2177 if (isGenericZero(getTriple())) {
2178 AddrSpaceMap = Opts.OpenCL ? &AMDGPUOpenCLGenericIsZeroMap
2179 : &AMDGPUNonOpenCLGenericIsZeroMap;
2180 } else {
2181 AddrSpaceMap = Opts.OpenCL ? &AMDGPUOpenCLPrivateIsZeroMap
2182 : &AMDGPUNonOpenCLPrivateIsZeroMap;
2183 }
2184 }
2185
Tom Stellarda96344b2014-08-21 13:58:40 +00002186 uint64_t getPointerWidthV(unsigned AddrSpace) const override {
2187 if (GPU <= GK_CAYMAN)
2188 return 32;
2189
Yaxun Liu3464f922017-03-25 03:46:25 +00002190 if (AddrSpace == AS.Private || AddrSpace == AS.Local) {
2191 return 32;
Tom Stellarda96344b2014-08-21 13:58:40 +00002192 }
Yaxun Liu3464f922017-03-25 03:46:25 +00002193 return 64;
Tom Stellarda96344b2014-08-21 13:58:40 +00002194 }
2195
Yaxun Liu26f75662016-08-19 05:17:25 +00002196 uint64_t getMaxPointerWidth() const override {
2197 return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
2198 }
2199
Craig Topper3164f332014-03-11 03:39:26 +00002200 const char * getClobbers() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00002201 return "";
2202 }
2203
Craig Topperf054e3a2015-10-19 03:52:27 +00002204 ArrayRef<const char *> getGCCRegNames() const override;
Eli Friedmand13b41e2012-10-12 23:32:00 +00002205
Craig Topperf054e3a2015-10-19 03:52:27 +00002206 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
2207 return None;
Eli Friedmand13b41e2012-10-12 23:32:00 +00002208 }
2209
Craig Topper3164f332014-03-11 03:39:26 +00002210 bool validateAsmConstraint(const char *&Name,
Tom Stellardd097e942015-11-19 22:11:58 +00002211 TargetInfo::ConstraintInfo &Info) const override {
2212 switch (*Name) {
2213 default: break;
2214 case 'v': // vgpr
2215 case 's': // sgpr
2216 Info.setAllowsRegister();
2217 return true;
2218 }
2219 return false;
Eli Friedmand13b41e2012-10-12 23:32:00 +00002220 }
2221
Matt Arsenault250024f2016-06-08 01:56:42 +00002222 bool initFeatureMap(llvm::StringMap<bool> &Features,
2223 DiagnosticsEngine &Diags, StringRef CPU,
2224 const std::vector<std::string> &FeatureVec) const override;
2225
Yaxun Liu2c17e822016-08-09 19:43:38 +00002226 void adjustTargetOptions(const CodeGenOptions &CGOpts,
2227 TargetOptions &TargetOpts) const override {
Yaxun Liu2c17e822016-08-09 19:43:38 +00002228 bool hasFP32Denormals = false;
2229 bool hasFP64Denormals = false;
2230 for (auto &I : TargetOpts.FeaturesAsWritten) {
2231 if (I == "+fp32-denormals" || I == "-fp32-denormals")
2232 hasFP32Denormals = true;
Matt Arsenault09cca092017-01-23 22:31:14 +00002233 if (I == "+fp64-fp16-denormals" || I == "-fp64-fp16-denormals")
Yaxun Liu2c17e822016-08-09 19:43:38 +00002234 hasFP64Denormals = true;
2235 }
2236 if (!hasFP32Denormals)
Konstantin Zhuravlyove668b1c2017-04-14 05:33:57 +00002237 TargetOpts.Features.push_back(
2238 (Twine(hasFullSpeedFMAF32(TargetOpts.CPU) &&
Yaxun Liud3e85b92016-09-13 17:37:09 +00002239 !CGOpts.FlushDenorm ? '+' : '-') + Twine("fp32-denormals")).str());
Matt Arsenault09cca092017-01-23 22:31:14 +00002240 // Always do not flush fp64 or fp16 denorms.
Yaxun Liu2c17e822016-08-09 19:43:38 +00002241 if (!hasFP64Denormals && hasFP64)
Matt Arsenault09cca092017-01-23 22:31:14 +00002242 TargetOpts.Features.push_back("+fp64-fp16-denormals");
Yaxun Liu2c17e822016-08-09 19:43:38 +00002243 }
2244
Craig Topper6c03a542015-10-19 04:51:35 +00002245 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
2246 return llvm::makeArrayRef(BuiltinInfo,
2247 clang::AMDGPU::LastTSBuiltin - Builtin::FirstTSBuiltin);
Eli Friedmand13b41e2012-10-12 23:32:00 +00002248 }
2249
Craig Topper3164f332014-03-11 03:39:26 +00002250 void getTargetDefines(const LangOptions &Opts,
2251 MacroBuilder &Builder) const override {
Matt Arsenault5e020b22016-02-27 09:06:26 +00002252 if (getTriple().getArch() == llvm::Triple::amdgcn)
2253 Builder.defineMacro("__AMDGCN__");
2254 else
2255 Builder.defineMacro("__R600__");
2256
Jan Veselyeebeaea2015-05-04 19:53:36 +00002257 if (hasFMAF)
2258 Builder.defineMacro("__HAS_FMAF__");
2259 if (hasLDEXPF)
2260 Builder.defineMacro("__HAS_LDEXPF__");
Jan Vesely211ba782016-06-17 02:25:03 +00002261 if (hasFP64)
2262 Builder.defineMacro("__HAS_FP64__");
Eli Friedmand13b41e2012-10-12 23:32:00 +00002263 }
2264
Craig Topper3164f332014-03-11 03:39:26 +00002265 BuiltinVaListKind getBuiltinVaListKind() const override {
Eli Friedmand13b41e2012-10-12 23:32:00 +00002266 return TargetInfo::CharPtrBuiltinVaList;
2267 }
2268
Matt Arsenault250024f2016-06-08 01:56:42 +00002269 static GPUKind parseR600Name(StringRef Name) {
2270 return llvm::StringSwitch<GPUKind>(Name)
Tom Stellardc74b1e02013-03-04 17:40:53 +00002271 .Case("r600" , GK_R600)
2272 .Case("rv610", GK_R600)
2273 .Case("rv620", GK_R600)
2274 .Case("rv630", GK_R600)
2275 .Case("rv635", GK_R600)
2276 .Case("rs780", GK_R600)
2277 .Case("rs880", GK_R600)
2278 .Case("rv670", GK_R600_DOUBLE_OPS)
2279 .Case("rv710", GK_R700)
2280 .Case("rv730", GK_R700)
2281 .Case("rv740", GK_R700_DOUBLE_OPS)
2282 .Case("rv770", GK_R700_DOUBLE_OPS)
2283 .Case("palm", GK_EVERGREEN)
2284 .Case("cedar", GK_EVERGREEN)
2285 .Case("sumo", GK_EVERGREEN)
2286 .Case("sumo2", GK_EVERGREEN)
2287 .Case("redwood", GK_EVERGREEN)
2288 .Case("juniper", GK_EVERGREEN)
2289 .Case("hemlock", GK_EVERGREEN_DOUBLE_OPS)
2290 .Case("cypress", GK_EVERGREEN_DOUBLE_OPS)
2291 .Case("barts", GK_NORTHERN_ISLANDS)
2292 .Case("turks", GK_NORTHERN_ISLANDS)
2293 .Case("caicos", GK_NORTHERN_ISLANDS)
2294 .Case("cayman", GK_CAYMAN)
2295 .Case("aruba", GK_CAYMAN)
Matt Arsenault250024f2016-06-08 01:56:42 +00002296 .Default(GK_NONE);
2297 }
2298
2299 static GPUKind parseAMDGCNName(StringRef Name) {
2300 return llvm::StringSwitch<GPUKind>(Name)
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002301 .Case("tahiti", GK_GFX6)
2302 .Case("pitcairn", GK_GFX6)
2303 .Case("verde", GK_GFX6)
2304 .Case("oland", GK_GFX6)
2305 .Case("hainan", GK_GFX6)
2306 .Case("bonaire", GK_GFX7)
2307 .Case("kabini", GK_GFX7)
2308 .Case("kaveri", GK_GFX7)
2309 .Case("hawaii", GK_GFX7)
2310 .Case("mullins", GK_GFX7)
Yaxun Liue59a0bc2016-10-26 16:40:21 +00002311 .Case("gfx700", GK_GFX7)
2312 .Case("gfx701", GK_GFX7)
2313 .Case("gfx702", GK_GFX7)
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002314 .Case("tonga", GK_GFX8)
2315 .Case("iceland", GK_GFX8)
2316 .Case("carrizo", GK_GFX8)
2317 .Case("fiji", GK_GFX8)
2318 .Case("stoney", GK_GFX8)
2319 .Case("polaris10", GK_GFX8)
2320 .Case("polaris11", GK_GFX8)
Yaxun Liue59a0bc2016-10-26 16:40:21 +00002321 .Case("gfx800", GK_GFX8)
2322 .Case("gfx801", GK_GFX8)
2323 .Case("gfx802", GK_GFX8)
2324 .Case("gfx803", GK_GFX8)
2325 .Case("gfx804", GK_GFX8)
2326 .Case("gfx810", GK_GFX8)
Matt Arsenaulteb952fd2017-02-18 19:02:41 +00002327 .Case("gfx900", GK_GFX9)
2328 .Case("gfx901", GK_GFX9)
Tom Stellardc74b1e02013-03-04 17:40:53 +00002329 .Default(GK_NONE);
Matt Arsenault250024f2016-06-08 01:56:42 +00002330 }
Tom Stellardc74b1e02013-03-04 17:40:53 +00002331
Matt Arsenault250024f2016-06-08 01:56:42 +00002332 bool setCPU(const std::string &Name) override {
2333 if (getTriple().getArch() == llvm::Triple::amdgcn)
2334 GPU = parseAMDGCNName(Name);
2335 else
2336 GPU = parseR600Name(Name);
Tom Stellardc74b1e02013-03-04 17:40:53 +00002337
Matt Arsenault250024f2016-06-08 01:56:42 +00002338 return GPU != GK_NONE;
Tom Stellardc74b1e02013-03-04 17:40:53 +00002339 }
Yaxun Liu39cf40f2016-05-16 17:06:34 +00002340
Jan Vesely211ba782016-06-17 02:25:03 +00002341 void setSupportedOpenCLOpts() override {
2342 auto &Opts = getSupportedOpenCLOpts();
Yaxun Liu5b746652016-12-18 05:18:55 +00002343 Opts.support("cl_clang_storage_class_specifiers");
2344 Opts.support("cl_khr_icd");
Yaxun Liu39cf40f2016-05-16 17:06:34 +00002345
Jan Vesely211ba782016-06-17 02:25:03 +00002346 if (hasFP64)
Yaxun Liu5b746652016-12-18 05:18:55 +00002347 Opts.support("cl_khr_fp64");
Jan Vesely211ba782016-06-17 02:25:03 +00002348 if (GPU >= GK_EVERGREEN) {
Yaxun Liu5b746652016-12-18 05:18:55 +00002349 Opts.support("cl_khr_byte_addressable_store");
2350 Opts.support("cl_khr_global_int32_base_atomics");
2351 Opts.support("cl_khr_global_int32_extended_atomics");
2352 Opts.support("cl_khr_local_int32_base_atomics");
2353 Opts.support("cl_khr_local_int32_extended_atomics");
Jan Vesely211ba782016-06-17 02:25:03 +00002354 }
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002355 if (GPU >= GK_GFX6) {
Yaxun Liu5b746652016-12-18 05:18:55 +00002356 Opts.support("cl_khr_fp16");
2357 Opts.support("cl_khr_int64_base_atomics");
2358 Opts.support("cl_khr_int64_extended_atomics");
2359 Opts.support("cl_khr_mipmap_image");
2360 Opts.support("cl_khr_subgroups");
2361 Opts.support("cl_khr_3d_image_writes");
2362 Opts.support("cl_amd_media_ops");
2363 Opts.support("cl_amd_media_ops2");
Jan Vesely211ba782016-06-17 02:25:03 +00002364 }
Yaxun Liu39cf40f2016-05-16 17:06:34 +00002365 }
Nikolay Haustov8c6538b2016-06-30 09:06:33 +00002366
Yaxun Liu99444cb2016-08-03 20:38:06 +00002367 LangAS::ID getOpenCLImageAddrSpace() const override {
2368 return LangAS::opencl_constant;
2369 }
2370
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00002371 /// \returns Target specific vtbl ptr address space.
2372 unsigned getVtblPtrAddressSpace() const override {
2373 // \todo: We currently have address spaces defined in AMDGPU Backend. It
2374 // would be nice if we could use it here instead of using bare numbers (same
2375 // applies to getDWARFAddressSpace).
2376 return 2; // constant.
2377 }
2378
2379 /// \returns If a target requires an address within a target specific address
2380 /// space \p AddressSpace to be converted in order to be used, then return the
2381 /// corresponding target specific DWARF address space.
2382 ///
2383 /// \returns Otherwise return None and no conversion will be emitted in the
2384 /// DWARF.
2385 Optional<unsigned> getDWARFAddressSpace(
2386 unsigned AddressSpace) const override {
Yaxun Liu3464f922017-03-25 03:46:25 +00002387 const unsigned DWARF_Private = 1;
2388 const unsigned DWARF_Local = 2;
2389 if (AddressSpace == AS.Private) {
2390 return DWARF_Private;
2391 } else if (AddressSpace == AS.Local) {
2392 return DWARF_Local;
2393 } else {
Konstantin Zhuravlyovd1ba16e2017-03-08 23:56:48 +00002394 return None;
2395 }
2396 }
2397
Nikolay Haustov8c6538b2016-06-30 09:06:33 +00002398 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
2399 switch (CC) {
2400 default:
2401 return CCCR_Warning;
2402 case CC_C:
2403 case CC_OpenCLKernel:
2404 return CCCR_OK;
2405 }
2406 }
Yaxun Liu402804b2016-12-15 08:09:08 +00002407
2408 // In amdgcn target the null pointer in global, constant, and generic
2409 // address space has value 0 but in private and local address space has
2410 // value ~0.
2411 uint64_t getNullPointerValue(unsigned AS) const override {
Matt Arsenaultbf5e3e42017-03-13 19:47:53 +00002412 return AS == LangAS::opencl_local ? ~0 : 0;
Yaxun Liu402804b2016-12-15 08:09:08 +00002413 }
Eli Friedmand13b41e2012-10-12 23:32:00 +00002414};
2415
Matt Arsenault3ea39f92015-06-19 17:54:10 +00002416const Builtin::Info AMDGPUTargetInfo::BuiltinInfo[] = {
Matt Arsenault56f008d2014-06-24 20:45:01 +00002417#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00002418 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Matt Arsenault250024f2016-06-08 01:56:42 +00002419#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
2420 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Matt Arsenault3ea39f92015-06-19 17:54:10 +00002421#include "clang/Basic/BuiltinsAMDGPU.def"
Matt Arsenault56f008d2014-06-24 20:45:01 +00002422};
Matt Arsenault3ea39f92015-06-19 17:54:10 +00002423const char * const AMDGPUTargetInfo::GCCRegNames[] = {
Tom Stellard7b1059b2015-04-14 14:36:56 +00002424 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
2425 "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
2426 "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23",
2427 "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31",
2428 "v32", "v33", "v34", "v35", "v36", "v37", "v38", "v39",
2429 "v40", "v41", "v42", "v43", "v44", "v45", "v46", "v47",
2430 "v48", "v49", "v50", "v51", "v52", "v53", "v54", "v55",
2431 "v56", "v57", "v58", "v59", "v60", "v61", "v62", "v63",
2432 "v64", "v65", "v66", "v67", "v68", "v69", "v70", "v71",
2433 "v72", "v73", "v74", "v75", "v76", "v77", "v78", "v79",
2434 "v80", "v81", "v82", "v83", "v84", "v85", "v86", "v87",
2435 "v88", "v89", "v90", "v91", "v92", "v93", "v94", "v95",
2436 "v96", "v97", "v98", "v99", "v100", "v101", "v102", "v103",
2437 "v104", "v105", "v106", "v107", "v108", "v109", "v110", "v111",
2438 "v112", "v113", "v114", "v115", "v116", "v117", "v118", "v119",
2439 "v120", "v121", "v122", "v123", "v124", "v125", "v126", "v127",
2440 "v128", "v129", "v130", "v131", "v132", "v133", "v134", "v135",
2441 "v136", "v137", "v138", "v139", "v140", "v141", "v142", "v143",
2442 "v144", "v145", "v146", "v147", "v148", "v149", "v150", "v151",
2443 "v152", "v153", "v154", "v155", "v156", "v157", "v158", "v159",
2444 "v160", "v161", "v162", "v163", "v164", "v165", "v166", "v167",
2445 "v168", "v169", "v170", "v171", "v172", "v173", "v174", "v175",
2446 "v176", "v177", "v178", "v179", "v180", "v181", "v182", "v183",
2447 "v184", "v185", "v186", "v187", "v188", "v189", "v190", "v191",
2448 "v192", "v193", "v194", "v195", "v196", "v197", "v198", "v199",
2449 "v200", "v201", "v202", "v203", "v204", "v205", "v206", "v207",
2450 "v208", "v209", "v210", "v211", "v212", "v213", "v214", "v215",
2451 "v216", "v217", "v218", "v219", "v220", "v221", "v222", "v223",
2452 "v224", "v225", "v226", "v227", "v228", "v229", "v230", "v231",
2453 "v232", "v233", "v234", "v235", "v236", "v237", "v238", "v239",
2454 "v240", "v241", "v242", "v243", "v244", "v245", "v246", "v247",
2455 "v248", "v249", "v250", "v251", "v252", "v253", "v254", "v255",
2456 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
2457 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
2458 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
2459 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
2460 "s32", "s33", "s34", "s35", "s36", "s37", "s38", "s39",
2461 "s40", "s41", "s42", "s43", "s44", "s45", "s46", "s47",
2462 "s48", "s49", "s50", "s51", "s52", "s53", "s54", "s55",
2463 "s56", "s57", "s58", "s59", "s60", "s61", "s62", "s63",
2464 "s64", "s65", "s66", "s67", "s68", "s69", "s70", "s71",
2465 "s72", "s73", "s74", "s75", "s76", "s77", "s78", "s79",
2466 "s80", "s81", "s82", "s83", "s84", "s85", "s86", "s87",
2467 "s88", "s89", "s90", "s91", "s92", "s93", "s94", "s95",
2468 "s96", "s97", "s98", "s99", "s100", "s101", "s102", "s103",
2469 "s104", "s105", "s106", "s107", "s108", "s109", "s110", "s111",
2470 "s112", "s113", "s114", "s115", "s116", "s117", "s118", "s119",
Etienne Bergerone8ae26f2016-03-24 18:29:24 +00002471 "s120", "s121", "s122", "s123", "s124", "s125", "s126", "s127",
Matt Arsenaultb015d622016-02-27 09:06:22 +00002472 "exec", "vcc", "scc", "m0", "flat_scratch", "exec_lo", "exec_hi",
2473 "vcc_lo", "vcc_hi", "flat_scratch_lo", "flat_scratch_hi"
Tom Stellard7b1059b2015-04-14 14:36:56 +00002474};
2475
Craig Topperf054e3a2015-10-19 03:52:27 +00002476ArrayRef<const char *> AMDGPUTargetInfo::getGCCRegNames() const {
2477 return llvm::makeArrayRef(GCCRegNames);
Tom Stellard7b1059b2015-04-14 14:36:56 +00002478}
Matt Arsenault56f008d2014-06-24 20:45:01 +00002479
Matt Arsenault250024f2016-06-08 01:56:42 +00002480bool AMDGPUTargetInfo::initFeatureMap(
2481 llvm::StringMap<bool> &Features,
2482 DiagnosticsEngine &Diags, StringRef CPU,
2483 const std::vector<std::string> &FeatureVec) const {
2484
2485 // XXX - What does the member GPU mean if device name string passed here?
2486 if (getTriple().getArch() == llvm::Triple::amdgcn) {
2487 if (CPU.empty())
2488 CPU = "tahiti";
2489
2490 switch (parseAMDGCNName(CPU)) {
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002491 case GK_GFX6:
2492 case GK_GFX7:
Matt Arsenault250024f2016-06-08 01:56:42 +00002493 break;
2494
Matt Arsenaulta0c6dca2017-02-22 20:55:59 +00002495 case GK_GFX9:
2496 Features["gfx9-insts"] = true;
2497 LLVM_FALLTHROUGH;
Niels Ole Salscheiderb28cc452016-09-03 07:13:54 +00002498 case GK_GFX8:
Matt Arsenault250024f2016-06-08 01:56:42 +00002499 Features["s-memrealtime"] = true;
2500 Features["16-bit-insts"] = true;
Yaxun Liu4d867992017-03-10 01:30:46 +00002501 Features["dpp"] = true;
Matt Arsenault250024f2016-06-08 01:56:42 +00002502 break;
2503
2504 case GK_NONE:
2505 return false;
2506 default:
2507 llvm_unreachable("unhandled subtarget");
2508 }
2509 } else {
2510 if (CPU.empty())
2511 CPU = "r600";
2512
2513 switch (parseR600Name(CPU)) {
2514 case GK_R600:
2515 case GK_R700:
2516 case GK_EVERGREEN:
2517 case GK_NORTHERN_ISLANDS:
2518 break;
2519 case GK_R600_DOUBLE_OPS:
2520 case GK_R700_DOUBLE_OPS:
2521 case GK_EVERGREEN_DOUBLE_OPS:
2522 case GK_CAYMAN:
2523 Features["fp64"] = true;
2524 break;
2525 case GK_NONE:
2526 return false;
2527 default:
2528 llvm_unreachable("unhandled subtarget");
2529 }
2530 }
2531
2532 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeatureVec);
2533}
2534
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00002535const Builtin::Info BuiltinInfoX86[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00002536#define BUILTIN(ID, TYPE, ATTRS) \
2537 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Eric Christopherb6dfd942015-08-06 22:11:54 +00002538#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
Craig Topper07d3b622015-08-07 05:14:44 +00002539 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Albert Gutowski727ab8a2016-09-14 21:19:43 +00002540#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
2541 { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
Chris Lattner5abdec72009-06-14 01:05:48 +00002542#include "clang/Basic/BuiltinsX86.def"
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00002543
2544#define BUILTIN(ID, TYPE, ATTRS) \
2545 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Albert Gutowski0fd6e962016-10-12 17:28:44 +00002546#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
2547 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00002548#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
2549 { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
2550#include "clang/Basic/BuiltinsX86_64.def"
Eli Friedman3fd920a2008-08-20 02:34:37 +00002551};
Eli Friedmanb5366062008-05-20 14:21:01 +00002552
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00002553
Nuno Lopescfca1f02009-12-23 17:49:57 +00002554static const char* const GCCRegNames[] = {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002555 "ax", "dx", "cx", "bx", "si", "di", "bp", "sp",
2556 "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)",
Eric Christopher0c912c52011-07-07 22:55:26 +00002557 "argp", "flags", "fpcr", "fpsr", "dirflag", "frame",
Eli Friedman3fd920a2008-08-20 02:34:37 +00002558 "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
2559 "mm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
2560 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
Eric Christophercdd36352011-06-21 00:05:20 +00002561 "xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
Eric Christopheraf643102011-12-02 02:12:16 +00002562 "ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
2563 "ymm8", "ymm9", "ymm10", "ymm11", "ymm12", "ymm13", "ymm14", "ymm15",
Marina Yatsina41c45fa2016-02-03 11:32:08 +00002564 "xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23",
2565 "xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31",
2566 "ymm16", "ymm17", "ymm18", "ymm19", "ymm20", "ymm21", "ymm22", "ymm23",
2567 "ymm24", "ymm25", "ymm26", "ymm27", "ymm28", "ymm29", "ymm30", "ymm31",
2568 "zmm0", "zmm1", "zmm2", "zmm3", "zmm4", "zmm5", "zmm6", "zmm7",
2569 "zmm8", "zmm9", "zmm10", "zmm11", "zmm12", "zmm13", "zmm14", "zmm15",
2570 "zmm16", "zmm17", "zmm18", "zmm19", "zmm20", "zmm21", "zmm22", "zmm23",
2571 "zmm24", "zmm25", "zmm26", "zmm27", "zmm28", "zmm29", "zmm30", "zmm31",
Michael Zuckerman15604b92016-10-31 14:16:57 +00002572 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7",
Eli Friedman3fd920a2008-08-20 02:34:37 +00002573};
2574
Eric Christophercdd36352011-06-21 00:05:20 +00002575const TargetInfo::AddlRegName AddlRegNames[] = {
2576 { { "al", "ah", "eax", "rax" }, 0 },
2577 { { "bl", "bh", "ebx", "rbx" }, 3 },
2578 { { "cl", "ch", "ecx", "rcx" }, 2 },
2579 { { "dl", "dh", "edx", "rdx" }, 1 },
2580 { { "esi", "rsi" }, 4 },
2581 { { "edi", "rdi" }, 5 },
2582 { { "esp", "rsp" }, 7 },
2583 { { "ebp", "rbp" }, 6 },
Alexey Bataeva7ab1b42015-09-04 03:42:23 +00002584 { { "r8d", "r8w", "r8b" }, 38 },
2585 { { "r9d", "r9w", "r9b" }, 39 },
2586 { { "r10d", "r10w", "r10b" }, 40 },
2587 { { "r11d", "r11w", "r11b" }, 41 },
2588 { { "r12d", "r12w", "r12b" }, 42 },
2589 { { "r13d", "r13w", "r13b" }, 43 },
2590 { { "r14d", "r14w", "r14b" }, 44 },
2591 { { "r15d", "r15w", "r15b" }, 45 },
Eli Friedman3fd920a2008-08-20 02:34:37 +00002592};
2593
2594// X86 target abstract base class; x86-32 and x86-64 are very close, so
2595// most of the implementation can be shared.
2596class X86TargetInfo : public TargetInfo {
Chris Lattner96e43572009-03-02 22:40:39 +00002597 enum X86SSEEnum {
Craig Topper9c4d17f2013-08-21 03:59:22 +00002598 NoSSE, SSE1, SSE2, SSE3, SSSE3, SSE41, SSE42, AVX, AVX2, AVX512F
Craig Topper543f3bd2015-10-14 23:47:57 +00002599 } SSELevel = NoSSE;
Eli Friedman33465822011-07-08 23:31:17 +00002600 enum MMX3DNowEnum {
2601 NoMMX3DNow, MMX, AMD3DNow, AMD3DNowAthlon
Craig Topper543f3bd2015-10-14 23:47:57 +00002602 } MMX3DNowLevel = NoMMX3DNow;
Rafael Espindolae62e2792013-08-20 13:44:29 +00002603 enum XOPEnum {
2604 NoXOP,
2605 SSE4A,
2606 FMA4,
2607 XOP
Craig Topper543f3bd2015-10-14 23:47:57 +00002608 } XOPLevel = NoXOP;
Anders Carlssone437c682010-01-27 03:47:49 +00002609
Craig Topper543f3bd2015-10-14 23:47:57 +00002610 bool HasAES = false;
2611 bool HasPCLMUL = false;
2612 bool HasLZCNT = false;
2613 bool HasRDRND = false;
2614 bool HasFSGSBASE = false;
2615 bool HasBMI = false;
2616 bool HasBMI2 = false;
2617 bool HasPOPCNT = false;
2618 bool HasRTM = false;
2619 bool HasPRFCHW = false;
2620 bool HasRDSEED = false;
2621 bool HasADX = false;
2622 bool HasTBM = false;
Simon Pilgrim35113482017-05-08 12:09:45 +00002623 bool HasLWP = false;
Craig Topper543f3bd2015-10-14 23:47:57 +00002624 bool HasFMA = false;
2625 bool HasF16C = false;
2626 bool HasAVX512CD = false;
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00002627 bool HasAVX512VPOPCNTDQ = false;
Craig Topper543f3bd2015-10-14 23:47:57 +00002628 bool HasAVX512ER = false;
2629 bool HasAVX512PF = false;
2630 bool HasAVX512DQ = false;
2631 bool HasAVX512BW = false;
2632 bool HasAVX512VL = false;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002633 bool HasAVX512VBMI = false;
2634 bool HasAVX512IFMA = false;
Craig Topper543f3bd2015-10-14 23:47:57 +00002635 bool HasSHA = false;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002636 bool HasMPX = false;
2637 bool HasSGX = false;
Craig Topper543f3bd2015-10-14 23:47:57 +00002638 bool HasCX16 = false;
Craig Toppere33f51f2015-10-16 06:22:36 +00002639 bool HasFXSR = false;
Craig Topperda9fe562015-10-15 05:23:38 +00002640 bool HasXSAVE = false;
2641 bool HasXSAVEOPT = false;
2642 bool HasXSAVEC = false;
2643 bool HasXSAVES = false;
Ashutosh Nema51c9dd02016-05-18 11:56:23 +00002644 bool HasMWAITX = false;
Craig Topper45742262017-02-09 06:10:14 +00002645 bool HasCLZERO = false;
Asaf Badouha9d1e182015-12-31 14:14:07 +00002646 bool HasPKU = false;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002647 bool HasCLFLUSHOPT = false;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002648 bool HasCLWB = false;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002649 bool HasMOVBE = false;
2650 bool HasPREFETCHWT1 = false;
Bruno Cardoso Lopesd81ef1c2010-08-04 22:29:13 +00002651
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002652 /// \brief Enumeration of all of the X86 CPUs supported by Clang.
2653 ///
2654 /// Each enumeration represents a particular CPU supported by Clang. These
2655 /// loosely correspond to the options passed to '-march' or '-mtune' flags.
2656 enum CPUKind {
2657 CK_Generic,
2658
2659 /// \name i386
2660 /// i386-generation processors.
2661 //@{
2662 CK_i386,
2663 //@}
2664
2665 /// \name i486
2666 /// i486-generation processors.
2667 //@{
2668 CK_i486,
2669 CK_WinChipC6,
2670 CK_WinChip2,
2671 CK_C3,
2672 //@}
2673
2674 /// \name i586
2675 /// i586-generation processors, P5 microarchitecture based.
2676 //@{
2677 CK_i586,
2678 CK_Pentium,
2679 CK_PentiumMMX,
2680 //@}
2681
2682 /// \name i686
2683 /// i686-generation processors, P6 / Pentium M microarchitecture based.
2684 //@{
2685 CK_i686,
2686 CK_PentiumPro,
2687 CK_Pentium2,
2688 CK_Pentium3,
2689 CK_Pentium3M,
2690 CK_PentiumM,
2691 CK_C3_2,
2692
2693 /// This enumerator is a bit odd, as GCC no longer accepts -march=yonah.
2694 /// Clang however has some logic to suport this.
2695 // FIXME: Warn, deprecate, and potentially remove this.
2696 CK_Yonah,
2697 //@}
2698
2699 /// \name Netburst
Chandler Carruth3270e262011-09-28 18:17:30 +00002700 /// Netburst microarchitecture based processors.
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002701 //@{
2702 CK_Pentium4,
2703 CK_Pentium4M,
2704 CK_Prescott,
2705 CK_Nocona,
2706 //@}
2707
2708 /// \name Core
2709 /// Core microarchitecture based processors.
2710 //@{
2711 CK_Core2,
2712
2713 /// This enumerator, like \see CK_Yonah, is a bit odd. It is another
2714 /// codename which GCC no longer accepts as an option to -march, but Clang
2715 /// has some logic for recognizing it.
2716 // FIXME: Warn, deprecate, and potentially remove this.
2717 CK_Penryn,
2718 //@}
2719
2720 /// \name Atom
2721 /// Atom processors
2722 //@{
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002723 CK_Bonnell,
Preston Gurda3c58c02013-09-13 19:27:17 +00002724 CK_Silvermont,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002725 //@}
2726
2727 /// \name Nehalem
2728 /// Nehalem microarchitecture based processors.
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002729 CK_Nehalem,
2730
2731 /// \name Westmere
2732 /// Westmere microarchitecture based processors.
2733 CK_Westmere,
2734
2735 /// \name Sandy Bridge
2736 /// Sandy Bridge microarchitecture based processors.
2737 CK_SandyBridge,
2738
2739 /// \name Ivy Bridge
2740 /// Ivy Bridge microarchitecture based processors.
2741 CK_IvyBridge,
2742
2743 /// \name Haswell
2744 /// Haswell microarchitecture based processors.
2745 CK_Haswell,
2746
2747 /// \name Broadwell
2748 /// Broadwell microarchitecture based processors.
Robert Khasanov50e6f582014-09-19 09:53:48 +00002749 CK_Broadwell,
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00002750
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002751 /// \name Skylake Client
2752 /// Skylake client microarchitecture based processors.
2753 CK_SkylakeClient,
2754
2755 /// \name Skylake Server
2756 /// Skylake server microarchitecture based processors.
2757 CK_SkylakeServer,
2758
2759 /// \name Cannonlake Client
2760 /// Cannonlake client microarchitecture based processors.
2761 CK_Cannonlake,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002762
Craig Topper449314e2013-08-20 07:09:39 +00002763 /// \name Knights Landing
2764 /// Knights Landing processor.
2765 CK_KNL,
2766
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00002767 /// \name Lakemont
2768 /// Lakemont microarchitecture based processors.
2769 CK_Lakemont,
2770
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002771 /// \name K6
2772 /// K6 architecture processors.
2773 //@{
2774 CK_K6,
2775 CK_K6_2,
2776 CK_K6_3,
2777 //@}
2778
2779 /// \name K7
2780 /// K7 architecture processors.
2781 //@{
2782 CK_Athlon,
2783 CK_AthlonThunderbird,
2784 CK_Athlon4,
2785 CK_AthlonXP,
2786 CK_AthlonMP,
2787 //@}
2788
2789 /// \name K8
2790 /// K8 architecture processors.
2791 //@{
2792 CK_Athlon64,
2793 CK_Athlon64SSE3,
2794 CK_AthlonFX,
2795 CK_K8,
Chandler Carruth212334f2011-09-28 08:55:37 +00002796 CK_K8SSE3,
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002797 CK_Opteron,
2798 CK_OpteronSSE3,
Roman Divacky43eb6f82011-10-30 07:48:46 +00002799 CK_AMDFAM10,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002800 //@}
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002801
Benjamin Kramer569f2152012-01-10 11:50:18 +00002802 /// \name Bobcat
2803 /// Bobcat architecture processors.
2804 //@{
2805 CK_BTVER1,
Benjamin Kramer914d7e02013-05-03 10:47:15 +00002806 CK_BTVER2,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002807 //@}
2808
2809 /// \name Bulldozer
2810 /// Bulldozer architecture processors.
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002811 //@{
2812 CK_BDVER1,
2813 CK_BDVER2,
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00002814 CK_BDVER3,
Benjamin Kramer56c58222014-05-02 15:47:51 +00002815 CK_BDVER4,
Benjamin Kramer569f2152012-01-10 11:50:18 +00002816 //@}
Benjamin Kramer6bd51592011-12-01 18:23:59 +00002817
Craig Topperc45744a2017-01-10 06:02:12 +00002818 /// \name zen
2819 /// Zen architecture processors.
2820 //@{
2821 CK_ZNVER1,
2822 //@}
2823
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002824 /// This specification is deprecated and will be removed in the future.
2825 /// Users should prefer \see CK_K8.
2826 // FIXME: Warn on this when the CPU is set to it.
Saleem Abdulrasoolcb29c1a2014-11-17 18:40:15 +00002827 //@{
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002828 CK_x86_64,
2829 //@}
2830
2831 /// \name Geode
2832 /// Geode processors.
2833 //@{
2834 CK_Geode
2835 //@}
Craig Topper543f3bd2015-10-14 23:47:57 +00002836 } CPU = CK_Generic;
Chandler Carruth3ac7aea2011-09-28 08:55:34 +00002837
Eric Christopherc50738f2015-08-27 00:05:50 +00002838 CPUKind getCPUKind(StringRef CPU) const {
Eric Christopherb39e44b2015-08-26 23:42:18 +00002839 return llvm::StringSwitch<CPUKind>(CPU)
2840 .Case("i386", CK_i386)
2841 .Case("i486", CK_i486)
2842 .Case("winchip-c6", CK_WinChipC6)
2843 .Case("winchip2", CK_WinChip2)
2844 .Case("c3", CK_C3)
2845 .Case("i586", CK_i586)
2846 .Case("pentium", CK_Pentium)
2847 .Case("pentium-mmx", CK_PentiumMMX)
2848 .Case("i686", CK_i686)
2849 .Case("pentiumpro", CK_PentiumPro)
2850 .Case("pentium2", CK_Pentium2)
2851 .Case("pentium3", CK_Pentium3)
2852 .Case("pentium3m", CK_Pentium3M)
2853 .Case("pentium-m", CK_PentiumM)
2854 .Case("c3-2", CK_C3_2)
2855 .Case("yonah", CK_Yonah)
2856 .Case("pentium4", CK_Pentium4)
2857 .Case("pentium4m", CK_Pentium4M)
2858 .Case("prescott", CK_Prescott)
2859 .Case("nocona", CK_Nocona)
2860 .Case("core2", CK_Core2)
2861 .Case("penryn", CK_Penryn)
2862 .Case("bonnell", CK_Bonnell)
2863 .Case("atom", CK_Bonnell) // Legacy name.
2864 .Case("silvermont", CK_Silvermont)
2865 .Case("slm", CK_Silvermont) // Legacy name.
2866 .Case("nehalem", CK_Nehalem)
2867 .Case("corei7", CK_Nehalem) // Legacy name.
2868 .Case("westmere", CK_Westmere)
2869 .Case("sandybridge", CK_SandyBridge)
2870 .Case("corei7-avx", CK_SandyBridge) // Legacy name.
2871 .Case("ivybridge", CK_IvyBridge)
2872 .Case("core-avx-i", CK_IvyBridge) // Legacy name.
2873 .Case("haswell", CK_Haswell)
2874 .Case("core-avx2", CK_Haswell) // Legacy name.
2875 .Case("broadwell", CK_Broadwell)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00002876 .Case("skylake", CK_SkylakeClient)
2877 .Case("skylake-avx512", CK_SkylakeServer)
2878 .Case("skx", CK_SkylakeServer) // Legacy name.
2879 .Case("cannonlake", CK_Cannonlake)
Eric Christopherb39e44b2015-08-26 23:42:18 +00002880 .Case("knl", CK_KNL)
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00002881 .Case("lakemont", CK_Lakemont)
Eric Christopherb39e44b2015-08-26 23:42:18 +00002882 .Case("k6", CK_K6)
2883 .Case("k6-2", CK_K6_2)
2884 .Case("k6-3", CK_K6_3)
2885 .Case("athlon", CK_Athlon)
2886 .Case("athlon-tbird", CK_AthlonThunderbird)
2887 .Case("athlon-4", CK_Athlon4)
2888 .Case("athlon-xp", CK_AthlonXP)
2889 .Case("athlon-mp", CK_AthlonMP)
2890 .Case("athlon64", CK_Athlon64)
2891 .Case("athlon64-sse3", CK_Athlon64SSE3)
2892 .Case("athlon-fx", CK_AthlonFX)
2893 .Case("k8", CK_K8)
2894 .Case("k8-sse3", CK_K8SSE3)
2895 .Case("opteron", CK_Opteron)
2896 .Case("opteron-sse3", CK_OpteronSSE3)
2897 .Case("barcelona", CK_AMDFAM10)
2898 .Case("amdfam10", CK_AMDFAM10)
2899 .Case("btver1", CK_BTVER1)
2900 .Case("btver2", CK_BTVER2)
2901 .Case("bdver1", CK_BDVER1)
2902 .Case("bdver2", CK_BDVER2)
2903 .Case("bdver3", CK_BDVER3)
2904 .Case("bdver4", CK_BDVER4)
Craig Topperc45744a2017-01-10 06:02:12 +00002905 .Case("znver1", CK_ZNVER1)
Eric Christopherb39e44b2015-08-26 23:42:18 +00002906 .Case("x86-64", CK_x86_64)
2907 .Case("geode", CK_Geode)
2908 .Default(CK_Generic);
2909 }
2910
Rafael Espindolaeb265472013-08-21 21:59:03 +00002911 enum FPMathKind {
2912 FP_Default,
2913 FP_SSE,
2914 FP_387
Craig Topper543f3bd2015-10-14 23:47:57 +00002915 } FPMath = FP_Default;
Rafael Espindolaeb265472013-08-21 21:59:03 +00002916
Eli Friedman3fd920a2008-08-20 02:34:37 +00002917public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00002918 X86TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
2919 : TargetInfo(Triple) {
Stephan Bergmann17c7f702016-12-14 11:57:17 +00002920 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
Chris Lattner1f5ad112006-10-14 18:32:12 +00002921 }
Craig Topper3164f332014-03-11 03:39:26 +00002922 unsigned getFloatEvalMethod() const override {
Benjamin Kramercf501472011-12-28 15:47:06 +00002923 // X87 evaluates with 80 bits "long double" precision.
2924 return SSELevel == NoSSE ? 2 : 0;
2925 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002926 ArrayRef<const char *> getGCCRegNames() const override {
2927 return llvm::makeArrayRef(GCCRegNames);
Anders Carlsson5fa3f342007-11-24 23:38:12 +00002928 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002929 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
2930 return None;
Eric Christophercdd36352011-06-21 00:05:20 +00002931 }
Craig Topperf054e3a2015-10-19 03:52:27 +00002932 ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override {
2933 return llvm::makeArrayRef(AddlRegNames);
Anders Carlssona7408e72007-10-13 00:45:48 +00002934 }
Eric Christopherd9832702015-06-29 21:00:05 +00002935 bool validateCpuSupports(StringRef Name) const override;
Craig Topper3164f332014-03-11 03:39:26 +00002936 bool validateAsmConstraint(const char *&Name,
Eric Christopher917e9522014-11-18 22:36:15 +00002937 TargetInfo::ConstraintInfo &info) const override;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002938
Akira Hatanaka8c26ea62015-11-18 00:15:28 +00002939 bool validateGlobalRegisterVariable(StringRef RegName,
2940 unsigned RegSize,
2941 bool &HasSizeMismatch) const override {
2942 // esp and ebp are the only 32-bit registers the x86 backend can currently
2943 // handle.
2944 if (RegName.equals("esp") || RegName.equals("ebp")) {
2945 // Check that the register size is 32-bit.
2946 HasSizeMismatch = RegSize != 32;
2947 return true;
2948 }
2949
2950 return false;
2951 }
2952
Akira Hatanaka974131e2014-09-18 18:17:18 +00002953 bool validateOutputSize(StringRef Constraint, unsigned Size) const override;
2954
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00002955 bool validateInputSize(StringRef Constraint, unsigned Size) const override;
2956
Akira Hatanaka974131e2014-09-18 18:17:18 +00002957 virtual bool validateOperandSize(StringRef Constraint, unsigned Size) const;
2958
Craig Topper3164f332014-03-11 03:39:26 +00002959 std::string convertConstraint(const char *&Constraint) const override;
2960 const char *getClobbers() const override {
Eli Friedman3fd920a2008-08-20 02:34:37 +00002961 return "~{dirflag},~{fpsr},~{flags}";
2962 }
Marina Yatsinac42fd032016-12-26 12:23:42 +00002963
2964 StringRef getConstraintRegister(const StringRef &Constraint,
2965 const StringRef &Expression) const override {
2966 StringRef::iterator I, E;
2967 for (I = Constraint.begin(), E = Constraint.end(); I != E; ++I) {
2968 if (isalpha(*I))
2969 break;
2970 }
2971 if (I == E)
2972 return "";
2973 switch (*I) {
2974 // For the register constraints, return the matching register name
2975 case 'a':
2976 return "ax";
2977 case 'b':
2978 return "bx";
2979 case 'c':
2980 return "cx";
2981 case 'd':
2982 return "dx";
2983 case 'S':
2984 return "si";
2985 case 'D':
2986 return "di";
2987 // In case the constraint is 'r' we need to return Expression
2988 case 'r':
2989 return Expression;
2990 default:
2991 // Default value if there is no constraint for the register
2992 return "";
2993 }
2994 return "";
2995 }
2996
Craig Topper3164f332014-03-11 03:39:26 +00002997 void getTargetDefines(const LangOptions &Opts,
2998 MacroBuilder &Builder) const override;
Craig Topper13f61a62013-09-17 04:12:55 +00002999 static void setSSELevel(llvm::StringMap<bool> &Features, X86SSEEnum Level,
3000 bool Enabled);
3001 static void setMMXLevel(llvm::StringMap<bool> &Features, MMX3DNowEnum Level,
3002 bool Enabled);
3003 static void setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
3004 bool Enabled);
Craig Topper3164f332014-03-11 03:39:26 +00003005 void setFeatureEnabled(llvm::StringMap<bool> &Features,
3006 StringRef Name, bool Enabled) const override {
Craig Topper86d79ef2013-09-17 04:51:29 +00003007 setFeatureEnabledImpl(Features, Name, Enabled);
3008 }
3009 // This exists purely to cut down on the number of virtual calls in
Eric Christopheref1e2952015-08-28 02:13:58 +00003010 // initFeatureMap which calls this repeatedly.
Craig Topper86d79ef2013-09-17 04:51:29 +00003011 static void setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
3012 StringRef Name, bool Enabled);
Eric Christopher8c47b422015-10-09 18:39:55 +00003013 bool
3014 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
3015 StringRef CPU,
3016 const std::vector<std::string> &FeaturesVec) const override;
Craig Topper3164f332014-03-11 03:39:26 +00003017 bool hasFeature(StringRef Feature) const override;
3018 bool handleTargetFeatures(std::vector<std::string> &Features,
3019 DiagnosticsEngine &Diags) override;
Alp Toker4925ba72014-06-07 23:30:42 +00003020 StringRef getABI() const override {
Ahmed Bougacha0b938282015-06-22 21:31:43 +00003021 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX512F)
3022 return "avx512";
Craig Topperd945d502015-10-20 00:00:17 +00003023 if (getTriple().getArch() == llvm::Triple::x86_64 && SSELevel >= AVX)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00003024 return "avx";
Craig Topperd945d502015-10-20 00:00:17 +00003025 if (getTriple().getArch() == llvm::Triple::x86 &&
Derek Schuffc7dd7222012-10-11 15:52:22 +00003026 MMX3DNowLevel == NoMMX3DNow)
Eli Friedmanbfd5add2011-12-02 00:11:43 +00003027 return "no-mmx";
3028 return "";
Eli Friedman33465822011-07-08 23:31:17 +00003029 }
Craig Topper3164f332014-03-11 03:39:26 +00003030 bool setCPU(const std::string &Name) override {
Eric Christopherb39e44b2015-08-26 23:42:18 +00003031 CPU = getCPUKind(Name);
Chandler Carruth212334f2011-09-28 08:55:37 +00003032
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00003033 // Perform any per-CPU checks necessary to determine if this CPU is
3034 // acceptable.
3035 // FIXME: This results in terrible diagnostics. Clang just says the CPU is
3036 // invalid without explaining *why*.
3037 switch (CPU) {
3038 case CK_Generic:
3039 // No processor selected!
3040 return false;
3041
3042 case CK_i386:
3043 case CK_i486:
3044 case CK_WinChipC6:
3045 case CK_WinChip2:
3046 case CK_C3:
3047 case CK_i586:
3048 case CK_Pentium:
3049 case CK_PentiumMMX:
3050 case CK_i686:
3051 case CK_PentiumPro:
3052 case CK_Pentium2:
3053 case CK_Pentium3:
3054 case CK_Pentium3M:
3055 case CK_PentiumM:
3056 case CK_Yonah:
3057 case CK_C3_2:
3058 case CK_Pentium4:
3059 case CK_Pentium4M:
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00003060 case CK_Lakemont:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00003061 case CK_Prescott:
3062 case CK_K6:
3063 case CK_K6_2:
3064 case CK_K6_3:
3065 case CK_Athlon:
3066 case CK_AthlonThunderbird:
3067 case CK_Athlon4:
3068 case CK_AthlonXP:
3069 case CK_AthlonMP:
3070 case CK_Geode:
3071 // Only accept certain architectures when compiling in 32-bit mode.
Derek Schuffc7dd7222012-10-11 15:52:22 +00003072 if (getTriple().getArch() != llvm::Triple::x86)
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00003073 return false;
3074
3075 // Fallthrough
3076 case CK_Nocona:
3077 case CK_Core2:
3078 case CK_Penryn:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003079 case CK_Bonnell:
Preston Gurda3c58c02013-09-13 19:27:17 +00003080 case CK_Silvermont:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003081 case CK_Nehalem:
3082 case CK_Westmere:
3083 case CK_SandyBridge:
3084 case CK_IvyBridge:
3085 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00003086 case CK_Broadwell:
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003087 case CK_SkylakeClient:
3088 case CK_SkylakeServer:
3089 case CK_Cannonlake:
Craig Topper449314e2013-08-20 07:09:39 +00003090 case CK_KNL:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00003091 case CK_Athlon64:
3092 case CK_Athlon64SSE3:
3093 case CK_AthlonFX:
3094 case CK_K8:
3095 case CK_K8SSE3:
3096 case CK_Opteron:
3097 case CK_OpteronSSE3:
Roman Divacky43eb6f82011-10-30 07:48:46 +00003098 case CK_AMDFAM10:
Benjamin Kramer569f2152012-01-10 11:50:18 +00003099 case CK_BTVER1:
Benjamin Kramer914d7e02013-05-03 10:47:15 +00003100 case CK_BTVER2:
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003101 case CK_BDVER1:
3102 case CK_BDVER2:
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00003103 case CK_BDVER3:
Benjamin Kramer56c58222014-05-02 15:47:51 +00003104 case CK_BDVER4:
Craig Topperc45744a2017-01-10 06:02:12 +00003105 case CK_ZNVER1:
Chandler Carruth6e20c2b2011-09-28 09:45:08 +00003106 case CK_x86_64:
3107 return true;
3108 }
Chandler Carruth7d8241c2011-09-28 10:49:06 +00003109 llvm_unreachable("Unhandled CPU kind");
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003110 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003111
Craig Topper3164f332014-03-11 03:39:26 +00003112 bool setFPMath(StringRef Name) override;
Rafael Espindolaeb265472013-08-21 21:59:03 +00003113
Craig Topper3164f332014-03-11 03:39:26 +00003114 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
John McCall477f2bb2016-03-03 06:39:32 +00003115 // Most of the non-ARM calling conventions are i386 conventions.
3116 switch (CC) {
3117 case CC_X86ThisCall:
3118 case CC_X86FastCall:
3119 case CC_X86StdCall:
3120 case CC_X86VectorCall:
Erich Keane757d3172016-11-02 18:29:35 +00003121 case CC_X86RegCall:
John McCall477f2bb2016-03-03 06:39:32 +00003122 case CC_C:
3123 case CC_Swift:
3124 case CC_X86Pascal:
3125 case CC_IntelOclBicc:
3126 return CCCR_OK;
3127 default:
3128 return CCCR_Warning;
3129 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003130 }
3131
Craig Topper3164f332014-03-11 03:39:26 +00003132 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00003133 return MT == CCMT_Member ? CC_X86ThisCall : CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00003134 }
Joerg Sonnenberger27173282015-03-11 23:46:32 +00003135
3136 bool hasSjLjLowering() const override {
3137 return true;
3138 }
Yaxun Liu39cf40f2016-05-16 17:06:34 +00003139
3140 void setSupportedOpenCLOpts() override {
Yaxun Liu5b746652016-12-18 05:18:55 +00003141 getSupportedOpenCLOpts().supportAll();
Yaxun Liu39cf40f2016-05-16 17:06:34 +00003142 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00003143};
Chris Lattnerc25d8a72009-03-02 22:20:04 +00003144
Rafael Espindolaeb265472013-08-21 21:59:03 +00003145bool X86TargetInfo::setFPMath(StringRef Name) {
3146 if (Name == "387") {
3147 FPMath = FP_387;
3148 return true;
3149 }
3150 if (Name == "sse") {
3151 FPMath = FP_SSE;
3152 return true;
3153 }
3154 return false;
3155}
3156
Eric Christopher007b0a02015-08-28 22:32:01 +00003157bool X86TargetInfo::initFeatureMap(
3158 llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
Eric Christopher8c47b422015-10-09 18:39:55 +00003159 const std::vector<std::string> &FeaturesVec) const {
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003160 // FIXME: This *really* should not be here.
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003161 // X86_64 always has SSE2.
Derek Schuffc7dd7222012-10-11 15:52:22 +00003162 if (getTriple().getArch() == llvm::Triple::x86_64)
Craig Topper86d79ef2013-09-17 04:51:29 +00003163 setFeatureEnabledImpl(Features, "sse2", true);
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003164
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00003165 const CPUKind Kind = getCPUKind(CPU);
Andrey Turetskiy5f1cf5f2016-03-23 11:15:10 +00003166
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00003167 // Enable X87 for all X86 processors but Lakemont.
3168 if (Kind != CK_Lakemont)
3169 setFeatureEnabledImpl(Features, "x87", true);
3170
3171 switch (Kind) {
Chandler Carruth212334f2011-09-28 08:55:37 +00003172 case CK_Generic:
3173 case CK_i386:
3174 case CK_i486:
3175 case CK_i586:
3176 case CK_Pentium:
3177 case CK_i686:
3178 case CK_PentiumPro:
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00003179 case CK_Lakemont:
Chandler Carruth212334f2011-09-28 08:55:37 +00003180 break;
3181 case CK_PentiumMMX:
3182 case CK_Pentium2:
Craig Topperdb4dc082014-11-06 05:52:19 +00003183 case CK_K6:
3184 case CK_WinChipC6:
Craig Topper86d79ef2013-09-17 04:51:29 +00003185 setFeatureEnabledImpl(Features, "mmx", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003186 break;
3187 case CK_Pentium3:
3188 case CK_Pentium3M:
Craig Topperdb4dc082014-11-06 05:52:19 +00003189 case CK_C3_2:
Craig Topper86d79ef2013-09-17 04:51:29 +00003190 setFeatureEnabledImpl(Features, "sse", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003191 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003192 break;
3193 case CK_PentiumM:
3194 case CK_Pentium4:
3195 case CK_Pentium4M:
3196 case CK_x86_64:
Craig Topper86d79ef2013-09-17 04:51:29 +00003197 setFeatureEnabledImpl(Features, "sse2", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003198 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003199 break;
3200 case CK_Yonah:
3201 case CK_Prescott:
3202 case CK_Nocona:
Craig Topper86d79ef2013-09-17 04:51:29 +00003203 setFeatureEnabledImpl(Features, "sse3", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003204 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00003205 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003206 break;
3207 case CK_Core2:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003208 case CK_Bonnell:
Craig Topper86d79ef2013-09-17 04:51:29 +00003209 setFeatureEnabledImpl(Features, "ssse3", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003210 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00003211 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003212 break;
3213 case CK_Penryn:
Craig Topper86d79ef2013-09-17 04:51:29 +00003214 setFeatureEnabledImpl(Features, "sse4.1", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003215 setFeatureEnabledImpl(Features, "fxsr", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00003216 setFeatureEnabledImpl(Features, "cx16", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003217 break;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003218 case CK_Cannonlake:
3219 setFeatureEnabledImpl(Features, "avx512ifma", true);
3220 setFeatureEnabledImpl(Features, "avx512vbmi", true);
3221 setFeatureEnabledImpl(Features, "sha", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003222 LLVM_FALLTHROUGH;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003223 case CK_SkylakeServer:
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003224 setFeatureEnabledImpl(Features, "avx512f", true);
3225 setFeatureEnabledImpl(Features, "avx512cd", true);
3226 setFeatureEnabledImpl(Features, "avx512dq", true);
3227 setFeatureEnabledImpl(Features, "avx512bw", true);
3228 setFeatureEnabledImpl(Features, "avx512vl", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003229 setFeatureEnabledImpl(Features, "pku", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003230 setFeatureEnabledImpl(Features, "clwb", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003231 LLVM_FALLTHROUGH;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003232 case CK_SkylakeClient:
Craig Topperda9fe562015-10-15 05:23:38 +00003233 setFeatureEnabledImpl(Features, "xsavec", true);
3234 setFeatureEnabledImpl(Features, "xsaves", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003235 setFeatureEnabledImpl(Features, "mpx", true);
3236 setFeatureEnabledImpl(Features, "sgx", true);
3237 setFeatureEnabledImpl(Features, "clflushopt", true);
Eric Christopherfc6ffed2017-03-28 23:03:19 +00003238 setFeatureEnabledImpl(Features, "rtm", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003239 LLVM_FALLTHROUGH;
Craig Topperdb4dc082014-11-06 05:52:19 +00003240 case CK_Broadwell:
3241 setFeatureEnabledImpl(Features, "rdseed", true);
3242 setFeatureEnabledImpl(Features, "adx", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003243 LLVM_FALLTHROUGH;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003244 case CK_Haswell:
Craig Topperdb4dc082014-11-06 05:52:19 +00003245 setFeatureEnabledImpl(Features, "avx2", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003246 setFeatureEnabledImpl(Features, "lzcnt", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003247 setFeatureEnabledImpl(Features, "bmi", true);
3248 setFeatureEnabledImpl(Features, "bmi2", true);
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003249 setFeatureEnabledImpl(Features, "fma", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003250 setFeatureEnabledImpl(Features, "movbe", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003251 LLVM_FALLTHROUGH;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003252 case CK_IvyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00003253 setFeatureEnabledImpl(Features, "rdrnd", true);
3254 setFeatureEnabledImpl(Features, "f16c", true);
3255 setFeatureEnabledImpl(Features, "fsgsbase", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003256 LLVM_FALLTHROUGH;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003257 case CK_SandyBridge:
Craig Topperdb4dc082014-11-06 05:52:19 +00003258 setFeatureEnabledImpl(Features, "avx", true);
Craig Topperda9fe562015-10-15 05:23:38 +00003259 setFeatureEnabledImpl(Features, "xsave", true);
3260 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003261 LLVM_FALLTHROUGH;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003262 case CK_Westmere:
Craig Topperdb4dc082014-11-06 05:52:19 +00003263 case CK_Silvermont:
3264 setFeatureEnabledImpl(Features, "aes", true);
3265 setFeatureEnabledImpl(Features, "pclmul", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003266 LLVM_FALLTHROUGH;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003267 case CK_Nehalem:
Craig Topperdb4dc082014-11-06 05:52:19 +00003268 setFeatureEnabledImpl(Features, "sse4.2", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003269 setFeatureEnabledImpl(Features, "fxsr", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00003270 setFeatureEnabledImpl(Features, "cx16", true);
3271 break;
3272 case CK_KNL:
3273 setFeatureEnabledImpl(Features, "avx512f", true);
3274 setFeatureEnabledImpl(Features, "avx512cd", true);
3275 setFeatureEnabledImpl(Features, "avx512er", true);
3276 setFeatureEnabledImpl(Features, "avx512pf", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003277 setFeatureEnabledImpl(Features, "prefetchwt1", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003278 setFeatureEnabledImpl(Features, "fxsr", true);
Robert Khasanov50e6f582014-09-19 09:53:48 +00003279 setFeatureEnabledImpl(Features, "rdseed", true);
3280 setFeatureEnabledImpl(Features, "adx", true);
Craig Topperdb4dc082014-11-06 05:52:19 +00003281 setFeatureEnabledImpl(Features, "lzcnt", true);
3282 setFeatureEnabledImpl(Features, "bmi", true);
3283 setFeatureEnabledImpl(Features, "bmi2", true);
3284 setFeatureEnabledImpl(Features, "rtm", true);
3285 setFeatureEnabledImpl(Features, "fma", true);
3286 setFeatureEnabledImpl(Features, "rdrnd", true);
3287 setFeatureEnabledImpl(Features, "f16c", true);
3288 setFeatureEnabledImpl(Features, "fsgsbase", true);
3289 setFeatureEnabledImpl(Features, "aes", true);
3290 setFeatureEnabledImpl(Features, "pclmul", true);
3291 setFeatureEnabledImpl(Features, "cx16", true);
Craig Topperda9fe562015-10-15 05:23:38 +00003292 setFeatureEnabledImpl(Features, "xsaveopt", true);
3293 setFeatureEnabledImpl(Features, "xsave", true);
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003294 setFeatureEnabledImpl(Features, "movbe", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003295 break;
3296 case CK_K6_2:
3297 case CK_K6_3:
Chandler Carruth212334f2011-09-28 08:55:37 +00003298 case CK_WinChip2:
3299 case CK_C3:
Craig Topper86d79ef2013-09-17 04:51:29 +00003300 setFeatureEnabledImpl(Features, "3dnow", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003301 break;
Chandler Carruthcd99bad2011-09-28 10:36:46 +00003302 case CK_Athlon:
3303 case CK_AthlonThunderbird:
3304 case CK_Geode:
Craig Topper86d79ef2013-09-17 04:51:29 +00003305 setFeatureEnabledImpl(Features, "3dnowa", true);
Chandler Carruthcd99bad2011-09-28 10:36:46 +00003306 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003307 case CK_Athlon4:
3308 case CK_AthlonXP:
3309 case CK_AthlonMP:
Craig Topper86d79ef2013-09-17 04:51:29 +00003310 setFeatureEnabledImpl(Features, "sse", true);
3311 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003312 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003313 break;
3314 case CK_K8:
3315 case CK_Opteron:
3316 case CK_Athlon64:
3317 case CK_AthlonFX:
Craig Topper86d79ef2013-09-17 04:51:29 +00003318 setFeatureEnabledImpl(Features, "sse2", true);
3319 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003320 setFeatureEnabledImpl(Features, "fxsr", true);
Chandler Carruth212334f2011-09-28 08:55:37 +00003321 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00003322 case CK_AMDFAM10:
3323 setFeatureEnabledImpl(Features, "sse4a", true);
3324 setFeatureEnabledImpl(Features, "lzcnt", true);
3325 setFeatureEnabledImpl(Features, "popcnt", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003326 LLVM_FALLTHROUGH;
Chandler Carruth212334f2011-09-28 08:55:37 +00003327 case CK_K8SSE3:
3328 case CK_OpteronSSE3:
3329 case CK_Athlon64SSE3:
Craig Topper86d79ef2013-09-17 04:51:29 +00003330 setFeatureEnabledImpl(Features, "sse3", true);
3331 setFeatureEnabledImpl(Features, "3dnowa", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003332 setFeatureEnabledImpl(Features, "fxsr", true);
Roman Divackyce253d82011-10-30 13:47:56 +00003333 break;
Craig Topperdb4dc082014-11-06 05:52:19 +00003334 case CK_BTVER2:
3335 setFeatureEnabledImpl(Features, "avx", true);
3336 setFeatureEnabledImpl(Features, "aes", true);
3337 setFeatureEnabledImpl(Features, "pclmul", true);
3338 setFeatureEnabledImpl(Features, "bmi", true);
3339 setFeatureEnabledImpl(Features, "f16c", true);
Craig Topperda9fe562015-10-15 05:23:38 +00003340 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003341 LLVM_FALLTHROUGH;
Benjamin Kramer569f2152012-01-10 11:50:18 +00003342 case CK_BTVER1:
Craig Topper86d79ef2013-09-17 04:51:29 +00003343 setFeatureEnabledImpl(Features, "ssse3", true);
3344 setFeatureEnabledImpl(Features, "sse4a", true);
3345 setFeatureEnabledImpl(Features, "lzcnt", true);
3346 setFeatureEnabledImpl(Features, "popcnt", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00003347 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00003348 setFeatureEnabledImpl(Features, "cx16", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003349 setFeatureEnabledImpl(Features, "fxsr", true);
Benjamin Kramer914d7e02013-05-03 10:47:15 +00003350 break;
Craig Topperc45744a2017-01-10 06:02:12 +00003351 case CK_ZNVER1:
3352 setFeatureEnabledImpl(Features, "adx", true);
3353 setFeatureEnabledImpl(Features, "aes", true);
3354 setFeatureEnabledImpl(Features, "avx2", true);
3355 setFeatureEnabledImpl(Features, "bmi", true);
3356 setFeatureEnabledImpl(Features, "bmi2", true);
3357 setFeatureEnabledImpl(Features, "clflushopt", true);
Craig Topper45742262017-02-09 06:10:14 +00003358 setFeatureEnabledImpl(Features, "clzero", true);
Craig Topperc45744a2017-01-10 06:02:12 +00003359 setFeatureEnabledImpl(Features, "cx16", true);
3360 setFeatureEnabledImpl(Features, "f16c", true);
3361 setFeatureEnabledImpl(Features, "fma", true);
3362 setFeatureEnabledImpl(Features, "fsgsbase", true);
3363 setFeatureEnabledImpl(Features, "fxsr", true);
3364 setFeatureEnabledImpl(Features, "lzcnt", true);
3365 setFeatureEnabledImpl(Features, "mwaitx", true);
3366 setFeatureEnabledImpl(Features, "movbe", true);
3367 setFeatureEnabledImpl(Features, "pclmul", true);
3368 setFeatureEnabledImpl(Features, "popcnt", true);
3369 setFeatureEnabledImpl(Features, "prfchw", true);
3370 setFeatureEnabledImpl(Features, "rdrnd", true);
3371 setFeatureEnabledImpl(Features, "rdseed", true);
3372 setFeatureEnabledImpl(Features, "sha", true);
3373 setFeatureEnabledImpl(Features, "sse4a", true);
3374 setFeatureEnabledImpl(Features, "xsave", true);
3375 setFeatureEnabledImpl(Features, "xsavec", true);
3376 setFeatureEnabledImpl(Features, "xsaveopt", true);
3377 setFeatureEnabledImpl(Features, "xsaves", true);
3378 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00003379 case CK_BDVER4:
3380 setFeatureEnabledImpl(Features, "avx2", true);
3381 setFeatureEnabledImpl(Features, "bmi2", true);
Ashutosh Nema51c9dd02016-05-18 11:56:23 +00003382 setFeatureEnabledImpl(Features, "mwaitx", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003383 LLVM_FALLTHROUGH;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00003384 case CK_BDVER3:
Craig Topper8c7f2512014-11-03 06:51:41 +00003385 setFeatureEnabledImpl(Features, "fsgsbase", true);
Craig Topperda9fe562015-10-15 05:23:38 +00003386 setFeatureEnabledImpl(Features, "xsaveopt", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003387 LLVM_FALLTHROUGH;
Craig Topper8c7f2512014-11-03 06:51:41 +00003388 case CK_BDVER2:
Andrea Di Biagio9760a442014-11-06 12:08:57 +00003389 setFeatureEnabledImpl(Features, "bmi", true);
3390 setFeatureEnabledImpl(Features, "fma", true);
3391 setFeatureEnabledImpl(Features, "f16c", true);
3392 setFeatureEnabledImpl(Features, "tbm", true);
Craig Topper7d494ef2017-02-08 05:44:30 +00003393 LLVM_FALLTHROUGH;
Andrea Di Biagio9760a442014-11-06 12:08:57 +00003394 case CK_BDVER1:
3395 // xop implies avx, sse4a and fma4.
Craig Topper86d79ef2013-09-17 04:51:29 +00003396 setFeatureEnabledImpl(Features, "xop", true);
Simon Pilgrim35113482017-05-08 12:09:45 +00003397 setFeatureEnabledImpl(Features, "lwp", true);
Craig Topper86d79ef2013-09-17 04:51:29 +00003398 setFeatureEnabledImpl(Features, "lzcnt", true);
3399 setFeatureEnabledImpl(Features, "aes", true);
3400 setFeatureEnabledImpl(Features, "pclmul", true);
Yunzhong Gao61089362013-10-16 19:07:02 +00003401 setFeatureEnabledImpl(Features, "prfchw", true);
Nick Lewycky50e8f482013-10-05 20:14:27 +00003402 setFeatureEnabledImpl(Features, "cx16", true);
Craig Toppere33f51f2015-10-16 06:22:36 +00003403 setFeatureEnabledImpl(Features, "fxsr", true);
Craig Topperda9fe562015-10-15 05:23:38 +00003404 setFeatureEnabledImpl(Features, "xsave", true);
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003405 break;
Eli Friedman33465822011-07-08 23:31:17 +00003406 }
Eric Christopherbbd746d2015-10-08 20:10:14 +00003407 if (!TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec))
3408 return false;
3409
3410 // Can't do this earlier because we need to be able to explicitly enable
3411 // or disable these features and the things that they depend upon.
3412
3413 // Enable popcnt if sse4.2 is enabled and popcnt is not explicitly disabled.
3414 auto I = Features.find("sse4.2");
Rafael Espindolaa9195872015-10-24 23:15:31 +00003415 if (I != Features.end() && I->getValue() &&
Eric Christopherbbd746d2015-10-08 20:10:14 +00003416 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-popcnt") ==
3417 FeaturesVec.end())
3418 Features["popcnt"] = true;
3419
3420 // Enable prfchw if 3DNow! is enabled and prfchw is not explicitly disabled.
3421 I = Features.find("3dnow");
Rafael Espindolaa9195872015-10-24 23:15:31 +00003422 if (I != Features.end() && I->getValue() &&
Eric Christopherbbd746d2015-10-08 20:10:14 +00003423 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-prfchw") ==
3424 FeaturesVec.end())
3425 Features["prfchw"] = true;
3426
Eric Christophera7260af2015-10-08 20:10:18 +00003427 // Additionally, if SSE is enabled and mmx is not explicitly disabled,
3428 // then enable MMX.
3429 I = Features.find("sse");
Rafael Espindolaa9195872015-10-24 23:15:31 +00003430 if (I != Features.end() && I->getValue() &&
Eric Christophera7260af2015-10-08 20:10:18 +00003431 std::find(FeaturesVec.begin(), FeaturesVec.end(), "-mmx") ==
3432 FeaturesVec.end())
3433 Features["mmx"] = true;
3434
Eric Christopherbbd746d2015-10-08 20:10:14 +00003435 return true;
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003436}
3437
Rafael Espindolae62e2792013-08-20 13:44:29 +00003438void X86TargetInfo::setSSELevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00003439 X86SSEEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003440 if (Enabled) {
3441 switch (Level) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003442 case AVX512F:
3443 Features["avx512f"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003444 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003445 case AVX2:
3446 Features["avx2"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003447 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003448 case AVX:
3449 Features["avx"] = true;
Craig Topperda9fe562015-10-15 05:23:38 +00003450 Features["xsave"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003451 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003452 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00003453 Features["sse4.2"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003454 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003455 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00003456 Features["sse4.1"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003457 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003458 case SSSE3:
3459 Features["ssse3"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003460 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003461 case SSE3:
3462 Features["sse3"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003463 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003464 case SSE2:
3465 Features["sse2"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003466 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003467 case SSE1:
Rafael Espindolae62e2792013-08-20 13:44:29 +00003468 Features["sse"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003469 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003470 case NoSSE:
3471 break;
3472 }
3473 return;
3474 }
3475
3476 switch (Level) {
3477 case NoSSE:
3478 case SSE1:
3479 Features["sse"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003480 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003481 case SSE2:
Ben Langmuir58078d02013-09-19 13:22:04 +00003482 Features["sse2"] = Features["pclmul"] = Features["aes"] =
3483 Features["sha"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003484 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003485 case SSE3:
3486 Features["sse3"] = false;
3487 setXOPLevel(Features, NoXOP, false);
Galina Kistanova078b3012017-05-23 16:33:07 +00003488 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003489 case SSSE3:
3490 Features["ssse3"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003491 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003492 case SSE41:
Rafael Espindola89049822013-08-23 20:21:37 +00003493 Features["sse4.1"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003494 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003495 case SSE42:
Craig Topper7481d8a2013-09-10 06:55:47 +00003496 Features["sse4.2"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003497 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003498 case AVX:
Craig Topperda9fe562015-10-15 05:23:38 +00003499 Features["fma"] = Features["avx"] = Features["f16c"] = Features["xsave"] =
3500 Features["xsaveopt"] = false;
Rafael Espindola0221d862013-08-21 13:28:02 +00003501 setXOPLevel(Features, FMA4, false);
Galina Kistanova078b3012017-05-23 16:33:07 +00003502 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003503 case AVX2:
3504 Features["avx2"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003505 LLVM_FALLTHROUGH;
Craig Topper9c4d17f2013-08-21 03:59:22 +00003506 case AVX512F:
Eric Christopher917e9522014-11-18 22:36:15 +00003507 Features["avx512f"] = Features["avx512cd"] = Features["avx512er"] =
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00003508 Features["avx512pf"] = Features["avx512dq"] = Features["avx512bw"] =
3509 Features["avx512vl"] = Features["avx512vbmi"] =
3510 Features["avx512ifma"] = Features["avx512vpopcntdq"] = false;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003511 }
3512}
3513
3514void X86TargetInfo::setMMXLevel(llvm::StringMap<bool> &Features,
Craig Topper13f61a62013-09-17 04:12:55 +00003515 MMX3DNowEnum Level, bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003516 if (Enabled) {
3517 switch (Level) {
3518 case AMD3DNowAthlon:
3519 Features["3dnowa"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003520 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003521 case AMD3DNow:
3522 Features["3dnow"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003523 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003524 case MMX:
3525 Features["mmx"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003526 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003527 case NoMMX3DNow:
3528 break;
3529 }
3530 return;
3531 }
3532
3533 switch (Level) {
3534 case NoMMX3DNow:
3535 case MMX:
3536 Features["mmx"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003537 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003538 case AMD3DNow:
3539 Features["3dnow"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003540 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003541 case AMD3DNowAthlon:
3542 Features["3dnowa"] = false;
3543 }
3544}
3545
3546void X86TargetInfo::setXOPLevel(llvm::StringMap<bool> &Features, XOPEnum Level,
Craig Topper13f61a62013-09-17 04:12:55 +00003547 bool Enabled) {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003548 if (Enabled) {
3549 switch (Level) {
3550 case XOP:
3551 Features["xop"] = true;
Galina Kistanova078b3012017-05-23 16:33:07 +00003552 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003553 case FMA4:
3554 Features["fma4"] = true;
3555 setSSELevel(Features, AVX, true);
Galina Kistanova078b3012017-05-23 16:33:07 +00003556 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003557 case SSE4A:
3558 Features["sse4a"] = true;
3559 setSSELevel(Features, SSE3, true);
Galina Kistanova078b3012017-05-23 16:33:07 +00003560 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003561 case NoXOP:
3562 break;
3563 }
3564 return;
3565 }
3566
3567 switch (Level) {
3568 case NoXOP:
3569 case SSE4A:
3570 Features["sse4a"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003571 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003572 case FMA4:
3573 Features["fma4"] = false;
Galina Kistanova078b3012017-05-23 16:33:07 +00003574 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00003575 case XOP:
3576 Features["xop"] = false;
3577 }
3578}
3579
Craig Topper86d79ef2013-09-17 04:51:29 +00003580void X86TargetInfo::setFeatureEnabledImpl(llvm::StringMap<bool> &Features,
3581 StringRef Name, bool Enabled) {
Eric Christopher298ac302015-07-01 00:08:32 +00003582 // This is a bit of a hack to deal with the sse4 target feature when used
3583 // as part of the target attribute. We handle sse4 correctly everywhere
3584 // else. See below for more information on how we handle the sse4 options.
3585 if (Name != "sse4")
3586 Features[Name] = Enabled;
Rafael Espindolaa6416a72011-11-27 20:00:43 +00003587
Craig Topper29561122013-09-19 01:13:07 +00003588 if (Name == "mmx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003589 setMMXLevel(Features, MMX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003590 } else if (Name == "sse") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003591 setSSELevel(Features, SSE1, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003592 } else if (Name == "sse2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003593 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003594 } else if (Name == "sse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003595 setSSELevel(Features, SSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003596 } else if (Name == "ssse3") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003597 setSSELevel(Features, SSSE3, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003598 } else if (Name == "sse4.2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003599 setSSELevel(Features, SSE42, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003600 } else if (Name == "sse4.1") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003601 setSSELevel(Features, SSE41, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003602 } else if (Name == "3dnow") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003603 setMMXLevel(Features, AMD3DNow, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003604 } else if (Name == "3dnowa") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003605 setMMXLevel(Features, AMD3DNowAthlon, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003606 } else if (Name == "aes") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003607 if (Enabled)
3608 setSSELevel(Features, SSE2, Enabled);
3609 } else if (Name == "pclmul") {
3610 if (Enabled)
3611 setSSELevel(Features, SSE2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003612 } else if (Name == "avx") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003613 setSSELevel(Features, AVX, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003614 } else if (Name == "avx2") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003615 setSSELevel(Features, AVX2, Enabled);
Craig Topper29561122013-09-19 01:13:07 +00003616 } else if (Name == "avx512f") {
Craig Topper9c4d17f2013-08-21 03:59:22 +00003617 setSSELevel(Features, AVX512F, Enabled);
Craig Topperb4f83a02016-02-29 06:51:38 +00003618 } else if (Name == "avx512cd" || Name == "avx512er" || Name == "avx512pf" ||
3619 Name == "avx512dq" || Name == "avx512bw" || Name == "avx512vl" ||
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00003620 Name == "avx512vbmi" || Name == "avx512ifma" ||
3621 Name == "avx512vpopcntdq") {
Craig Topper679b53a2013-08-21 05:29:10 +00003622 if (Enabled)
3623 setSSELevel(Features, AVX512F, Enabled);
Craig Topper6c7ecc52016-11-09 04:51:03 +00003624 // Enable BWI instruction if VBMI is being enabled.
3625 if (Name == "avx512vbmi" && Enabled)
3626 Features["avx512bw"] = true;
3627 // Also disable VBMI if BWI is being disabled.
3628 if (Name == "avx512bw" && !Enabled)
3629 Features["avx512vbmi"] = false;
Craig Topper679b53a2013-08-21 05:29:10 +00003630 } else if (Name == "fma") {
Rafael Espindolae62e2792013-08-20 13:44:29 +00003631 if (Enabled)
3632 setSSELevel(Features, AVX, Enabled);
3633 } else if (Name == "fma4") {
3634 setXOPLevel(Features, FMA4, Enabled);
3635 } else if (Name == "xop") {
3636 setXOPLevel(Features, XOP, Enabled);
3637 } else if (Name == "sse4a") {
3638 setXOPLevel(Features, SSE4A, Enabled);
Craig Topper31db3a22013-09-16 04:54:13 +00003639 } else if (Name == "f16c") {
3640 if (Enabled)
3641 setSSELevel(Features, AVX, Enabled);
Ben Langmuir58078d02013-09-19 13:22:04 +00003642 } else if (Name == "sha") {
3643 if (Enabled)
3644 setSSELevel(Features, SSE2, Enabled);
Eric Christopher298ac302015-07-01 00:08:32 +00003645 } else if (Name == "sse4") {
3646 // We can get here via the __target__ attribute since that's not controlled
3647 // via the -msse4/-mno-sse4 command line alias. Handle this the same way
3648 // here - turn on the sse4.2 if enabled, turn off the sse4.1 level if
3649 // disabled.
3650 if (Enabled)
3651 setSSELevel(Features, SSE42, Enabled);
3652 else
3653 setSSELevel(Features, SSE41, Enabled);
Craig Topperda9fe562015-10-15 05:23:38 +00003654 } else if (Name == "xsave") {
Craig Topper840927e2016-02-29 06:51:34 +00003655 if (!Enabled)
Craig Topperda9fe562015-10-15 05:23:38 +00003656 Features["xsaveopt"] = false;
3657 } else if (Name == "xsaveopt" || Name == "xsavec" || Name == "xsaves") {
Craig Topper840927e2016-02-29 06:51:34 +00003658 if (Enabled)
Craig Topperda9fe562015-10-15 05:23:38 +00003659 Features["xsave"] = true;
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00003660 }
Daniel Dunbarbb36aed2009-05-06 21:07:50 +00003661}
3662
Eric Christopher3ff21b32013-10-16 21:26:26 +00003663/// handleTargetFeatures - Perform initialization based on the user
Daniel Dunbar4dbaaa62009-05-06 03:16:41 +00003664/// configured set of features.
Eric Christopher3ff21b32013-10-16 21:26:26 +00003665bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
Rafael Espindolaeb265472013-08-21 21:59:03 +00003666 DiagnosticsEngine &Diags) {
Eric Christopher610fe112015-08-26 08:21:55 +00003667 for (const auto &Feature : Features) {
3668 if (Feature[0] != '+')
Daniel Dunbar979586e2009-11-11 09:38:56 +00003669 continue;
3670
Eric Christopher610fe112015-08-26 08:21:55 +00003671 if (Feature == "+aes") {
Eric Christophere1ddaf92010-04-02 23:50:19 +00003672 HasAES = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003673 } else if (Feature == "+pclmul") {
Craig Topper3f122a72012-05-31 05:18:48 +00003674 HasPCLMUL = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003675 } else if (Feature == "+lzcnt") {
Craig Topper22967d42011-12-25 05:06:45 +00003676 HasLZCNT = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003677 } else if (Feature == "+rdrnd") {
Benjamin Kramer1e250392012-07-07 09:39:18 +00003678 HasRDRND = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003679 } else if (Feature == "+fsgsbase") {
Craig Topper8c7f2512014-11-03 06:51:41 +00003680 HasFSGSBASE = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003681 } else if (Feature == "+bmi") {
Craig Topper22967d42011-12-25 05:06:45 +00003682 HasBMI = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003683 } else if (Feature == "+bmi2") {
Craig Topper22967d42011-12-25 05:06:45 +00003684 HasBMI2 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003685 } else if (Feature == "+popcnt") {
Craig Topper1de83482011-12-29 16:10:46 +00003686 HasPOPCNT = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003687 } else if (Feature == "+rtm") {
Michael Liao625a8752012-11-10 05:17:46 +00003688 HasRTM = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003689 } else if (Feature == "+prfchw") {
Michael Liao74f4eaf2013-03-26 17:52:08 +00003690 HasPRFCHW = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003691 } else if (Feature == "+rdseed") {
Michael Liaoffaae352013-03-29 05:17:55 +00003692 HasRDSEED = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003693 } else if (Feature == "+adx") {
Robert Khasanov50e6f582014-09-19 09:53:48 +00003694 HasADX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003695 } else if (Feature == "+tbm") {
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00003696 HasTBM = true;
Simon Pilgrim35113482017-05-08 12:09:45 +00003697 } else if (Feature == "+lwp") {
3698 HasLWP = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003699 } else if (Feature == "+fma") {
Craig Topperbba778b2012-06-03 21:46:30 +00003700 HasFMA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003701 } else if (Feature == "+f16c") {
Manman Rena45358c2012-10-11 00:59:55 +00003702 HasF16C = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003703 } else if (Feature == "+avx512cd") {
Craig Topper679b53a2013-08-21 05:29:10 +00003704 HasAVX512CD = true;
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00003705 } else if (Feature == "+avx512vpopcntdq") {
3706 HasAVX512VPOPCNTDQ = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003707 } else if (Feature == "+avx512er") {
Craig Topper679b53a2013-08-21 05:29:10 +00003708 HasAVX512ER = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003709 } else if (Feature == "+avx512pf") {
Craig Topper679b53a2013-08-21 05:29:10 +00003710 HasAVX512PF = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003711 } else if (Feature == "+avx512dq") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003712 HasAVX512DQ = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003713 } else if (Feature == "+avx512bw") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003714 HasAVX512BW = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003715 } else if (Feature == "+avx512vl") {
Robert Khasanov3b6616c2014-07-30 13:53:40 +00003716 HasAVX512VL = true;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003717 } else if (Feature == "+avx512vbmi") {
3718 HasAVX512VBMI = true;
3719 } else if (Feature == "+avx512ifma") {
3720 HasAVX512IFMA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003721 } else if (Feature == "+sha") {
Ben Langmuir58078d02013-09-19 13:22:04 +00003722 HasSHA = true;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003723 } else if (Feature == "+mpx") {
3724 HasMPX = true;
3725 } else if (Feature == "+movbe") {
3726 HasMOVBE = true;
3727 } else if (Feature == "+sgx") {
3728 HasSGX = true;
Eric Christopher610fe112015-08-26 08:21:55 +00003729 } else if (Feature == "+cx16") {
Nick Lewycky50e8f482013-10-05 20:14:27 +00003730 HasCX16 = true;
Craig Toppere33f51f2015-10-16 06:22:36 +00003731 } else if (Feature == "+fxsr") {
3732 HasFXSR = true;
Craig Topperda9fe562015-10-15 05:23:38 +00003733 } else if (Feature == "+xsave") {
3734 HasXSAVE = true;
3735 } else if (Feature == "+xsaveopt") {
3736 HasXSAVEOPT = true;
3737 } else if (Feature == "+xsavec") {
3738 HasXSAVEC = true;
3739 } else if (Feature == "+xsaves") {
3740 HasXSAVES = true;
Ashutosh Nema51c9dd02016-05-18 11:56:23 +00003741 } else if (Feature == "+mwaitx") {
3742 HasMWAITX = true;
Asaf Badouha9d1e182015-12-31 14:14:07 +00003743 } else if (Feature == "+pku") {
3744 HasPKU = true;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003745 } else if (Feature == "+clflushopt") {
3746 HasCLFLUSHOPT = true;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003747 } else if (Feature == "+clwb") {
3748 HasCLWB = true;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003749 } else if (Feature == "+prefetchwt1") {
3750 HasPREFETCHWT1 = true;
Craig Topper45742262017-02-09 06:10:14 +00003751 } else if (Feature == "+clzero") {
3752 HasCLZERO = true;
Nick Lewycky50e8f482013-10-05 20:14:27 +00003753 }
3754
Benjamin Kramer27402c62012-03-05 15:10:44 +00003755 X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003756 .Case("+avx512f", AVX512F)
3757 .Case("+avx2", AVX2)
3758 .Case("+avx", AVX)
3759 .Case("+sse4.2", SSE42)
3760 .Case("+sse4.1", SSE41)
3761 .Case("+ssse3", SSSE3)
3762 .Case("+sse3", SSE3)
3763 .Case("+sse2", SSE2)
3764 .Case("+sse", SSE1)
Eli Friedman33465822011-07-08 23:31:17 +00003765 .Default(NoSSE);
Daniel Dunbar979586e2009-11-11 09:38:56 +00003766 SSELevel = std::max(SSELevel, Level);
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00003767
Eli Friedman33465822011-07-08 23:31:17 +00003768 MMX3DNowEnum ThreeDNowLevel =
Benjamin Kramer27402c62012-03-05 15:10:44 +00003769 llvm::StringSwitch<MMX3DNowEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003770 .Case("+3dnowa", AMD3DNowAthlon)
3771 .Case("+3dnow", AMD3DNow)
3772 .Case("+mmx", MMX)
Eli Friedman33465822011-07-08 23:31:17 +00003773 .Default(NoMMX3DNow);
Eli Friedman33465822011-07-08 23:31:17 +00003774 MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
Rafael Espindolae62e2792013-08-20 13:44:29 +00003775
3776 XOPEnum XLevel = llvm::StringSwitch<XOPEnum>(Feature)
Eric Christopher610fe112015-08-26 08:21:55 +00003777 .Case("+xop", XOP)
3778 .Case("+fma4", FMA4)
3779 .Case("+sse4a", SSE4A)
Rafael Espindolae62e2792013-08-20 13:44:29 +00003780 .Default(NoXOP);
3781 XOPLevel = std::max(XOPLevel, XLevel);
Daniel Dunbar979586e2009-11-11 09:38:56 +00003782 }
Eli Friedman33465822011-07-08 23:31:17 +00003783
Rafael Espindolaeb265472013-08-21 21:59:03 +00003784 // LLVM doesn't have a separate switch for fpmath, so only accept it if it
3785 // matches the selected sse level.
Craig Topperd945d502015-10-20 00:00:17 +00003786 if ((FPMath == FP_SSE && SSELevel < SSE1) ||
3787 (FPMath == FP_387 && SSELevel >= SSE1)) {
3788 Diags.Report(diag::err_target_unsupported_fpmath) <<
3789 (FPMath == FP_SSE ? "sse" : "387");
Rafael Espindolaeb265472013-08-21 21:59:03 +00003790 return false;
3791 }
3792
Alexey Bataev00396512015-07-02 03:40:19 +00003793 SimdDefaultAlign =
Ahmed Bougacha68bf64e2015-08-27 22:24:56 +00003794 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Rafael Espindolaeb265472013-08-21 21:59:03 +00003795 return true;
Chris Lattnerc25d8a72009-03-02 22:20:04 +00003796}
Chris Lattnerecd49032009-03-02 22:27:17 +00003797
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003798/// X86TargetInfo::getTargetDefines - Return the set of the X86-specific macro
3799/// definitions for this particular subtarget.
Chris Lattner4ba73aa02009-03-20 15:52:06 +00003800void X86TargetInfo::getTargetDefines(const LangOptions &Opts,
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003801 MacroBuilder &Builder) const {
Chris Lattnerecd49032009-03-02 22:27:17 +00003802 // Target identification.
Derek Schuffc7dd7222012-10-11 15:52:22 +00003803 if (getTriple().getArch() == llvm::Triple::x86_64) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003804 Builder.defineMacro("__amd64__");
3805 Builder.defineMacro("__amd64");
3806 Builder.defineMacro("__x86_64");
3807 Builder.defineMacro("__x86_64__");
Bob Wilsona2acb1e2014-08-08 23:46:28 +00003808 if (getTriple().getArchName() == "x86_64h") {
3809 Builder.defineMacro("__x86_64h");
3810 Builder.defineMacro("__x86_64h__");
3811 }
Chris Lattnerecd49032009-03-02 22:27:17 +00003812 } else {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003813 DefineStd(Builder, "i386", Opts);
Chris Lattnerecd49032009-03-02 22:27:17 +00003814 }
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003815
Chris Lattnerecd49032009-03-02 22:27:17 +00003816 // Subtarget options.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003817 // FIXME: We are hard-coding the tune parameters based on the CPU, but they
3818 // truly should be based on -mtune options.
Chandler Carruth212334f2011-09-28 08:55:37 +00003819 switch (CPU) {
3820 case CK_Generic:
3821 break;
3822 case CK_i386:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003823 // The rest are coming from the i386 define above.
3824 Builder.defineMacro("__tune_i386__");
Chandler Carruth212334f2011-09-28 08:55:37 +00003825 break;
3826 case CK_i486:
3827 case CK_WinChipC6:
3828 case CK_WinChip2:
3829 case CK_C3:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003830 defineCPUMacros(Builder, "i486");
Chandler Carruth212334f2011-09-28 08:55:37 +00003831 break;
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003832 case CK_PentiumMMX:
3833 Builder.defineMacro("__pentium_mmx__");
3834 Builder.defineMacro("__tune_pentium_mmx__");
3835 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00003836 case CK_i586:
3837 case CK_Pentium:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003838 defineCPUMacros(Builder, "i586");
3839 defineCPUMacros(Builder, "pentium");
Chandler Carruth212334f2011-09-28 08:55:37 +00003840 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003841 case CK_Pentium3:
3842 case CK_Pentium3M:
3843 case CK_PentiumM:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003844 Builder.defineMacro("__tune_pentium3__");
3845 // Fallthrough
3846 case CK_Pentium2:
Chandler Carruth212334f2011-09-28 08:55:37 +00003847 case CK_C3_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003848 Builder.defineMacro("__tune_pentium2__");
3849 // Fallthrough
3850 case CK_PentiumPro:
3851 Builder.defineMacro("__tune_i686__");
3852 Builder.defineMacro("__tune_pentiumpro__");
3853 // Fallthrough
3854 case CK_i686:
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003855 Builder.defineMacro("__i686");
3856 Builder.defineMacro("__i686__");
3857 // Strangely, __tune_i686__ isn't defined by GCC when CPU == i686.
3858 Builder.defineMacro("__pentiumpro");
3859 Builder.defineMacro("__pentiumpro__");
Chandler Carruth212334f2011-09-28 08:55:37 +00003860 break;
3861 case CK_Pentium4:
3862 case CK_Pentium4M:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003863 defineCPUMacros(Builder, "pentium4");
Chandler Carruth212334f2011-09-28 08:55:37 +00003864 break;
3865 case CK_Yonah:
3866 case CK_Prescott:
3867 case CK_Nocona:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003868 defineCPUMacros(Builder, "nocona");
Chandler Carruth212334f2011-09-28 08:55:37 +00003869 break;
3870 case CK_Core2:
3871 case CK_Penryn:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003872 defineCPUMacros(Builder, "core2");
Chandler Carruth212334f2011-09-28 08:55:37 +00003873 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003874 case CK_Bonnell:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003875 defineCPUMacros(Builder, "atom");
Chandler Carruth212334f2011-09-28 08:55:37 +00003876 break;
Preston Gurda3c58c02013-09-13 19:27:17 +00003877 case CK_Silvermont:
Benjamin Kramerffecc842013-08-30 14:05:34 +00003878 defineCPUMacros(Builder, "slm");
3879 break;
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003880 case CK_Nehalem:
3881 case CK_Westmere:
3882 case CK_SandyBridge:
3883 case CK_IvyBridge:
3884 case CK_Haswell:
Robert Khasanov50e6f582014-09-19 09:53:48 +00003885 case CK_Broadwell:
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003886 case CK_SkylakeClient:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003887 // FIXME: Historically, we defined this legacy name, it would be nice to
3888 // remove it at some point. We've never exposed fine-grained names for
3889 // recent primary x86 CPUs, and we should keep it that way.
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003890 defineCPUMacros(Builder, "corei7");
Chandler Carruth212334f2011-09-28 08:55:37 +00003891 break;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003892 case CK_SkylakeServer:
Chandler Carruth04ca0bb2014-12-09 14:50:25 +00003893 defineCPUMacros(Builder, "skx");
3894 break;
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00003895 case CK_Cannonlake:
3896 break;
Craig Topper449314e2013-08-20 07:09:39 +00003897 case CK_KNL:
3898 defineCPUMacros(Builder, "knl");
3899 break;
Andrey Turetskiyfd259ff2016-04-05 15:04:26 +00003900 case CK_Lakemont:
3901 Builder.defineMacro("__tune_lakemont__");
3902 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003903 case CK_K6_2:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003904 Builder.defineMacro("__k6_2__");
3905 Builder.defineMacro("__tune_k6_2__");
3906 // Fallthrough
Chandler Carruth212334f2011-09-28 08:55:37 +00003907 case CK_K6_3:
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003908 if (CPU != CK_K6_2) { // In case of fallthrough
3909 // FIXME: GCC may be enabling these in cases where some other k6
3910 // architecture is specified but -m3dnow is explicitly provided. The
3911 // exact semantics need to be determined and emulated here.
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003912 Builder.defineMacro("__k6_3__");
3913 Builder.defineMacro("__tune_k6_3__");
3914 }
Chandler Carruthdf5f48a2011-09-28 09:45:05 +00003915 // Fallthrough
3916 case CK_K6:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003917 defineCPUMacros(Builder, "k6");
Chandler Carruth212334f2011-09-28 08:55:37 +00003918 break;
3919 case CK_Athlon:
3920 case CK_AthlonThunderbird:
3921 case CK_Athlon4:
3922 case CK_AthlonXP:
3923 case CK_AthlonMP:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003924 defineCPUMacros(Builder, "athlon");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00003925 if (SSELevel != NoSSE) {
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003926 Builder.defineMacro("__athlon_sse__");
Chandler Carruth5d0feef2011-09-28 09:54:11 +00003927 Builder.defineMacro("__tune_athlon_sse__");
3928 }
Chandler Carruth212334f2011-09-28 08:55:37 +00003929 break;
3930 case CK_K8:
3931 case CK_K8SSE3:
3932 case CK_x86_64:
3933 case CK_Opteron:
3934 case CK_OpteronSSE3:
3935 case CK_Athlon64:
3936 case CK_Athlon64SSE3:
3937 case CK_AthlonFX:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003938 defineCPUMacros(Builder, "k8");
Chandler Carruth212334f2011-09-28 08:55:37 +00003939 break;
Roman Divacky43eb6f82011-10-30 07:48:46 +00003940 case CK_AMDFAM10:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003941 defineCPUMacros(Builder, "amdfam10");
Roman Divacky43eb6f82011-10-30 07:48:46 +00003942 break;
Benjamin Kramer569f2152012-01-10 11:50:18 +00003943 case CK_BTVER1:
3944 defineCPUMacros(Builder, "btver1");
3945 break;
Benjamin Kramer914d7e02013-05-03 10:47:15 +00003946 case CK_BTVER2:
3947 defineCPUMacros(Builder, "btver2");
3948 break;
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003949 case CK_BDVER1:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003950 defineCPUMacros(Builder, "bdver1");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003951 break;
3952 case CK_BDVER2:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003953 defineCPUMacros(Builder, "bdver2");
Benjamin Kramer6bd51592011-12-01 18:23:59 +00003954 break;
Benjamin Kramerd9a5e2a2013-11-04 10:29:51 +00003955 case CK_BDVER3:
3956 defineCPUMacros(Builder, "bdver3");
3957 break;
Benjamin Kramer56c58222014-05-02 15:47:51 +00003958 case CK_BDVER4:
3959 defineCPUMacros(Builder, "bdver4");
3960 break;
Craig Topperc45744a2017-01-10 06:02:12 +00003961 case CK_ZNVER1:
3962 defineCPUMacros(Builder, "znver1");
3963 break;
Chandler Carruth212334f2011-09-28 08:55:37 +00003964 case CK_Geode:
Benjamin Kramere3b442d2012-01-10 11:50:09 +00003965 defineCPUMacros(Builder, "geode");
Chandler Carruth212334f2011-09-28 08:55:37 +00003966 break;
Chandler Carruth5ac1e8e2011-09-28 02:59:25 +00003967 }
Chris Lattner96e43572009-03-02 22:40:39 +00003968
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003969 // Target properties.
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003970 Builder.defineMacro("__REGISTER_PREFIX__", "");
3971
Chris Lattner6df41af2009-04-19 17:32:33 +00003972 // Define __NO_MATH_INLINES on linux/x86 so that we don't get inline
3973 // functions in glibc header files that use FP Stack inline asm which the
3974 // backend can't deal with (PR879).
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00003975 Builder.defineMacro("__NO_MATH_INLINES");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00003976
Chandler Carruth3f7ed952011-09-28 09:54:07 +00003977 if (HasAES)
3978 Builder.defineMacro("__AES__");
3979
Craig Topper3f122a72012-05-31 05:18:48 +00003980 if (HasPCLMUL)
3981 Builder.defineMacro("__PCLMUL__");
3982
Craig Topper22967d42011-12-25 05:06:45 +00003983 if (HasLZCNT)
3984 Builder.defineMacro("__LZCNT__");
3985
Benjamin Kramer1e250392012-07-07 09:39:18 +00003986 if (HasRDRND)
3987 Builder.defineMacro("__RDRND__");
3988
Craig Topper8c7f2512014-11-03 06:51:41 +00003989 if (HasFSGSBASE)
3990 Builder.defineMacro("__FSGSBASE__");
3991
Craig Topper22967d42011-12-25 05:06:45 +00003992 if (HasBMI)
3993 Builder.defineMacro("__BMI__");
3994
3995 if (HasBMI2)
3996 Builder.defineMacro("__BMI2__");
3997
Craig Topper1de83482011-12-29 16:10:46 +00003998 if (HasPOPCNT)
3999 Builder.defineMacro("__POPCNT__");
4000
Michael Liao625a8752012-11-10 05:17:46 +00004001 if (HasRTM)
4002 Builder.defineMacro("__RTM__");
4003
Michael Liao74f4eaf2013-03-26 17:52:08 +00004004 if (HasPRFCHW)
4005 Builder.defineMacro("__PRFCHW__");
4006
Michael Liaoffaae352013-03-29 05:17:55 +00004007 if (HasRDSEED)
4008 Builder.defineMacro("__RDSEED__");
4009
Robert Khasanov50e6f582014-09-19 09:53:48 +00004010 if (HasADX)
4011 Builder.defineMacro("__ADX__");
4012
Yunzhong Gao1f6aeeb2013-09-24 19:00:58 +00004013 if (HasTBM)
4014 Builder.defineMacro("__TBM__");
4015
Simon Pilgrim35113482017-05-08 12:09:45 +00004016 if (HasLWP)
4017 Builder.defineMacro("__LWP__");
4018
Ashutosh Nema51c9dd02016-05-18 11:56:23 +00004019 if (HasMWAITX)
4020 Builder.defineMacro("__MWAITX__");
4021
Rafael Espindolae62e2792013-08-20 13:44:29 +00004022 switch (XOPLevel) {
4023 case XOP:
4024 Builder.defineMacro("__XOP__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004025 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00004026 case FMA4:
Craig Topperffdb46c2011-12-30 07:33:42 +00004027 Builder.defineMacro("__FMA4__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004028 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00004029 case SSE4A:
4030 Builder.defineMacro("__SSE4A__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004031 LLVM_FALLTHROUGH;
Rafael Espindolae62e2792013-08-20 13:44:29 +00004032 case NoXOP:
4033 break;
4034 }
Craig Topperffdb46c2011-12-30 07:33:42 +00004035
Craig Topperbba778b2012-06-03 21:46:30 +00004036 if (HasFMA)
4037 Builder.defineMacro("__FMA__");
4038
Manman Rena45358c2012-10-11 00:59:55 +00004039 if (HasF16C)
4040 Builder.defineMacro("__F16C__");
4041
Craig Topper679b53a2013-08-21 05:29:10 +00004042 if (HasAVX512CD)
4043 Builder.defineMacro("__AVX512CD__");
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00004044 if (HasAVX512VPOPCNTDQ)
4045 Builder.defineMacro("__AVX512VPOPCNTDQ__");
Craig Topper679b53a2013-08-21 05:29:10 +00004046 if (HasAVX512ER)
4047 Builder.defineMacro("__AVX512ER__");
4048 if (HasAVX512PF)
4049 Builder.defineMacro("__AVX512PF__");
Robert Khasanov3b6616c2014-07-30 13:53:40 +00004050 if (HasAVX512DQ)
4051 Builder.defineMacro("__AVX512DQ__");
4052 if (HasAVX512BW)
4053 Builder.defineMacro("__AVX512BW__");
4054 if (HasAVX512VL)
4055 Builder.defineMacro("__AVX512VL__");
Craig Topperb4f83a02016-02-29 06:51:38 +00004056 if (HasAVX512VBMI)
4057 Builder.defineMacro("__AVX512VBMI__");
4058 if (HasAVX512IFMA)
4059 Builder.defineMacro("__AVX512IFMA__");
Craig Topper679b53a2013-08-21 05:29:10 +00004060
Ben Langmuir58078d02013-09-19 13:22:04 +00004061 if (HasSHA)
4062 Builder.defineMacro("__SHA__");
4063
Craig Toppere33f51f2015-10-16 06:22:36 +00004064 if (HasFXSR)
4065 Builder.defineMacro("__FXSR__");
Craig Topperda9fe562015-10-15 05:23:38 +00004066 if (HasXSAVE)
4067 Builder.defineMacro("__XSAVE__");
4068 if (HasXSAVEOPT)
4069 Builder.defineMacro("__XSAVEOPT__");
4070 if (HasXSAVEC)
4071 Builder.defineMacro("__XSAVEC__");
4072 if (HasXSAVES)
4073 Builder.defineMacro("__XSAVES__");
Asaf Badouha9d1e182015-12-31 14:14:07 +00004074 if (HasPKU)
4075 Builder.defineMacro("__PKU__");
Nick Lewycky50e8f482013-10-05 20:14:27 +00004076 if (HasCX16)
4077 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
Craig Topper78b47872017-02-08 06:48:58 +00004078 if (HasCLFLUSHOPT)
4079 Builder.defineMacro("__CLFLUSHOPT__");
Craig Topper8c708cf2017-02-08 07:36:58 +00004080 if (HasCLWB)
4081 Builder.defineMacro("__CLWB__");
Craig Topperb16cb822017-02-08 07:56:42 +00004082 if (HasMPX)
4083 Builder.defineMacro("__MPX__");
Craig Topper204ecff2017-02-08 08:23:17 +00004084 if (HasSGX)
4085 Builder.defineMacro("__SGX__");
Craig Topperd2bf7b02017-02-08 08:23:40 +00004086 if (HasPREFETCHWT1)
4087 Builder.defineMacro("__PREFETCHWT1__");
Craig Topper45742262017-02-09 06:10:14 +00004088 if (HasCLZERO)
4089 Builder.defineMacro("__CLZERO__");
Nick Lewycky50e8f482013-10-05 20:14:27 +00004090
Chris Lattner96e43572009-03-02 22:40:39 +00004091 // Each case falls through to the previous one here.
4092 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00004093 case AVX512F:
Craig Topper007b0592013-08-20 07:39:54 +00004094 Builder.defineMacro("__AVX512F__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004095 LLVM_FALLTHROUGH;
Craig Topper23b92192012-01-09 09:19:09 +00004096 case AVX2:
4097 Builder.defineMacro("__AVX2__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004098 LLVM_FALLTHROUGH;
Craig Topper23b92192012-01-09 09:19:09 +00004099 case AVX:
4100 Builder.defineMacro("__AVX__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004101 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004102 case SSE42:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004103 Builder.defineMacro("__SSE4_2__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004104 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004105 case SSE41:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004106 Builder.defineMacro("__SSE4_1__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004107 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004108 case SSSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004109 Builder.defineMacro("__SSSE3__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004110 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004111 case SSE3:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004112 Builder.defineMacro("__SSE3__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004113 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004114 case SSE2:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004115 Builder.defineMacro("__SSE2__");
4116 Builder.defineMacro("__SSE2_MATH__"); // -mfp-math=sse always implied.
Galina Kistanova078b3012017-05-23 16:33:07 +00004117 LLVM_FALLTHROUGH;
Chris Lattner96e43572009-03-02 22:40:39 +00004118 case SSE1:
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004119 Builder.defineMacro("__SSE__");
4120 Builder.defineMacro("__SSE_MATH__"); // -mfp-math=sse always implied.
Galina Kistanova078b3012017-05-23 16:33:07 +00004121 LLVM_FALLTHROUGH;
Eli Friedman33465822011-07-08 23:31:17 +00004122 case NoSSE:
Chris Lattner96e43572009-03-02 22:40:39 +00004123 break;
4124 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00004125
Derek Schuffc7dd7222012-10-11 15:52:22 +00004126 if (Opts.MicrosoftExt && getTriple().getArch() == llvm::Triple::x86) {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004127 switch (SSELevel) {
Craig Topper9c4d17f2013-08-21 03:59:22 +00004128 case AVX512F:
Craig Topper23b92192012-01-09 09:19:09 +00004129 case AVX2:
4130 case AVX:
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004131 case SSE42:
4132 case SSE41:
4133 case SSSE3:
4134 case SSE3:
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004135 case SSE2:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004136 Builder.defineMacro("_M_IX86_FP", Twine(2));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004137 break;
4138 case SSE1:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004139 Builder.defineMacro("_M_IX86_FP", Twine(1));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004140 break;
4141 default:
Chris Lattner0e62c1c2011-07-23 10:55:15 +00004142 Builder.defineMacro("_M_IX86_FP", Twine(0));
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004143 }
4144 }
4145
Anders Carlssone437c682010-01-27 03:47:49 +00004146 // Each case falls through to the previous one here.
Eli Friedman33465822011-07-08 23:31:17 +00004147 switch (MMX3DNowLevel) {
Anders Carlssone437c682010-01-27 03:47:49 +00004148 case AMD3DNowAthlon:
4149 Builder.defineMacro("__3dNOW_A__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004150 LLVM_FALLTHROUGH;
Anders Carlssone437c682010-01-27 03:47:49 +00004151 case AMD3DNow:
4152 Builder.defineMacro("__3dNOW__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004153 LLVM_FALLTHROUGH;
Eli Friedman33465822011-07-08 23:31:17 +00004154 case MMX:
4155 Builder.defineMacro("__MMX__");
Galina Kistanova078b3012017-05-23 16:33:07 +00004156 LLVM_FALLTHROUGH;
Eli Friedman33465822011-07-08 23:31:17 +00004157 case NoMMX3DNow:
Anders Carlssone437c682010-01-27 03:47:49 +00004158 break;
4159 }
Michael J. Spencera0d5eb3a2013-04-04 23:53:43 +00004160
4161 if (CPU >= CK_i486) {
4162 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
4163 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
4164 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
4165 }
4166 if (CPU >= CK_i586)
4167 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Chris Lattnerecd49032009-03-02 22:27:17 +00004168}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00004169
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004170bool X86TargetInfo::hasFeature(StringRef Feature) const {
4171 return llvm::StringSwitch<bool>(Feature)
4172 .Case("aes", HasAES)
4173 .Case("avx", SSELevel >= AVX)
4174 .Case("avx2", SSELevel >= AVX2)
Craig Topper9c4d17f2013-08-21 03:59:22 +00004175 .Case("avx512f", SSELevel >= AVX512F)
Craig Topper679b53a2013-08-21 05:29:10 +00004176 .Case("avx512cd", HasAVX512CD)
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00004177 .Case("avx512vpopcntdq", HasAVX512VPOPCNTDQ)
Craig Topper679b53a2013-08-21 05:29:10 +00004178 .Case("avx512er", HasAVX512ER)
4179 .Case("avx512pf", HasAVX512PF)
Robert Khasanov3b6616c2014-07-30 13:53:40 +00004180 .Case("avx512dq", HasAVX512DQ)
4181 .Case("avx512bw", HasAVX512BW)
4182 .Case("avx512vl", HasAVX512VL)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004183 .Case("avx512vbmi", HasAVX512VBMI)
4184 .Case("avx512ifma", HasAVX512IFMA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004185 .Case("bmi", HasBMI)
4186 .Case("bmi2", HasBMI2)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004187 .Case("clflushopt", HasCLFLUSHOPT)
4188 .Case("clwb", HasCLWB)
Craig Topper45742262017-02-09 06:10:14 +00004189 .Case("clzero", HasCLZERO)
Nick Lewycky50e8f482013-10-05 20:14:27 +00004190 .Case("cx16", HasCX16)
4191 .Case("f16c", HasF16C)
Craig Topperbba778b2012-06-03 21:46:30 +00004192 .Case("fma", HasFMA)
Rafael Espindolae62e2792013-08-20 13:44:29 +00004193 .Case("fma4", XOPLevel >= FMA4)
Craig Topper8c7f2512014-11-03 06:51:41 +00004194 .Case("fsgsbase", HasFSGSBASE)
Craig Toppere33f51f2015-10-16 06:22:36 +00004195 .Case("fxsr", HasFXSR)
Craig Topper8dbc5842014-11-03 07:05:26 +00004196 .Case("lzcnt", HasLZCNT)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004197 .Case("mm3dnow", MMX3DNowLevel >= AMD3DNow)
4198 .Case("mm3dnowa", MMX3DNowLevel >= AMD3DNowAthlon)
4199 .Case("mmx", MMX3DNowLevel >= MMX)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004200 .Case("movbe", HasMOVBE)
4201 .Case("mpx", HasMPX)
Craig Topper3f122a72012-05-31 05:18:48 +00004202 .Case("pclmul", HasPCLMUL)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004203 .Case("pku", HasPKU)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004204 .Case("popcnt", HasPOPCNT)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004205 .Case("prefetchwt1", HasPREFETCHWT1)
Michael Liao74f4eaf2013-03-26 17:52:08 +00004206 .Case("prfchw", HasPRFCHW)
Craig Topper8dbc5842014-11-03 07:05:26 +00004207 .Case("rdrnd", HasRDRND)
Michael Liaoffaae352013-03-29 05:17:55 +00004208 .Case("rdseed", HasRDSEED)
Craig Topper8dbc5842014-11-03 07:05:26 +00004209 .Case("rtm", HasRTM)
Elena Demikhovskya89df0c2016-02-21 07:41:23 +00004210 .Case("sgx", HasSGX)
Ben Langmuir58078d02013-09-19 13:22:04 +00004211 .Case("sha", HasSHA)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004212 .Case("sse", SSELevel >= SSE1)
4213 .Case("sse2", SSELevel >= SSE2)
4214 .Case("sse3", SSELevel >= SSE3)
4215 .Case("ssse3", SSELevel >= SSSE3)
Rafael Espindola89049822013-08-23 20:21:37 +00004216 .Case("sse4.1", SSELevel >= SSE41)
4217 .Case("sse4.2", SSELevel >= SSE42)
Rafael Espindolae62e2792013-08-20 13:44:29 +00004218 .Case("sse4a", XOPLevel >= SSE4A)
Craig Topper8dbc5842014-11-03 07:05:26 +00004219 .Case("tbm", HasTBM)
Simon Pilgrim35113482017-05-08 12:09:45 +00004220 .Case("lwp", HasLWP)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004221 .Case("x86", true)
Derek Schuffc7dd7222012-10-11 15:52:22 +00004222 .Case("x86_32", getTriple().getArch() == llvm::Triple::x86)
4223 .Case("x86_64", getTriple().getArch() == llvm::Triple::x86_64)
Rafael Espindolae62e2792013-08-20 13:44:29 +00004224 .Case("xop", XOPLevel >= XOP)
Craig Topperda9fe562015-10-15 05:23:38 +00004225 .Case("xsave", HasXSAVE)
4226 .Case("xsavec", HasXSAVEC)
4227 .Case("xsaves", HasXSAVES)
4228 .Case("xsaveopt", HasXSAVEOPT)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00004229 .Default(false);
4230}
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00004231
Eric Christopherd9832702015-06-29 21:00:05 +00004232// We can't use a generic validation scheme for the features accepted here
4233// versus subtarget features accepted in the target attribute because the
4234// bitfield structure that's initialized in the runtime only supports the
4235// below currently rather than the full range of subtarget features. (See
4236// X86TargetInfo::hasFeature for a somewhat comprehensive list).
4237bool X86TargetInfo::validateCpuSupports(StringRef FeatureStr) const {
4238 return llvm::StringSwitch<bool>(FeatureStr)
4239 .Case("cmov", true)
4240 .Case("mmx", true)
4241 .Case("popcnt", true)
4242 .Case("sse", true)
4243 .Case("sse2", true)
4244 .Case("sse3", true)
Benjamin Kramerf4c520d2016-05-20 15:21:08 +00004245 .Case("ssse3", true)
Eric Christopherd9832702015-06-29 21:00:05 +00004246 .Case("sse4.1", true)
4247 .Case("sse4.2", true)
4248 .Case("avx", true)
4249 .Case("avx2", true)
4250 .Case("sse4a", true)
4251 .Case("fma4", true)
4252 .Case("xop", true)
4253 .Case("fma", true)
4254 .Case("avx512f", true)
4255 .Case("bmi", true)
4256 .Case("bmi2", true)
Benjamin Kramerf4c520d2016-05-20 15:21:08 +00004257 .Case("aes", true)
4258 .Case("pclmul", true)
4259 .Case("avx512vl", true)
4260 .Case("avx512bw", true)
4261 .Case("avx512dq", true)
4262 .Case("avx512cd", true)
Oren Ben Simhon140c1fb2017-05-25 13:44:11 +00004263 .Case("avx512vpopcntdq", true)
Benjamin Kramerf4c520d2016-05-20 15:21:08 +00004264 .Case("avx512er", true)
4265 .Case("avx512pf", true)
4266 .Case("avx512vbmi", true)
4267 .Case("avx512ifma", true)
Eric Christopherd9832702015-06-29 21:00:05 +00004268 .Default(false);
4269}
4270
Eli Friedman3fd920a2008-08-20 02:34:37 +00004271bool
Anders Carlsson58436352009-02-28 17:11:49 +00004272X86TargetInfo::validateAsmConstraint(const char *&Name,
Chris Lattnerd9725f72009-04-26 07:16:29 +00004273 TargetInfo::ConstraintInfo &Info) const {
Anders Carlsson58436352009-02-28 17:11:49 +00004274 switch (*Name) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00004275 default: return false;
Alexey Bataev91e58602015-07-20 12:08:00 +00004276 // Constant constraints.
4277 case 'e': // 32-bit signed integer constant for use with sign-extending x86_64
4278 // instructions.
4279 case 'Z': // 32-bit unsigned integer constant for use with zero-extending
4280 // x86_64 instructions.
4281 case 's':
4282 Info.setRequiresImmediate();
4283 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00004284 case 'I':
4285 Info.setRequiresImmediate(0, 31);
4286 return true;
4287 case 'J':
4288 Info.setRequiresImmediate(0, 63);
4289 return true;
4290 case 'K':
4291 Info.setRequiresImmediate(-128, 127);
4292 return true;
4293 case 'L':
Alexey Bataev91e58602015-07-20 12:08:00 +00004294 Info.setRequiresImmediate({ int(0xff), int(0xffff), int(0xffffffff) });
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00004295 return true;
4296 case 'M':
4297 Info.setRequiresImmediate(0, 3);
4298 return true;
4299 case 'N':
4300 Info.setRequiresImmediate(0, 255);
4301 return true;
4302 case 'O':
4303 Info.setRequiresImmediate(0, 127);
4304 return true;
Alexey Bataev91e58602015-07-20 12:08:00 +00004305 // Register constraints.
4306 case 'Y': // 'Y' is the first character for several 2-character constraints.
4307 // Shift the pointer to the second character of the constraint.
4308 Name++;
4309 switch (*Name) {
4310 default:
4311 return false;
4312 case '0': // First SSE register.
4313 case 't': // Any SSE register, when SSE2 is enabled.
4314 case 'i': // Any SSE register, when SSE2 and inter-unit moves enabled.
4315 case 'm': // Any MMX register, when inter-unit moves enabled.
Michael Zuckerman849a6a52016-10-31 17:23:52 +00004316 case 'k': // AVX512 arch mask registers: k1-k7.
Alexey Bataev91e58602015-07-20 12:08:00 +00004317 Info.setAllowsRegister();
4318 return true;
4319 }
4320 case 'f': // Any x87 floating point stack register.
Akira Hatanaka88ef7282014-07-18 23:30:30 +00004321 // Constraint 'f' cannot be used for output operands.
4322 if (Info.ConstraintStr[0] == '=')
4323 return false;
Akira Hatanaka88ef7282014-07-18 23:30:30 +00004324 Info.setAllowsRegister();
4325 return true;
Eli Friedman3fd920a2008-08-20 02:34:37 +00004326 case 'a': // eax.
4327 case 'b': // ebx.
4328 case 'c': // ecx.
4329 case 'd': // edx.
4330 case 'S': // esi.
4331 case 'D': // edi.
4332 case 'A': // edx:eax.
Alexey Bataev91e58602015-07-20 12:08:00 +00004333 case 't': // Top of floating point stack.
4334 case 'u': // Second from top of floating point stack.
Eli Friedman3fd920a2008-08-20 02:34:37 +00004335 case 'q': // Any register accessible as [r]l: a, b, c, and d.
Anders Carlsson83661ac2008-10-06 00:41:45 +00004336 case 'y': // Any MMX register.
Michael Zuckerman62f516f2016-11-01 13:16:44 +00004337 case 'v': // Any {X,Y,Z}MM register (Arch & context dependent)
Anders Carlsson5f7ee682008-10-06 19:17:39 +00004338 case 'x': // Any SSE register.
Michael Zuckerman849a6a52016-10-31 17:23:52 +00004339 case 'k': // Any AVX512 mask register (same as Yk, additionaly allows k0
4340 // for intermideate k reg operations).
Eli Friedman3fd920a2008-08-20 02:34:37 +00004341 case 'Q': // Any register accessible as [r]h: a, b, c, and d.
Dale Johannesen46742a42010-08-24 22:33:12 +00004342 case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.
4343 case 'l': // "Index" registers: any general register that can be used as an
4344 // index in a base+index memory access.
4345 Info.setAllowsRegister();
4346 return true;
Alexey Bataev91e58602015-07-20 12:08:00 +00004347 // Floating point constant constraints.
Dale Johannesen46742a42010-08-24 22:33:12 +00004348 case 'C': // SSE floating point constant.
4349 case 'G': // x87 floating point constant.
Eli Friedman3fd920a2008-08-20 02:34:37 +00004350 return true;
4351 }
4352}
4353
Akira Hatanaka974131e2014-09-18 18:17:18 +00004354bool X86TargetInfo::validateOutputSize(StringRef Constraint,
4355 unsigned Size) const {
4356 // Strip off constraint modifiers.
4357 while (Constraint[0] == '=' ||
4358 Constraint[0] == '+' ||
4359 Constraint[0] == '&')
4360 Constraint = Constraint.substr(1);
4361
4362 return validateOperandSize(Constraint, Size);
4363}
4364
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004365bool X86TargetInfo::validateInputSize(StringRef Constraint,
4366 unsigned Size) const {
Akira Hatanaka974131e2014-09-18 18:17:18 +00004367 return validateOperandSize(Constraint, Size);
4368}
4369
4370bool X86TargetInfo::validateOperandSize(StringRef Constraint,
4371 unsigned Size) const {
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004372 switch (Constraint[0]) {
4373 default: break;
Michael Zuckerman849a6a52016-10-31 17:23:52 +00004374 case 'k':
4375 // Registers k0-k7 (AVX512) size limit is 64 bit.
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004376 case 'y':
4377 return Size <= 64;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004378 case 'f':
4379 case 't':
4380 case 'u':
4381 return Size <= 128;
Michael Zuckerman62f516f2016-11-01 13:16:44 +00004382 case 'v':
Hans Wennborg3c619a42014-09-18 20:24:04 +00004383 case 'x':
Alexey Bataev91e58602015-07-20 12:08:00 +00004384 if (SSELevel >= AVX512F)
4385 // 512-bit zmm registers can be used if target supports AVX512F.
4386 return Size <= 512U;
4387 else if (SSELevel >= AVX)
4388 // 256-bit ymm registers can be used if target supports AVX.
4389 return Size <= 256U;
4390 return Size <= 128U;
4391 case 'Y':
4392 // 'Y' is the first character for several 2-character constraints.
4393 switch (Constraint[1]) {
4394 default: break;
4395 case 'm':
4396 // 'Ym' is synonymous with 'y'.
Michael Zuckerman849a6a52016-10-31 17:23:52 +00004397 case 'k':
Alexey Bataev91e58602015-07-20 12:08:00 +00004398 return Size <= 64;
4399 case 'i':
4400 case 't':
4401 // 'Yi' and 'Yt' are synonymous with 'x' when SSE2 is enabled.
4402 if (SSELevel >= AVX512F)
4403 return Size <= 512U;
4404 else if (SSELevel >= AVX)
4405 return Size <= 256U;
4406 return SSELevel >= SSE2 && Size <= 128U;
4407 }
4408
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004409 }
4410
4411 return true;
4412}
Dale Johannesen7d3dfc02010-10-29 23:12:32 +00004413
Eli Friedman3fd920a2008-08-20 02:34:37 +00004414std::string
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004415X86TargetInfo::convertConstraint(const char *&Constraint) const {
4416 switch (*Constraint) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00004417 case 'a': return std::string("{ax}");
4418 case 'b': return std::string("{bx}");
4419 case 'c': return std::string("{cx}");
4420 case 'd': return std::string("{dx}");
4421 case 'S': return std::string("{si}");
4422 case 'D': return std::string("{di}");
Dale Johannesen70f564e2010-10-22 21:07:10 +00004423 case 'p': // address
4424 return std::string("im");
Eli Friedman3fd920a2008-08-20 02:34:37 +00004425 case 't': // top of floating point stack.
4426 return std::string("{st}");
4427 case 'u': // second from top of floating point stack.
4428 return std::string("{st(1)}"); // second from top of floating point stack.
Michael Zuckerman849a6a52016-10-31 17:23:52 +00004429 case 'Y':
4430 switch (Constraint[1]) {
4431 default:
4432 // Break from inner switch and fall through (copy single char),
4433 // continue parsing after copying the current constraint into
4434 // the return string.
4435 break;
4436 case 'k':
4437 // "^" hints llvm that this is a 2 letter constraint.
4438 // "Constraint++" is used to promote the string iterator
4439 // to the next constraint.
4440 return std::string("^") + std::string(Constraint++, 2);
4441 }
4442 LLVM_FALLTHROUGH;
Eli Friedman3fd920a2008-08-20 02:34:37 +00004443 default:
Stuart Hastings7fdc6702011-06-07 23:45:05 +00004444 return std::string(1, *Constraint);
Eli Friedman3fd920a2008-08-20 02:34:37 +00004445 }
4446}
Chris Lattner5ba61f02006-10-14 07:39:34 +00004447
Eli Friedman3fd920a2008-08-20 02:34:37 +00004448// X86-32 generic target
4449class X86_32TargetInfo : public X86TargetInfo {
Chris Lattner5ba61f02006-10-14 07:39:34 +00004450public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004451 X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4452 : X86TargetInfo(Triple, Opts) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00004453 DoubleAlign = LongLongAlign = 32;
4454 LongDoubleWidth = 96;
4455 LongDoubleAlign = 32;
Nick Lewyckyf243e0d2011-12-21 04:25:47 +00004456 SuitableAlign = 128;
James Y Knightb214cbc2016-03-04 19:00:41 +00004457 resetDataLayout("e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128");
Eli Friedman32ca82a2009-03-29 20:31:09 +00004458 SizeType = UnsignedInt;
4459 PtrDiffType = SignedInt;
4460 IntPtrType = SignedInt;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00004461 RegParmMax = 3;
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00004462
4463 // Use fpret for all types.
4464 RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
4465 (1 << TargetInfo::Double) |
4466 (1 << TargetInfo::LongDouble));
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004467
4468 // x86-32 has atomics up to 8 bytes
4469 // FIXME: Check that we actually have cmpxchg8b before setting
4470 // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
4471 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Eli Friedman3fd920a2008-08-20 02:34:37 +00004472 }
Craig Topper3164f332014-03-11 03:39:26 +00004473 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004474 return TargetInfo::CharPtrBuiltinVaList;
Eli Friedman3fd920a2008-08-20 02:34:37 +00004475 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00004476
Craig Topper3164f332014-03-11 03:39:26 +00004477 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00004478 if (RegNo == 0) return 0;
4479 if (RegNo == 1) return 2;
4480 return -1;
4481 }
Akira Hatanaka974131e2014-09-18 18:17:18 +00004482 bool validateOperandSize(StringRef Constraint,
4483 unsigned Size) const override {
Bill Wendling887b4852012-11-12 06:42:51 +00004484 switch (Constraint[0]) {
4485 default: break;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004486 case 'R':
4487 case 'q':
4488 case 'Q':
Bill Wendling887b4852012-11-12 06:42:51 +00004489 case 'a':
4490 case 'b':
4491 case 'c':
4492 case 'd':
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004493 case 'S':
4494 case 'D':
Bill Wendling3c7fed82012-11-12 18:52:32 +00004495 return Size <= 32;
Akira Hatanaka31c6d3b2014-09-17 23:35:14 +00004496 case 'A':
4497 return Size <= 64;
Bill Wendling887b4852012-11-12 06:42:51 +00004498 }
4499
Akira Hatanaka974131e2014-09-18 18:17:18 +00004500 return X86TargetInfo::validateOperandSize(Constraint, Size);
Bill Wendling887b4852012-11-12 06:42:51 +00004501 }
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00004502 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
4503 return llvm::makeArrayRef(BuiltinInfoX86, clang::X86::LastX86CommonBuiltin -
4504 Builtin::FirstTSBuiltin + 1);
4505 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00004506};
Eli Friedman3fd920a2008-08-20 02:34:37 +00004507
Joerg Sonnenberger16237142012-01-06 18:32:26 +00004508class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
4509public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004510 NetBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4511 : NetBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {}
Joerg Sonnenberger16237142012-01-06 18:32:26 +00004512
Craig Topper3164f332014-03-11 03:39:26 +00004513 unsigned getFloatEvalMethod() const override {
Joerg Sonnenberger0e921f22013-11-11 14:00:37 +00004514 unsigned Major, Minor, Micro;
4515 getTriple().getOSVersion(Major, Minor, Micro);
4516 // New NetBSD uses the default rounding mode.
4517 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 26) || Major == 0)
4518 return X86_32TargetInfo::getFloatEvalMethod();
4519 // NetBSD before 6.99.26 defaults to "double" rounding.
Joerg Sonnenberger16237142012-01-06 18:32:26 +00004520 return 1;
4521 }
4522};
Joerg Sonnenberger16237142012-01-06 18:32:26 +00004523
Eli Friedmane3aa4542009-07-05 18:47:56 +00004524class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
4525public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004526 OpenBSDI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4527 : OpenBSDTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Eli Friedmane3aa4542009-07-05 18:47:56 +00004528 SizeType = UnsignedLong;
4529 IntPtrType = SignedLong;
Eli Friedman245f2292009-07-05 22:31:18 +00004530 PtrDiffType = SignedLong;
Eli Friedmane3aa4542009-07-05 18:47:56 +00004531 }
4532};
Eli Friedmane3aa4542009-07-05 18:47:56 +00004533
Eli Friedman9fa28852012-08-08 23:57:20 +00004534class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
4535public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004536 BitrigI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4537 : BitrigTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Eli Friedman9fa28852012-08-08 23:57:20 +00004538 SizeType = UnsignedLong;
4539 IntPtrType = SignedLong;
4540 PtrDiffType = SignedLong;
4541 }
4542};
Eli Friedman9fa28852012-08-08 23:57:20 +00004543
Torok Edwinb2b37c62009-06-30 17:10:35 +00004544class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
Eli Friedman3fd920a2008-08-20 02:34:37 +00004545public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004546 DarwinI386TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4547 : DarwinTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Eli Friedman3fd920a2008-08-20 02:34:37 +00004548 LongDoubleWidth = 128;
4549 LongDoubleAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00004550 SuitableAlign = 128;
Tim Northover5627d392015-10-30 16:30:45 +00004551 MaxVectorAlign = 256;
4552 // The watchOS simulator uses the builtin bool type for Objective-C.
4553 llvm::Triple T = llvm::Triple(Triple);
4554 if (T.isWatchOS())
4555 UseSignedCharForObjCBool = false;
Eli Friedman32ca82a2009-03-29 20:31:09 +00004556 SizeType = UnsignedLong;
4557 IntPtrType = SignedLong;
James Y Knightb214cbc2016-03-04 19:00:41 +00004558 resetDataLayout("e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128");
Daniel Dunbarbd606522010-05-27 00:35:16 +00004559 HasAlignMac68kSupport = true;
Torok Edwin4e054162009-06-30 17:00:25 +00004560 }
4561
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004562 bool handleTargetFeatures(std::vector<std::string> &Features,
4563 DiagnosticsEngine &Diags) override {
4564 if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
4565 Diags))
4566 return false;
Ahmed Bougacha02b7b562015-08-27 22:42:12 +00004567 // We now know the features we have: we can decide how to align vectors.
4568 MaxVectorAlign =
4569 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004570 return true;
4571 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00004572};
Daniel Dunbar10de9e62009-06-29 20:52:51 +00004573
Eli Friedmanc968a6a2008-08-21 01:40:19 +00004574// x86-32 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004575class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
Eli Friedmanc968a6a2008-08-21 01:40:19 +00004576public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004577 WindowsX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4578 : WindowsTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Chris Lattner46be2e12009-06-24 17:12:15 +00004579 WCharType = UnsignedShort;
Eli Friedmanebb9e4d2009-06-08 21:16:17 +00004580 DoubleAlign = LongLongAlign = 64;
Reid Kleckner7510c092015-04-01 16:45:06 +00004581 bool IsWinCOFF =
4582 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
James Y Knightb214cbc2016-03-04 19:00:41 +00004583 resetDataLayout(IsWinCOFF
4584 ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
4585 : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
Eli Friedmanc968a6a2008-08-21 01:40:19 +00004586 }
Craig Topper3164f332014-03-11 03:39:26 +00004587 void getTargetDefines(const LangOptions &Opts,
4588 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004589 WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
4590 }
4591};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004592
4593// x86-32 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00004594class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004595public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004596 MicrosoftX86_32TargetInfo(const llvm::Triple &Triple,
4597 const TargetOptions &Opts)
4598 : WindowsX86_32TargetInfo(Triple, Opts) {
Eli Friedman015d6282011-03-22 21:25:11 +00004599 LongDoubleWidth = LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00004600 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004601 }
Craig Topper3164f332014-03-11 03:39:26 +00004602 void getTargetDefines(const LangOptions &Opts,
4603 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004604 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
4605 WindowsX86_32TargetInfo::getVisualStudioDefines(Opts, Builder);
4606 // The value of the following reflects processor type.
4607 // 300=386, 400=486, 500=Pentium, 600=Blend (default)
4608 // We lost the original triple, so we use the default.
4609 Builder.defineMacro("_M_IX86", "600");
4610 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004611};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004612
David Majnemerae1ed0e2015-05-28 04:36:18 +00004613static void addCygMingDefines(const LangOptions &Opts, MacroBuilder &Builder) {
Eric Christopherb093d692015-10-09 18:39:59 +00004614 // Mingw and cygwin define __declspec(a) to __attribute__((a)). Clang
4615 // supports __declspec natively under -fms-extensions, but we define a no-op
4616 // __declspec macro anyway for pre-processor compatibility.
Reid Kleckner47606832014-04-21 20:58:00 +00004617 if (Opts.MicrosoftExt)
4618 Builder.defineMacro("__declspec", "__declspec");
4619 else
4620 Builder.defineMacro("__declspec(a)", "__attribute__((a))");
4621
4622 if (!Opts.MicrosoftExt) {
4623 // Provide macros for all the calling convention keywords. Provide both
4624 // single and double underscore prefixed variants. These are available on
4625 // x64 as well as x86, even though they have no effect.
4626 const char *CCs[] = {"cdecl", "stdcall", "fastcall", "thiscall", "pascal"};
4627 for (const char *CC : CCs) {
Reid Kleckner70cfa662014-04-21 22:29:45 +00004628 std::string GCCSpelling = "__attribute__((__";
4629 GCCSpelling += CC;
4630 GCCSpelling += "__))";
Reid Kleckner47606832014-04-21 20:58:00 +00004631 Builder.defineMacro(Twine("_") + CC, GCCSpelling);
4632 Builder.defineMacro(Twine("__") + CC, GCCSpelling);
4633 }
4634 }
4635}
4636
David Majnemerae1ed0e2015-05-28 04:36:18 +00004637static void addMinGWDefines(const LangOptions &Opts, MacroBuilder &Builder) {
4638 Builder.defineMacro("__MSVCRT__");
4639 Builder.defineMacro("__MINGW32__");
4640 addCygMingDefines(Opts, Builder);
4641}
4642
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004643// x86-32 MinGW target
4644class MinGWX86_32TargetInfo : public WindowsX86_32TargetInfo {
4645public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004646 MinGWX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4647 : WindowsX86_32TargetInfo(Triple, Opts) {}
Craig Topper3164f332014-03-11 03:39:26 +00004648 void getTargetDefines(const LangOptions &Opts,
4649 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004650 WindowsX86_32TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004651 DefineStd(Builder, "WIN32", Opts);
4652 DefineStd(Builder, "WINNT", Opts);
4653 Builder.defineMacro("_X86_");
Reid Kleckner47606832014-04-21 20:58:00 +00004654 addMinGWDefines(Opts, Builder);
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004655 }
4656};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004657
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004658// x86-32 Cygwin target
4659class CygwinX86_32TargetInfo : public X86_32TargetInfo {
4660public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004661 CygwinX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4662 : X86_32TargetInfo(Triple, Opts) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004663 WCharType = UnsignedShort;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004664 DoubleAlign = LongLongAlign = 64;
James Y Knightb214cbc2016-03-04 19:00:41 +00004665 resetDataLayout("e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004666 }
Craig Topper3164f332014-03-11 03:39:26 +00004667 void getTargetDefines(const LangOptions &Opts,
4668 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004669 X86_32TargetInfo::getTargetDefines(Opts, Builder);
NAKAMURA Takumi02f43952012-12-14 10:17:26 +00004670 Builder.defineMacro("_X86_");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004671 Builder.defineMacro("__CYGWIN__");
4672 Builder.defineMacro("__CYGWIN32__");
David Majnemerae1ed0e2015-05-28 04:36:18 +00004673 addCygMingDefines(Opts, Builder);
Saleem Abdulrasool56027092017-02-07 19:00:06 +00004674 DefineStd(Builder, "unix", Opts);
Douglas Gregor3ecc6652010-04-21 05:52:38 +00004675 if (Opts.CPlusPlus)
4676 Builder.defineMacro("_GNU_SOURCE");
Eli Friedmanaa27a872009-06-08 06:11:14 +00004677 }
Eli Friedmanc968a6a2008-08-21 01:40:19 +00004678};
Eli Friedmanc968a6a2008-08-21 01:40:19 +00004679
Chris Lattnerb986aba2010-04-11 19:29:39 +00004680// x86-32 Haiku target
Reid Kleckner330fb172016-05-11 16:19:05 +00004681class HaikuX86_32TargetInfo : public HaikuTargetInfo<X86_32TargetInfo> {
Chris Lattnerb986aba2010-04-11 19:29:39 +00004682public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004683 HaikuX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Reid Kleckner330fb172016-05-11 16:19:05 +00004684 : HaikuTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Eli Friedman04831922010-08-22 01:00:03 +00004685 }
Craig Topper3164f332014-03-11 03:39:26 +00004686 void getTargetDefines(const LangOptions &Opts,
4687 MacroBuilder &Builder) const override {
Reid Kleckner330fb172016-05-11 16:19:05 +00004688 HaikuTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
Chris Lattnerb986aba2010-04-11 19:29:39 +00004689 Builder.defineMacro("__INTEL__");
Chris Lattnerb986aba2010-04-11 19:29:39 +00004690 }
4691};
Chris Lattnerb986aba2010-04-11 19:29:39 +00004692
Alexey Bataevc99b0492015-11-25 09:24:26 +00004693// X86-32 MCU target
4694class MCUX86_32TargetInfo : public X86_32TargetInfo {
4695public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004696 MCUX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4697 : X86_32TargetInfo(Triple, Opts) {
Alexey Bataevc99b0492015-11-25 09:24:26 +00004698 LongDoubleWidth = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00004699 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
James Y Knightb214cbc2016-03-04 19:00:41 +00004700 resetDataLayout("e-m:e-p:32:32-i64:32-f64:32-f128:32-n8:16:32-a:0:32-S32");
Andrey Bokhanko6e34c1d2016-02-04 11:54:45 +00004701 WIntType = UnsignedInt;
Alexey Bataevc99b0492015-11-25 09:24:26 +00004702 }
4703
4704 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
4705 // On MCU we support only C calling convention.
4706 return CC == CC_C ? CCCR_OK : CCCR_Warning;
4707 }
4708
4709 void getTargetDefines(const LangOptions &Opts,
4710 MacroBuilder &Builder) const override {
4711 X86_32TargetInfo::getTargetDefines(Opts, Builder);
4712 Builder.defineMacro("__iamcu");
4713 Builder.defineMacro("__iamcu__");
4714 }
Andrey Turetskiydb6655f2016-02-10 11:58:46 +00004715
4716 bool allowsLargerPreferedTypeAlignment() const override {
4717 return false;
4718 }
Alexey Bataevc99b0492015-11-25 09:24:26 +00004719};
4720
Douglas Gregor9fabd852011-07-01 22:41:14 +00004721// RTEMS Target
4722template<typename Target>
4723class RTEMSTargetInfo : public OSTargetInfo<Target> {
4724protected:
Craig Topper3164f332014-03-11 03:39:26 +00004725 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
4726 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00004727 // RTEMS defines; list based off of gcc output
4728
Douglas Gregor9fabd852011-07-01 22:41:14 +00004729 Builder.defineMacro("__rtems__");
4730 Builder.defineMacro("__ELF__");
4731 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004732
Douglas Gregor9fabd852011-07-01 22:41:14 +00004733public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004734 RTEMSTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4735 : OSTargetInfo<Target>(Triple, Opts) {
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004736 switch (Triple.getArch()) {
4737 default:
4738 case llvm::Triple::x86:
4739 // this->MCountName = ".mcount";
4740 break;
4741 case llvm::Triple::mips:
4742 case llvm::Triple::mipsel:
4743 case llvm::Triple::ppc:
4744 case llvm::Triple::ppc64:
Bill Schmidt778d3872013-07-26 01:36:11 +00004745 case llvm::Triple::ppc64le:
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004746 // this->MCountName = "_mcount";
4747 break;
4748 case llvm::Triple::arm:
4749 // this->MCountName = "__mcount";
4750 break;
Douglas Gregor9fabd852011-07-01 22:41:14 +00004751 }
Benjamin Kramerb1276b42013-06-29 16:37:14 +00004752 }
Douglas Gregor9fabd852011-07-01 22:41:14 +00004753};
4754
Douglas Gregor9fabd852011-07-01 22:41:14 +00004755// x86-32 RTEMS target
4756class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
4757public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004758 RTEMSX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4759 : X86_32TargetInfo(Triple, Opts) {
Douglas Gregor9fabd852011-07-01 22:41:14 +00004760 SizeType = UnsignedLong;
4761 IntPtrType = SignedLong;
4762 PtrDiffType = SignedLong;
Douglas Gregor9fabd852011-07-01 22:41:14 +00004763 }
Craig Topper3164f332014-03-11 03:39:26 +00004764 void getTargetDefines(const LangOptions &Opts,
4765 MacroBuilder &Builder) const override {
Douglas Gregor9fabd852011-07-01 22:41:14 +00004766 X86_32TargetInfo::getTargetDefines(Opts, Builder);
4767 Builder.defineMacro("__INTEL__");
4768 Builder.defineMacro("__rtems__");
4769 }
4770};
Douglas Gregor9fabd852011-07-01 22:41:14 +00004771
Eli Friedman3fd920a2008-08-20 02:34:37 +00004772// x86-64 generic target
4773class X86_64TargetInfo : public X86TargetInfo {
4774public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004775 X86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4776 : X86TargetInfo(Triple, Opts) {
David Blaikie40f842d2014-07-10 18:46:15 +00004777 const bool IsX32 = getTriple().getEnvironment() == llvm::Triple::GNUX32;
David Majnemer8fa8c382015-03-17 23:55:00 +00004778 bool IsWinCOFF =
4779 getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
Zinovy Nis1db95732014-07-10 15:27:19 +00004780 LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
Eli Friedmanb5366062008-05-20 14:21:01 +00004781 LongDoubleWidth = 128;
4782 LongDoubleAlign = 128;
Rafael Espindolae971b9a2010-06-04 23:15:27 +00004783 LargeArrayMinWidth = 128;
4784 LargeArrayAlign = 128;
Nick Lewyckyf59e1292011-12-16 22:34:14 +00004785 SuitableAlign = 128;
Zinovy Nis1db95732014-07-10 15:27:19 +00004786 SizeType = IsX32 ? UnsignedInt : UnsignedLong;
4787 PtrDiffType = IsX32 ? SignedInt : SignedLong;
4788 IntPtrType = IsX32 ? SignedInt : SignedLong;
4789 IntMaxType = IsX32 ? SignedLongLong : SignedLong;
Zinovy Nis1db95732014-07-10 15:27:19 +00004790 Int64Type = IsX32 ? SignedLongLong : SignedLong;
Anton Korobeynikov6953ef22009-04-03 23:38:25 +00004791 RegParmMax = 6;
Chris Lattnerd0a79b22009-02-05 07:32:46 +00004792
Eric Christopher917e9522014-11-18 22:36:15 +00004793 // Pointers are 32-bit in x32.
Eric Christopherf6ee1f32017-02-10 04:35:21 +00004794 resetDataLayout(IsX32
4795 ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
4796 : IsWinCOFF ? "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
4797 : "e-m:e-i64:64-f80:128-n8:16:32:64-S128");
Daniel Dunbar6f2e8392010-07-14 23:39:36 +00004798
4799 // Use fpret only for long double.
4800 RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004801
Anders Carlsson2f1a6c32011-10-31 16:27:11 +00004802 // Use fp2ret for _Complex long double.
4803 ComplexLongDoubleUsesFP2Ret = true;
4804
Charles Davisc7d5c942015-09-17 20:55:33 +00004805 // Make __builtin_ms_va_list available.
4806 HasBuiltinMSVaList = true;
4807
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004808 // x86-64 has atomics up to 16 bytes.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00004809 MaxAtomicPromoteWidth = 128;
Tim Northover1471cb12014-07-02 10:25:45 +00004810 MaxAtomicInlineWidth = 128;
Chris Lattner10a5b382007-01-29 05:24:35 +00004811 }
Craig Topper3164f332014-03-11 03:39:26 +00004812 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004813 return TargetInfo::X86_64ABIBuiltinVaList;
Anders Carlsson5fa3f342007-11-24 23:38:12 +00004814 }
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00004815
Craig Topper3164f332014-03-11 03:39:26 +00004816 int getEHDataRegisterNumber(unsigned RegNo) const override {
Chris Lattnerd545ad12009-09-23 06:06:36 +00004817 if (RegNo == 0) return 0;
4818 if (RegNo == 1) return 1;
4819 return -1;
4820 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004821
Craig Topper3164f332014-03-11 03:39:26 +00004822 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
John McCall477f2bb2016-03-03 06:39:32 +00004823 switch (CC) {
4824 case CC_C:
4825 case CC_Swift:
4826 case CC_X86VectorCall:
4827 case CC_IntelOclBicc:
4828 case CC_X86_64Win64:
Roman Levenstein35aa5ce2016-03-16 18:00:46 +00004829 case CC_PreserveMost:
4830 case CC_PreserveAll:
Erich Keane757d3172016-11-02 18:29:35 +00004831 case CC_X86RegCall:
John McCall477f2bb2016-03-03 06:39:32 +00004832 return CCCR_OK;
4833 default:
4834 return CCCR_Warning;
4835 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004836 }
4837
Craig Topper3164f332014-03-11 03:39:26 +00004838 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
Aaron Ballman02df2e02012-12-09 17:45:41 +00004839 return CC_C;
Aaron Ballmane91c6be2012-10-02 14:26:08 +00004840 }
4841
Pavel Chupinfd223e12014-08-04 12:39:43 +00004842 // for x32 we need it here explicitly
4843 bool hasInt128Type() const override { return true; }
Reid Klecknerf27e7522016-02-01 18:58:24 +00004844 unsigned getUnwindWordWidth() const override { return 64; }
4845 unsigned getRegisterWidth() const override { return 64; }
Akira Hatanaka8c26ea62015-11-18 00:15:28 +00004846
4847 bool validateGlobalRegisterVariable(StringRef RegName,
4848 unsigned RegSize,
4849 bool &HasSizeMismatch) const override {
4850 // rsp and rbp are the only 64-bit registers the x86 backend can currently
4851 // handle.
4852 if (RegName.equals("rsp") || RegName.equals("rbp")) {
4853 // Check that the register size is 64-bit.
4854 HasSizeMismatch = RegSize != 64;
4855 return true;
4856 }
4857
4858 // Check if the register is a 32-bit register the backend can handle.
4859 return X86TargetInfo::validateGlobalRegisterVariable(RegName, RegSize,
4860 HasSizeMismatch);
4861 }
Albert Gutowskif3a0bce2016-10-04 22:29:49 +00004862 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
4863 return llvm::makeArrayRef(BuiltinInfoX86,
4864 X86::LastTSBuiltin - Builtin::FirstTSBuiltin);
4865 }
Eli Friedman3fd920a2008-08-20 02:34:37 +00004866};
Eli Friedman3fd920a2008-08-20 02:34:37 +00004867
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004868// x86-64 Windows target
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004869class WindowsX86_64TargetInfo : public WindowsTargetInfo<X86_64TargetInfo> {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004870public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004871 WindowsX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4872 : WindowsTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004873 WCharType = UnsignedShort;
Mike Stumpaf9afe92009-10-08 23:00:00 +00004874 LongWidth = LongAlign = 32;
Michael J. Spencerfeb799c2010-10-18 07:10:59 +00004875 DoubleAlign = LongLongAlign = 64;
Nate Begeman6e8865a2010-07-21 02:02:56 +00004876 IntMaxType = SignedLongLong;
Nate Begeman6e8865a2010-07-21 02:02:56 +00004877 Int64Type = SignedLongLong;
Cameron Esfahanieb856502010-09-15 00:28:12 +00004878 SizeType = UnsignedLongLong;
4879 PtrDiffType = SignedLongLong;
4880 IntPtrType = SignedLongLong;
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004881 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004882
Craig Topper3164f332014-03-11 03:39:26 +00004883 void getTargetDefines(const LangOptions &Opts,
4884 MacroBuilder &Builder) const override {
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004885 WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
Michael J. Spencer4992ca4b2010-10-21 05:21:48 +00004886 Builder.defineMacro("_WIN64");
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004887 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004888
Craig Topper3164f332014-03-11 03:39:26 +00004889 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00004890 return TargetInfo::CharPtrBuiltinVaList;
NAKAMURA Takumia2e468c2011-01-17 22:56:23 +00004891 }
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004892
Craig Topper3164f332014-03-11 03:39:26 +00004893 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004894 switch (CC) {
4895 case CC_X86StdCall:
4896 case CC_X86ThisCall:
4897 case CC_X86FastCall:
4898 return CCCR_Ignore;
4899 case CC_C:
4900 case CC_X86VectorCall:
4901 case CC_IntelOclBicc:
4902 case CC_X86_64SysV:
Arnold Schwaighofer4fc955e2016-10-12 18:59:24 +00004903 case CC_Swift:
Erich Keane757d3172016-11-02 18:29:35 +00004904 case CC_X86RegCall:
Reid Kleckner9fde2e02015-02-26 19:43:46 +00004905 return CCCR_OK;
4906 default:
4907 return CCCR_Warning;
4908 }
Charles Davisb5a214e2013-08-30 04:39:01 +00004909 }
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004910};
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004911
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004912// x86-64 Windows Visual Studio target
Saleem Abdulrasool79ed5d42014-04-04 05:08:53 +00004913class MicrosoftX86_64TargetInfo : public WindowsX86_64TargetInfo {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004914public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004915 MicrosoftX86_64TargetInfo(const llvm::Triple &Triple,
4916 const TargetOptions &Opts)
4917 : WindowsX86_64TargetInfo(Triple, Opts) {
Eli Friedman015d6282011-03-22 21:25:11 +00004918 LongDoubleWidth = LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00004919 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004920 }
Craig Topper3164f332014-03-11 03:39:26 +00004921 void getTargetDefines(const LangOptions &Opts,
4922 MacroBuilder &Builder) const override {
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004923 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
4924 WindowsX86_64TargetInfo::getVisualStudioDefines(Opts, Builder);
David Majnemerb856e8f2015-07-26 23:17:29 +00004925 Builder.defineMacro("_M_X64", "100");
4926 Builder.defineMacro("_M_AMD64", "100");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004927 }
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004928};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004929
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004930// x86-64 MinGW target
4931class MinGWX86_64TargetInfo : public WindowsX86_64TargetInfo {
4932public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004933 MinGWX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4934 : WindowsX86_64TargetInfo(Triple, Opts) {
Reid Kleckner11a17192015-10-28 22:29:52 +00004935 // Mingw64 rounds long double size and alignment up to 16 bytes, but sticks
4936 // with x86 FP ops. Weird.
4937 LongDoubleWidth = LongDoubleAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00004938 LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
Reid Kleckner11a17192015-10-28 22:29:52 +00004939 }
4940
Craig Topper3164f332014-03-11 03:39:26 +00004941 void getTargetDefines(const LangOptions &Opts,
4942 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004943 WindowsX86_64TargetInfo::getTargetDefines(Opts, Builder);
Michael J. Spencer54bf3c32010-10-21 08:22:51 +00004944 DefineStd(Builder, "WIN64", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00004945 Builder.defineMacro("__MINGW64__");
Reid Kleckner47606832014-04-21 20:58:00 +00004946 addMinGWDefines(Opts, Builder);
Reid Klecknere070b992014-11-14 02:01:10 +00004947
4948 // GCC defines this macro when it is using __gxx_personality_seh0.
4949 if (!Opts.SjLjExceptions)
4950 Builder.defineMacro("__SEH__");
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004951 }
4952};
Daniel Dunbar3e7a7232009-09-23 07:31:35 +00004953
Yaron Kerend030d112015-07-22 17:38:19 +00004954// x86-64 Cygwin target
4955class CygwinX86_64TargetInfo : public X86_64TargetInfo {
4956public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004957 CygwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4958 : X86_64TargetInfo(Triple, Opts) {
Yaron Kerend030d112015-07-22 17:38:19 +00004959 TLSSupported = false;
4960 WCharType = UnsignedShort;
4961 }
4962 void getTargetDefines(const LangOptions &Opts,
4963 MacroBuilder &Builder) const override {
4964 X86_64TargetInfo::getTargetDefines(Opts, Builder);
4965 Builder.defineMacro("__x86_64__");
4966 Builder.defineMacro("__CYGWIN__");
4967 Builder.defineMacro("__CYGWIN64__");
4968 addCygMingDefines(Opts, Builder);
Saleem Abdulrasool56027092017-02-07 19:00:06 +00004969 DefineStd(Builder, "unix", Opts);
Yaron Kerend030d112015-07-22 17:38:19 +00004970 if (Opts.CPlusPlus)
4971 Builder.defineMacro("_GNU_SOURCE");
4972
4973 // GCC defines this macro when it is using __gxx_personality_seh0.
4974 if (!Opts.SjLjExceptions)
4975 Builder.defineMacro("__SEH__");
4976 }
4977};
4978
Eli Friedman2857ccb2009-07-01 03:36:11 +00004979class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
4980public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00004981 DarwinX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
4982 : DarwinTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Eli Friedman2857ccb2009-07-01 03:36:11 +00004983 Int64Type = SignedLongLong;
Tim Northovera2ee4332014-03-29 15:09:45 +00004984 // The 64-bit iOS simulator uses the builtin bool type for Objective-C.
4985 llvm::Triple T = llvm::Triple(Triple);
Bob Wilson946c04c2014-10-19 02:19:27 +00004986 if (T.isiOS())
Tim Northovera2ee4332014-03-29 15:09:45 +00004987 UseSignedCharForObjCBool = false;
James Y Knightb214cbc2016-03-04 19:00:41 +00004988 resetDataLayout("e-m:o-i64:64-f80:128-n8:16:32:64-S128");
Eli Friedman2857ccb2009-07-01 03:36:11 +00004989 }
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004990
4991 bool handleTargetFeatures(std::vector<std::string> &Features,
4992 DiagnosticsEngine &Diags) override {
4993 if (!DarwinTargetInfo<X86_64TargetInfo>::handleTargetFeatures(Features,
4994 Diags))
4995 return false;
Ahmed Bougacha02b7b562015-08-27 22:42:12 +00004996 // We now know the features we have: we can decide how to align vectors.
4997 MaxVectorAlign =
4998 hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
Ahmed Bougacha82b619e2015-08-27 22:30:38 +00004999 return true;
5000 }
Eli Friedman2857ccb2009-07-01 03:36:11 +00005001};
Eli Friedman2857ccb2009-07-01 03:36:11 +00005002
Eli Friedman245f2292009-07-05 22:31:18 +00005003class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
5004public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005005 OpenBSDX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5006 : OpenBSDTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Eli Friedman245f2292009-07-05 22:31:18 +00005007 IntMaxType = SignedLongLong;
Eli Friedman245f2292009-07-05 22:31:18 +00005008 Int64Type = SignedLongLong;
5009 }
5010};
Eli Friedman245f2292009-07-05 22:31:18 +00005011
Eli Friedman9fa28852012-08-08 23:57:20 +00005012class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
5013public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005014 BitrigX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5015 : BitrigTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005016 IntMaxType = SignedLongLong;
Benjamin Kramerb1276b42013-06-29 16:37:14 +00005017 Int64Type = SignedLongLong;
Eli Friedman9fa28852012-08-08 23:57:20 +00005018 }
5019};
Tim Northover9bb857a2013-01-31 12:13:10 +00005020
Eli Friedmanf05b7722008-08-20 07:44:10 +00005021class ARMTargetInfo : public TargetInfo {
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005022 // Possible FPU choices.
5023 enum FPUMode {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005024 VFP2FPU = (1 << 0),
5025 VFP3FPU = (1 << 1),
5026 VFP4FPU = (1 << 2),
Bernard Ogdenda13af32013-10-24 18:32:51 +00005027 NeonFPU = (1 << 3),
5028 FPARMV8 = (1 << 4)
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005029 };
5030
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005031 // Possible HWDiv features.
5032 enum HWDivMode {
5033 HWDivThumb = (1 << 0),
5034 HWDivARM = (1 << 1)
5035 };
5036
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005037 static bool FPUModeIsVFP(FPUMode Mode) {
Bernard Ogdenda13af32013-10-24 18:32:51 +00005038 return Mode & (VFP2FPU | VFP3FPU | VFP4FPU | NeonFPU | FPARMV8);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005039 }
5040
5041 static const TargetInfo::GCCRegAlias GCCRegAliases[];
5042 static const char * const GCCRegNames[];
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005043
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005044 std::string ABI, CPU;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005045
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005046 StringRef CPUProfile;
5047 StringRef CPUAttr;
5048
Rafael Espindolaeb265472013-08-21 21:59:03 +00005049 enum {
5050 FP_Default,
5051 FP_VFP,
5052 FP_Neon
5053 } FPMath;
5054
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005055 unsigned ArchISA;
Renato Goline84b0002015-10-08 16:43:26 +00005056 unsigned ArchKind = llvm::ARM::AK_ARMV4T;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005057 unsigned ArchProfile;
5058 unsigned ArchVersion;
5059
Bernard Ogdenda13af32013-10-24 18:32:51 +00005060 unsigned FPU : 5;
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005061
Logan Chien57086ce2012-10-10 06:56:20 +00005062 unsigned IsAAPCS : 1;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005063 unsigned HWDiv : 2;
Daniel Dunbar893d4752009-12-19 04:15:38 +00005064
5065 // Initialized via features.
5066 unsigned SoftFloat : 1;
5067 unsigned SoftFloatABI : 1;
Daniel Dunbarb4091a92009-09-14 00:35:03 +00005068
Bernard Ogden18b57012013-10-29 09:47:51 +00005069 unsigned CRC : 1;
Tim Northover02e38602014-02-03 17:28:04 +00005070 unsigned Crypto : 1;
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005071 unsigned DSP : 1;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005072 unsigned Unaligned : 1;
5073
5074 enum {
5075 LDREX_B = (1 << 0), /// byte (8-bit)
5076 LDREX_H = (1 << 1), /// half (16-bit)
5077 LDREX_W = (1 << 2), /// word (32-bit)
5078 LDREX_D = (1 << 3), /// double (64-bit)
5079 };
5080
5081 uint32_t LDREX;
Bernard Ogden18b57012013-10-29 09:47:51 +00005082
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005083 // ACLE 6.5.1 Hardware floating point
5084 enum {
5085 HW_FP_HP = (1 << 1), /// half (16-bit)
5086 HW_FP_SP = (1 << 2), /// single (32-bit)
5087 HW_FP_DP = (1 << 3), /// double (64-bit)
5088 };
5089 uint32_t HW_FP;
5090
Chris Lattner5cc15e02010-03-03 19:03:45 +00005091 static const Builtin::Info BuiltinInfo[];
5092
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005093 void setABIAAPCS() {
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005094 IsAAPCS = true;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005095
5096 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
Rafael Espindolac418ae92014-01-03 19:22:05 +00005097 const llvm::Triple &T = getTriple();
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005098
Renato Golin0201a9e2016-09-22 19:28:20 +00005099 // size_t is unsigned long on MachO-derived environments, NetBSD,
5100 // OpenBSD and Bitrig.
Renato Golin9ba39232015-02-27 16:35:48 +00005101 if (T.isOSBinFormatMachO() || T.getOS() == llvm::Triple::NetBSD ||
Renato Golin0201a9e2016-09-22 19:28:20 +00005102 T.getOS() == llvm::Triple::OpenBSD ||
Renato Golin9ba39232015-02-27 16:35:48 +00005103 T.getOS() == llvm::Triple::Bitrig)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005104 SizeType = UnsignedLong;
5105 else
5106 SizeType = UnsignedInt;
5107
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00005108 switch (T.getOS()) {
5109 case llvm::Triple::NetBSD:
Renato Golin0201a9e2016-09-22 19:28:20 +00005110 case llvm::Triple::OpenBSD:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005111 WCharType = SignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00005112 break;
5113 case llvm::Triple::Win32:
5114 WCharType = UnsignedShort;
5115 break;
5116 case llvm::Triple::Linux:
5117 default:
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005118 // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
5119 WCharType = UnsignedInt;
Saleem Abdulrasool6323a2d2014-05-04 01:56:04 +00005120 break;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005121 }
5122
5123 UseBitFieldTypeAlignment = true;
5124
5125 ZeroLengthBitfieldBoundary = 0;
5126
Tim Northover147cd2f2014-10-14 22:12:21 +00005127 // Thumb1 add sp, #imm requires the immediate value be multiple of 4,
5128 // so set preferred for small types to 32.
5129 if (T.isOSBinFormatMachO()) {
James Y Knightb214cbc2016-03-04 19:00:41 +00005130 resetDataLayout(BigEndian
5131 ? "E-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
5132 : "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
Tim Northover147cd2f2014-10-14 22:12:21 +00005133 } else if (T.isOSWindows()) {
Tim Northover147cd2f2014-10-14 22:12:21 +00005134 assert(!BigEndian && "Windows on ARM does not support big endian");
James Y Knightb214cbc2016-03-04 19:00:41 +00005135 resetDataLayout("e"
5136 "-m:w"
5137 "-p:32:32"
5138 "-i64:64"
5139 "-v128:64:128"
5140 "-a:0:32"
5141 "-n32"
5142 "-S64");
Derek Schuff6ab52fa2015-03-30 20:31:33 +00005143 } else if (T.isOSNaCl()) {
5144 assert(!BigEndian && "NaCl on ARM does not support big endian");
James Y Knightb214cbc2016-03-04 19:00:41 +00005145 resetDataLayout("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S128");
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005146 } else {
James Y Knightb214cbc2016-03-04 19:00:41 +00005147 resetDataLayout(BigEndian
5148 ? "E-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
5149 : "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005150 }
5151
5152 // FIXME: Enumerated types are variable width in straight AAPCS.
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005153 }
5154
Tim Northover5627d392015-10-30 16:30:45 +00005155 void setABIAPCS(bool IsAAPCS16) {
Rafael Espindolac418ae92014-01-03 19:22:05 +00005156 const llvm::Triple &T = getTriple();
5157
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005158 IsAAPCS = false;
5159
Tim Northover5627d392015-10-30 16:30:45 +00005160 if (IsAAPCS16)
5161 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
5162 else
5163 DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005164
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005165 // size_t is unsigned int on FreeBSD.
Rafael Espindolac418ae92014-01-03 19:22:05 +00005166 if (T.getOS() == llvm::Triple::FreeBSD)
Rafael Espindolaafa854c2013-12-18 20:24:51 +00005167 SizeType = UnsignedInt;
5168 else
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005169 SizeType = UnsignedLong;
5170
5171 // Revert to using SignedInt on apcs-gnu to comply with existing behaviour.
5172 WCharType = SignedInt;
5173
5174 // Do not respect the alignment of bit-field types when laying out
5175 // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
5176 UseBitFieldTypeAlignment = false;
5177
5178 /// gcc forces the alignment to 4 bytes, regardless of the type of the
5179 /// zero length bitfield. This corresponds to EMPTY_FIELD_BOUNDARY in
5180 /// gcc.
5181 ZeroLengthBitfieldBoundary = 32;
5182
Tim Northover5627d392015-10-30 16:30:45 +00005183 if (T.isOSBinFormatMachO() && IsAAPCS16) {
5184 assert(!BigEndian && "AAPCS16 does not support big-endian");
James Y Knightb214cbc2016-03-04 19:00:41 +00005185 resetDataLayout("e-m:o-p:32:32-i64:64-a:0:32-n32-S128");
Tim Northover5627d392015-10-30 16:30:45 +00005186 } else if (T.isOSBinFormatMachO())
James Y Knightb214cbc2016-03-04 19:00:41 +00005187 resetDataLayout(
Tim Northover147cd2f2014-10-14 22:12:21 +00005188 BigEndian
5189 ? "E-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
James Y Knightb214cbc2016-03-04 19:00:41 +00005190 : "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32");
Tim Northover147cd2f2014-10-14 22:12:21 +00005191 else
James Y Knightb214cbc2016-03-04 19:00:41 +00005192 resetDataLayout(
Tim Northover147cd2f2014-10-14 22:12:21 +00005193 BigEndian
5194 ? "E-m:e-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
James Y Knightb214cbc2016-03-04 19:00:41 +00005195 : "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 +00005196
5197 // FIXME: Override "preferred align" for double and long long.
5198 }
5199
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005200 void setArchInfo() {
5201 StringRef ArchName = getTriple().getArchName();
5202
Renato Goline84b0002015-10-08 16:43:26 +00005203 ArchISA = llvm::ARM::parseArchISA(ArchName);
5204 CPU = llvm::ARM::getDefaultCPU(ArchName);
5205 unsigned AK = llvm::ARM::parseArch(ArchName);
5206 if (AK != llvm::ARM::AK_INVALID)
5207 ArchKind = AK;
Vladimir Sukharev457d3412015-08-19 14:50:18 +00005208 setArchInfo(ArchKind);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005209 }
5210
Vladimir Sukharev457d3412015-08-19 14:50:18 +00005211 void setArchInfo(unsigned Kind) {
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005212 StringRef SubArch;
5213
5214 // cache TargetParser info
Vladimir Sukharev457d3412015-08-19 14:50:18 +00005215 ArchKind = Kind;
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00005216 SubArch = llvm::ARM::getSubArch(ArchKind);
5217 ArchProfile = llvm::ARM::parseArchProfile(SubArch);
5218 ArchVersion = llvm::ARM::parseArchVersion(SubArch);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005219
5220 // cache CPU related strings
5221 CPUAttr = getCPUAttr();
5222 CPUProfile = getCPUProfile();
5223 }
5224
5225 void setAtomic() {
Eric Christopherb093d692015-10-09 18:39:59 +00005226 // when triple does not specify a sub arch,
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005227 // then we are not using inline atomics
Renato Goline84b0002015-10-08 16:43:26 +00005228 bool ShouldUseInlineAtomic =
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005229 (ArchISA == llvm::ARM::IK_ARM && ArchVersion >= 6) ||
5230 (ArchISA == llvm::ARM::IK_THUMB && ArchVersion >= 7);
Eric Christopherb093d692015-10-09 18:39:59 +00005231 // Cortex M does not support 8 byte atomics, while general Thumb2 does.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005232 if (ArchProfile == llvm::ARM::PK_M) {
5233 MaxAtomicPromoteWidth = 32;
5234 if (ShouldUseInlineAtomic)
5235 MaxAtomicInlineWidth = 32;
5236 }
5237 else {
5238 MaxAtomicPromoteWidth = 64;
5239 if (ShouldUseInlineAtomic)
5240 MaxAtomicInlineWidth = 64;
Eric Christopherb093d692015-10-09 18:39:59 +00005241 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005242 }
5243
5244 bool isThumb() const {
5245 return (ArchISA == llvm::ARM::IK_THUMB);
5246 }
5247
5248 bool supportsThumb() const {
5249 return CPUAttr.count('T') || ArchVersion >= 6;
5250 }
5251
5252 bool supportsThumb2() const {
Bradley Smithf4affc12016-03-03 13:52:22 +00005253 return CPUAttr.equals("6T2") ||
5254 (ArchVersion >= 7 && !CPUAttr.equals("8M_BASE"));
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005255 }
5256
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005257 StringRef getCPUAttr() const {
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005258 // For most sub-arches, the build attribute CPU name is enough.
5259 // For Cortex variants, it's slightly different.
5260 switch(ArchKind) {
5261 default:
Chandler Carruthd96f37a2015-08-30 07:51:18 +00005262 return llvm::ARM::getCPUAttr(ArchKind);
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005263 case llvm::ARM::AK_ARMV6M:
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005264 return "6M";
Tim Northover525c73c2015-07-21 21:47:33 +00005265 case llvm::ARM::AK_ARMV7S:
5266 return "7S";
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005267 case llvm::ARM::AK_ARMV7A:
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005268 return "7A";
5269 case llvm::ARM::AK_ARMV7R:
5270 return "7R";
5271 case llvm::ARM::AK_ARMV7M:
5272 return "7M";
5273 case llvm::ARM::AK_ARMV7EM:
5274 return "7EM";
George Burgess IVfc970562017-02-09 23:30:10 +00005275 case llvm::ARM::AK_ARMV7VE:
5276 return "7VE";
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005277 case llvm::ARM::AK_ARMV8A:
5278 return "8A";
5279 case llvm::ARM::AK_ARMV8_1A:
5280 return "8_1A";
Oliver Stannard3086c042016-02-11 16:05:52 +00005281 case llvm::ARM::AK_ARMV8_2A:
5282 return "8_2A";
Bradley Smithf4affc12016-03-03 13:52:22 +00005283 case llvm::ARM::AK_ARMV8MBaseline:
5284 return "8M_BASE";
5285 case llvm::ARM::AK_ARMV8MMainline:
5286 return "8M_MAIN";
Javed Absar00b74442016-10-07 12:08:41 +00005287 case llvm::ARM::AK_ARMV8R:
5288 return "8R";
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005289 }
5290 }
5291
5292 StringRef getCPUProfile() const {
5293 switch(ArchProfile) {
5294 case llvm::ARM::PK_A:
5295 return "A";
5296 case llvm::ARM::PK_R:
5297 return "R";
5298 case llvm::ARM::PK_M:
5299 return "M";
5300 default:
5301 return "";
5302 }
5303 }
5304
Chris Lattner17df24e2008-04-21 18:56:49 +00005305public:
Matt Arsenaultf333de32016-09-07 07:08:02 +00005306 ARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005307 : TargetInfo(Triple), FPMath(FP_Default), IsAAPCS(true), LDREX(0),
5308 HW_FP(0) {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005309
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00005310 switch (getTriple().getOS()) {
5311 case llvm::Triple::NetBSD:
Renato Golin0201a9e2016-09-22 19:28:20 +00005312 case llvm::Triple::OpenBSD:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00005313 PtrDiffType = SignedLong;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00005314 break;
5315 default:
Joerg Sonnenberger7c7fcec2013-12-02 16:09:34 +00005316 PtrDiffType = SignedInt;
Joerg Sonnenberger84c7ca82013-11-30 00:38:16 +00005317 break;
5318 }
Chih-Hung Hsiehcda1cd52015-07-24 17:39:13 +00005319
Renato Goline84b0002015-10-08 16:43:26 +00005320 // Cache arch related info.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005321 setArchInfo();
Chih-Hung Hsiehcda1cd52015-07-24 17:39:13 +00005322
Chris Lattner1a8f3942010-04-23 16:29:58 +00005323 // {} in inline assembly are neon specifiers, not assembly variant
5324 // specifiers.
5325 NoAsmVariants = true;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005326
Eric Christopher0e261882014-12-05 01:06:59 +00005327 // FIXME: This duplicates code from the driver that sets the -target-abi
5328 // option - this code is used if -target-abi isn't passed and should
5329 // be unified in some way.
5330 if (Triple.isOSBinFormatMachO()) {
5331 // The backend is hardwired to assume AAPCS for M-class processors, ensure
5332 // the frontend matches that.
5333 if (Triple.getEnvironment() == llvm::Triple::EABI ||
5334 Triple.getOS() == llvm::Triple::UnknownOS ||
Zijiao Ma56a83722016-08-17 02:13:33 +00005335 ArchProfile == llvm::ARM::PK_M) {
Eric Christopher0e261882014-12-05 01:06:59 +00005336 setABI("aapcs");
Tim Northoverd88ecb32016-01-27 19:32:40 +00005337 } else if (Triple.isWatchABI()) {
Tim Northover5627d392015-10-30 16:30:45 +00005338 setABI("aapcs16");
Eric Christopher0e261882014-12-05 01:06:59 +00005339 } else {
5340 setABI("apcs-gnu");
5341 }
5342 } else if (Triple.isOSWindows()) {
5343 // FIXME: this is invalid for WindowsCE
5344 setABI("aapcs");
5345 } else {
5346 // Select the default based on the platform.
5347 switch (Triple.getEnvironment()) {
5348 case llvm::Triple::Android:
5349 case llvm::Triple::GNUEABI:
5350 case llvm::Triple::GNUEABIHF:
Rafael Espindola0fa66802016-06-24 21:35:06 +00005351 case llvm::Triple::MuslEABI:
5352 case llvm::Triple::MuslEABIHF:
Eric Christopher0e261882014-12-05 01:06:59 +00005353 setABI("aapcs-linux");
5354 break;
5355 case llvm::Triple::EABIHF:
5356 case llvm::Triple::EABI:
5357 setABI("aapcs");
5358 break;
Eric Christopher560cc4f2014-12-18 02:08:55 +00005359 case llvm::Triple::GNU:
Renato Goline84b0002015-10-08 16:43:26 +00005360 setABI("apcs-gnu");
5361 break;
Eric Christopher0e261882014-12-05 01:06:59 +00005362 default:
5363 if (Triple.getOS() == llvm::Triple::NetBSD)
5364 setABI("apcs-gnu");
Brad Smith3d648b32017-02-28 03:20:26 +00005365 else if (Triple.getOS() == llvm::Triple::OpenBSD)
5366 setABI("aapcs-linux");
Eric Christopher0e261882014-12-05 01:06:59 +00005367 else
5368 setABI("aapcs");
5369 break;
5370 }
5371 }
John McCall86353412010-08-21 22:46:04 +00005372
5373 // ARM targets default to using the ARM C++ ABI.
John McCall359b8852013-01-25 22:30:49 +00005374 TheCXXABI.set(TargetCXXABI::GenericARM);
Eli Friedman4b72fdd2011-10-14 20:59:01 +00005375
Renato Golin15b86152015-07-03 16:41:13 +00005376 // ARM has atomics up to 8 bytes
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005377 setAtomic();
Rafael Espindola5ab8e2e2015-07-02 15:14:10 +00005378
James Molloya7139222012-03-12 09:14:10 +00005379 // Do force alignment of members that follow zero length bitfields. If
Eric Christopher917e9522014-11-18 22:36:15 +00005380 // the alignment of the zero-length bitfield is greater than the member
5381 // that follows it, `bar', `bar' will be aligned as the type of the
James Molloya7139222012-03-12 09:14:10 +00005382 // zero length bitfield.
5383 UseZeroLengthBitfieldAlignment = true;
Saleem Abdulrasool9b5ba542016-04-10 03:19:47 +00005384
5385 if (Triple.getOS() == llvm::Triple::Linux ||
5386 Triple.getOS() == llvm::Triple::UnknownOS)
5387 this->MCountName =
5388 Opts.EABIVersion == "gnu" ? "\01__gnu_mcount_nc" : "\01mcount";
Eli Friedmanb5366062008-05-20 14:21:01 +00005389 }
Alexandros Lamprineas73b07612015-07-02 13:21:34 +00005390
Alp Toker4925ba72014-06-07 23:30:42 +00005391 StringRef getABI() const override { return ABI; }
Alexandros Lamprineas73b07612015-07-02 13:21:34 +00005392
Craig Topper3164f332014-03-11 03:39:26 +00005393 bool setABI(const std::string &Name) override {
Daniel Dunbarb4091a92009-09-14 00:35:03 +00005394 ABI = Name;
5395
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00005396 // The defaults (above) are for AAPCS, check if we need to change them.
5397 //
5398 // FIXME: We need support for -meabi... we could just mangle it into the
5399 // name.
Tim Northover756447a2015-10-30 16:30:36 +00005400 if (Name == "apcs-gnu" || Name == "aapcs16") {
Tim Northover5627d392015-10-30 16:30:45 +00005401 setABIAPCS(Name == "aapcs16");
Rafael Espindolad6c2b722013-12-18 19:47:32 +00005402 return true;
5403 }
5404 if (Name == "aapcs" || Name == "aapcs-vfp" || Name == "aapcs-linux") {
5405 setABIAAPCS();
5406 return true;
5407 }
5408 return false;
Daniel Dunbar125f8fb2009-09-14 00:02:24 +00005409 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00005410
Renato Golinf5c4dec2015-05-27 13:33:00 +00005411 // FIXME: This should be based on Arch attributes, not CPU names.
Eric Christopher8c47b422015-10-09 18:39:55 +00005412 bool
5413 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
5414 StringRef CPU,
5415 const std::vector<std::string> &FeaturesVec) const override {
5416
Mehdi Aminia0016ec2016-10-07 08:37:29 +00005417 std::vector<StringRef> TargetFeatures;
Bradley Smithb3501962015-11-16 11:16:36 +00005418 unsigned Arch = llvm::ARM::parseArch(getTriple().getArchName());
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00005419
5420 // get default FPU features
Bradley Smithb3501962015-11-16 11:16:36 +00005421 unsigned FPUKind = llvm::ARM::getDefaultFPU(CPU, Arch);
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00005422 llvm::ARM::getFPUFeatures(FPUKind, TargetFeatures);
5423
5424 // get default Extension features
Bradley Smithb3501962015-11-16 11:16:36 +00005425 unsigned Extensions = llvm::ARM::getDefaultExtensions(CPU, Arch);
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00005426 llvm::ARM::getExtensionFeatures(Extensions, TargetFeatures);
5427
Mehdi Aminia0016ec2016-10-07 08:37:29 +00005428 for (auto Feature : TargetFeatures)
Alexandros Lamprineas94d75db2015-09-06 16:15:45 +00005429 if (Feature[0] == '+')
Mehdi Aminia0016ec2016-10-07 08:37:29 +00005430 Features[Feature.drop_front(1)] = true;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005431
Eric Christopher007b0a02015-08-28 22:32:01 +00005432 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005433 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00005434
Craig Topper3164f332014-03-11 03:39:26 +00005435 bool handleTargetFeatures(std::vector<std::string> &Features,
5436 DiagnosticsEngine &Diags) override {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005437 FPU = 0;
Bernard Ogden18b57012013-10-29 09:47:51 +00005438 CRC = 0;
Tim Northover02e38602014-02-03 17:28:04 +00005439 Crypto = 0;
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005440 DSP = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005441 Unaligned = 1;
Daniel Dunbar893d4752009-12-19 04:15:38 +00005442 SoftFloat = SoftFloatABI = false;
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005443 HWDiv = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00005444
Ranjeet Singhac08e532015-06-24 23:39:25 +00005445 // This does not diagnose illegal cases like having both
5446 // "+vfpv2" and "+vfpv3" or having "+neon" and "+fp-only-sp".
5447 uint32_t HW_FP_remove = 0;
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00005448 for (const auto &Feature : Features) {
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005449 if (Feature == "+soft-float") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00005450 SoftFloat = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005451 } else if (Feature == "+soft-float-abi") {
Daniel Dunbar893d4752009-12-19 04:15:38 +00005452 SoftFloatABI = true;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005453 } else if (Feature == "+vfp2") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005454 FPU |= VFP2FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00005455 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005456 } else if (Feature == "+vfp3") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005457 FPU |= VFP3FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00005458 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005459 } else if (Feature == "+vfp4") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005460 FPU |= VFP4FPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00005461 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005462 } else if (Feature == "+fp-armv8") {
Bernard Ogdenda13af32013-10-24 18:32:51 +00005463 FPU |= FPARMV8;
Ranjeet Singhac08e532015-06-24 23:39:25 +00005464 HW_FP |= HW_FP_SP | HW_FP_DP | HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005465 } else if (Feature == "+neon") {
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005466 FPU |= NeonFPU;
Ranjeet Singhac08e532015-06-24 23:39:25 +00005467 HW_FP |= HW_FP_SP | HW_FP_DP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005468 } else if (Feature == "+hwdiv") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005469 HWDiv |= HWDivThumb;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005470 } else if (Feature == "+hwdiv-arm") {
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005471 HWDiv |= HWDivARM;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005472 } else if (Feature == "+crc") {
Bernard Ogden18b57012013-10-29 09:47:51 +00005473 CRC = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005474 } else if (Feature == "+crypto") {
Tim Northover02e38602014-02-03 17:28:04 +00005475 Crypto = 1;
Artyom Skrobov05d85ae2015-10-23 17:19:02 +00005476 } else if (Feature == "+dsp") {
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005477 DSP = 1;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005478 } else if (Feature == "+fp-only-sp") {
Matt Arsenault250024f2016-06-08 01:56:42 +00005479 HW_FP_remove |= HW_FP_DP;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005480 } else if (Feature == "+strict-align") {
5481 Unaligned = 0;
5482 } else if (Feature == "+fp16") {
5483 HW_FP |= HW_FP_HP;
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005484 }
Daniel Dunbar893d4752009-12-19 04:15:38 +00005485 }
Ranjeet Singhac08e532015-06-24 23:39:25 +00005486 HW_FP &= ~HW_FP_remove;
Daniel Dunbar893d4752009-12-19 04:15:38 +00005487
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005488 switch (ArchVersion) {
5489 case 6:
5490 if (ArchProfile == llvm::ARM::PK_M)
5491 LDREX = 0;
5492 else if (ArchKind == llvm::ARM::AK_ARMV6K)
5493 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5494 else
5495 LDREX = LDREX_W;
5496 break;
5497 case 7:
5498 if (ArchProfile == llvm::ARM::PK_M)
5499 LDREX = LDREX_W | LDREX_H | LDREX_B ;
5500 else
5501 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5502 break;
5503 case 8:
5504 LDREX = LDREX_D | LDREX_W | LDREX_H | LDREX_B ;
5505 }
5506
Rafael Espindolaeb265472013-08-21 21:59:03 +00005507 if (!(FPU & NeonFPU) && FPMath == FP_Neon) {
5508 Diags.Report(diag::err_target_unsupported_fpmath) << "neon";
5509 return false;
5510 }
5511
5512 if (FPMath == FP_Neon)
5513 Features.push_back("+neonfp");
5514 else if (FPMath == FP_VFP)
5515 Features.push_back("-neonfp");
5516
Daniel Dunbar893d4752009-12-19 04:15:38 +00005517 // Remove front-end specific options which the backend handles differently.
Eric Christopher9e172d22015-05-12 01:26:21 +00005518 auto Feature =
5519 std::find(Features.begin(), Features.end(), "+soft-float-abi");
5520 if (Feature != Features.end())
5521 Features.erase(Feature);
Saleem Abdulrasool0f691c62014-09-17 14:50:23 +00005522
Rafael Espindolaeb265472013-08-21 21:59:03 +00005523 return true;
Daniel Dunbar893d4752009-12-19 04:15:38 +00005524 }
5525
Craig Topper3164f332014-03-11 03:39:26 +00005526 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005527 return llvm::StringSwitch<bool>(Feature)
5528 .Case("arm", true)
Ben Langmuir587aeaf2015-08-07 01:59:56 +00005529 .Case("aarch32", true)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005530 .Case("softfloat", SoftFloat)
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005531 .Case("thumb", isThumb())
Amara Emerson8c3de542013-09-16 18:07:35 +00005532 .Case("neon", (FPU & NeonFPU) && !SoftFloat)
Weiming Zhaobe380c72017-05-05 19:25:29 +00005533 .Case("vfp", FPU && !SoftFloat)
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005534 .Case("hwdiv", HWDiv & HWDivThumb)
5535 .Case("hwdiv-arm", HWDiv & HWDivARM)
Douglas Gregor0070c0b2012-01-30 06:38:25 +00005536 .Default(false);
5537 }
Renato Golin15b86152015-07-03 16:41:13 +00005538
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005539 bool setCPU(const std::string &Name) override {
Vladimir Sukharev457d3412015-08-19 14:50:18 +00005540 if (Name != "generic")
Chandler Carruthaa0caeb2015-08-30 02:16:36 +00005541 setArchInfo(llvm::ARM::parseCPUArch(Name));
Vladimir Sukharev457d3412015-08-19 14:50:18 +00005542
Renato Golin15b86152015-07-03 16:41:13 +00005543 if (ArchKind == llvm::ARM::AK_INVALID)
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005544 return false;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005545 setAtomic();
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005546 CPU = Name;
5547 return true;
5548 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005549
Craig Topper3164f332014-03-11 03:39:26 +00005550 bool setFPMath(StringRef Name) override;
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005551
Craig Topper3164f332014-03-11 03:39:26 +00005552 void getTargetDefines(const LangOptions &Opts,
5553 MacroBuilder &Builder) const override {
Chris Lattnerecd49032009-03-02 22:27:17 +00005554 // Target identification.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005555 Builder.defineMacro("__arm");
5556 Builder.defineMacro("__arm__");
Weiming Zhaob0613132016-04-18 16:25:46 +00005557 // For bare-metal none-eabi.
5558 if (getTriple().getOS() == llvm::Triple::UnknownOS &&
Oliver Stannard233310f2017-04-18 13:12:36 +00005559 (getTriple().getEnvironment() == llvm::Triple::EABI ||
5560 getTriple().getEnvironment() == llvm::Triple::EABIHF))
Weiming Zhaob0613132016-04-18 16:25:46 +00005561 Builder.defineMacro("__ELF__");
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00005562
Oliver Stannard233310f2017-04-18 13:12:36 +00005563
Chris Lattnerecd49032009-03-02 22:27:17 +00005564 // Target properties.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005565 Builder.defineMacro("__REGISTER_PREFIX__", "");
Tim Northover5627d392015-10-30 16:30:45 +00005566
5567 // Unfortunately, __ARM_ARCH_7K__ is now more of an ABI descriptor. The CPU
5568 // happens to be Cortex-A7 though, so it should still get __ARM_ARCH_7A__.
Tim Northoverd88ecb32016-01-27 19:32:40 +00005569 if (getTriple().isWatchABI())
Tim Northover5627d392015-10-30 16:30:45 +00005570 Builder.defineMacro("__ARM_ARCH_7K__", "2");
5571
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005572 if (!CPUAttr.empty())
5573 Builder.defineMacro("__ARM_ARCH_" + CPUAttr + "__");
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005574
5575 // ACLE 6.4.1 ARM/Thumb instruction set architecture
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005576 // __ARM_ARCH is defined as an integer value indicating the current ARM ISA
Benjamin Kramerb42d9a52015-12-24 10:07:37 +00005577 Builder.defineMacro("__ARM_ARCH", Twine(ArchVersion));
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005578
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005579 if (ArchVersion >= 8) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005580 // ACLE 6.5.7 Crypto Extension
5581 if (Crypto)
5582 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
5583 // ACLE 6.5.8 CRC32 Extension
5584 if (CRC)
5585 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
5586 // ACLE 6.5.10 Numeric Maximum and Minimum
5587 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
5588 // ACLE 6.5.9 Directed Rounding
5589 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
James Molloy0ffb0932014-09-15 11:25:38 +00005590 }
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005591
5592 // __ARM_ARCH_ISA_ARM is defined to 1 if the core supports the ARM ISA. It
5593 // is not defined for the M-profile.
Bradley Smithf4affc12016-03-03 13:52:22 +00005594 // NOTE that the default profile is assumed to be 'A'
5595 if (CPUProfile.empty() || ArchProfile != llvm::ARM::PK_M)
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005596 Builder.defineMacro("__ARM_ARCH_ISA_ARM", "1");
5597
Bradley Smithf4affc12016-03-03 13:52:22 +00005598 // __ARM_ARCH_ISA_THUMB is defined to 1 if the core supports the original
5599 // Thumb ISA (including v6-M and v8-M Baseline). It is set to 2 if the
5600 // core supports the Thumb-2 ISA as found in the v6T2 architecture and all
5601 // v7 and v8 architectures excluding v8-M Baseline.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005602 if (supportsThumb2())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005603 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "2");
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005604 else if (supportsThumb())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005605 Builder.defineMacro("__ARM_ARCH_ISA_THUMB", "1");
5606
5607 // __ARM_32BIT_STATE is defined to 1 if code is being generated for a 32-bit
5608 // instruction set such as ARM or Thumb.
5609 Builder.defineMacro("__ARM_32BIT_STATE", "1");
5610
5611 // ACLE 6.4.2 Architectural Profile (A, R, M or pre-Cortex)
5612
5613 // __ARM_ARCH_PROFILE is defined as 'A', 'R', 'M' or 'S', or unset.
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00005614 if (!CPUProfile.empty())
Saleem Abdulrasool0e3258c2014-06-15 18:35:07 +00005615 Builder.defineMacro("__ARM_ARCH_PROFILE", "'" + CPUProfile + "'");
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00005616
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005617 // ACLE 6.4.3 Unaligned access supported in hardware
Eric Christopherb093d692015-10-09 18:39:59 +00005618 if (Unaligned)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005619 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
Eric Christopherb093d692015-10-09 18:39:59 +00005620
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005621 // ACLE 6.4.4 LDREX/STREX
5622 if (LDREX)
5623 Builder.defineMacro("__ARM_FEATURE_LDREX", "0x" + llvm::utohexstr(LDREX));
5624
5625 // ACLE 6.4.5 CLZ
Eric Christopherb093d692015-10-09 18:39:59 +00005626 if (ArchVersion == 5 ||
5627 (ArchVersion == 6 && CPUProfile != "M") ||
5628 ArchVersion > 6)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005629 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
5630
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005631 // ACLE 6.5.1 Hardware Floating Point
5632 if (HW_FP)
Saleem Abdulrasoolb404cb82014-09-18 02:13:33 +00005633 Builder.defineMacro("__ARM_FP", "0x" + llvm::utohexstr(HW_FP));
Saleem Abdulrasool687c3b02014-09-17 14:50:27 +00005634
Yi Konga44c4d72014-06-27 21:25:42 +00005635 // ACLE predefines.
5636 Builder.defineMacro("__ARM_ACLE", "200");
5637
Oliver Stannarddc2854c2015-09-03 12:40:58 +00005638 // FP16 support (we currently only support IEEE format).
5639 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
5640 Builder.defineMacro("__ARM_FP16_ARGS", "1");
5641
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005642 // ACLE 6.5.3 Fused multiply-accumulate (FMA)
Silviu Baranga632fdc52016-04-28 11:29:08 +00005643 if (ArchVersion >= 7 && (FPU & VFP4FPU))
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005644 Builder.defineMacro("__ARM_FEATURE_FMA", "1");
5645
Mike Stump9d54bd72009-04-08 02:07:04 +00005646 // Subtarget options.
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00005647
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005648 // FIXME: It's more complicated than this and we don't really support
5649 // interworking.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005650 // Windows on ARM does not "support" interworking
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005651 if (5 <= ArchVersion && ArchVersion <= 8 && !getTriple().isOSWindows())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005652 Builder.defineMacro("__THUMB_INTERWORK__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005653
David Tweed8f676532012-10-25 13:33:01 +00005654 if (ABI == "aapcs" || ABI == "aapcs-linux" || ABI == "aapcs-vfp") {
Tim Northovere77f78c2013-11-11 19:11:22 +00005655 // Embedded targets on Darwin follow AAPCS, but not EABI.
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005656 // Windows on ARM follows AAPCS VFP, but does not conform to EABI.
Tim Northover862eaf82016-05-13 21:26:45 +00005657 if (!getTriple().isOSBinFormatMachO() && !getTriple().isOSWindows())
Daniel Dunbarf7124da2012-10-22 18:51:13 +00005658 Builder.defineMacro("__ARM_EABI__");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00005659 Builder.defineMacro("__ARM_PCS", "1");
Anton Korobeynikove98c4db2012-09-08 08:08:27 +00005660 }
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005661
Tim Northover28fc0e12016-04-28 13:59:55 +00005662 if ((!SoftFloat && !SoftFloatABI) || ABI == "aapcs-vfp" ||
5663 ABI == "aapcs16")
5664 Builder.defineMacro("__ARM_PCS_VFP", "1");
5665
Daniel Dunbar893d4752009-12-19 04:15:38 +00005666 if (SoftFloat)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005667 Builder.defineMacro("__SOFTFP__");
Daniel Dunbaracde99e2009-12-18 18:42:37 +00005668
Zijiao Ma56a83722016-08-17 02:13:33 +00005669 if (ArchKind == llvm::ARM::AK_XSCALE)
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005670 Builder.defineMacro("__XSCALE__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00005671
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005672 if (isThumb()) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005673 Builder.defineMacro("__THUMBEL__");
5674 Builder.defineMacro("__thumb__");
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005675 if (supportsThumb2())
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005676 Builder.defineMacro("__thumb2__");
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00005677 }
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005678
5679 // ACLE 6.4.9 32-bit SIMD instructions
5680 if (ArchVersion >= 6 && (CPUProfile != "M" || CPUAttr == "7EM"))
5681 Builder.defineMacro("__ARM_FEATURE_SIMD32", "1");
5682
5683 // ACLE 6.4.10 Hardware Integer Divide
Eric Christopherb093d692015-10-09 18:39:59 +00005684 if (((HWDiv & HWDivThumb) && isThumb()) ||
5685 ((HWDiv & HWDivARM) && !isThumb())) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005686 Builder.defineMacro("__ARM_FEATURE_IDIV", "1");
Silviu Barangaf9671dd2013-10-21 10:54:53 +00005687 Builder.defineMacro("__ARM_ARCH_EXT_IDIV__", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005688 }
Daniel Dunbar2f5c75e2009-09-17 16:21:10 +00005689
5690 // Note, this is always on in gcc, even though it doesn't make sense.
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005691 Builder.defineMacro("__APCS_32__");
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005692
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005693 if (FPUModeIsVFP((FPUMode) FPU)) {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005694 Builder.defineMacro("__VFP_FP__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005695 if (FPU & VFP2FPU)
5696 Builder.defineMacro("__ARM_VFPV2__");
5697 if (FPU & VFP3FPU)
5698 Builder.defineMacro("__ARM_VFPV3__");
5699 if (FPU & VFP4FPU)
5700 Builder.defineMacro("__ARM_VFPV4__");
Tim Northoverc67803f2016-12-21 20:49:43 +00005701 if (FPU & FPARMV8)
5702 Builder.defineMacro("__ARM_FPV5__");
Bob Wilson6fc8fb82012-09-29 23:52:52 +00005703 }
Weiming Zhaofb5c21a2014-01-22 18:42:13 +00005704
Daniel Dunbar0def3d12009-12-21 23:28:17 +00005705 // This only gets set when Neon instructions are actually available, unlike
5706 // the VFP define, hence the soft float and arch check. This is subtly
5707 // different from gcc, we follow the intent which was that it should be set
5708 // when Neon instructions are actually available.
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005709 if ((FPU & NeonFPU) && !SoftFloat && ArchVersion >= 7) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005710 Builder.defineMacro("__ARM_NEON", "1");
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00005711 Builder.defineMacro("__ARM_NEON__");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005712 // current AArch32 NEON implementations do not support double-precision
5713 // floating-point even when it is present in VFP.
Eric Christopherb093d692015-10-09 18:39:59 +00005714 Builder.defineMacro("__ARM_NEON_FP",
5715 "0x" + llvm::utohexstr(HW_FP & ~HW_FP_DP));
Tim Northover5bb34ca2013-11-21 12:36:34 +00005716 }
Joey Gouly1e8637b2013-09-18 10:07:09 +00005717
Bradley Smith0f28f0c2014-01-20 10:52:00 +00005718 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T",
5719 Opts.ShortWChar ? "2" : "4");
5720
5721 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
5722 Opts.ShortEnums ? "1" : "4");
5723
Bradley Smithf4affc12016-03-03 13:52:22 +00005724 if (ArchVersion >= 6 && CPUAttr != "6M" && CPUAttr != "8M_BASE") {
Weiming Zhao53a797c2013-09-30 22:51:32 +00005725 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
5726 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
5727 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
5728 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
5729 }
Sergey Dmitrouk745f5302014-11-25 08:57:36 +00005730
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005731 // ACLE 6.4.7 DSP instructions
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005732 if (DSP) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005733 Builder.defineMacro("__ARM_FEATURE_DSP", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005734 }
5735
5736 // ACLE 6.4.8 Saturation instructions
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005737 bool SAT = false;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005738 if ((ArchVersion == 6 && CPUProfile != "M") || ArchVersion > 6 ) {
5739 Builder.defineMacro("__ARM_FEATURE_SAT", "1");
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005740 SAT = true;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005741 }
5742
5743 // ACLE 6.4.6 Q (saturation) flag
Artyom Skrobovd3ae09b2015-09-24 17:34:05 +00005744 if (DSP || SAT)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00005745 Builder.defineMacro("__ARM_FEATURE_QBIT", "1");
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00005746
5747 if (Opts.UnsafeFPMath)
5748 Builder.defineMacro("__ARM_FP_FAST", "1");
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00005749
5750 if (ArchKind == llvm::ARM::AK_ARMV8_1A)
5751 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
Chris Lattner17df24e2008-04-21 18:56:49 +00005752 }
Alexandros Lamprineas65bc3062015-07-17 09:08:37 +00005753
Craig Topper6c03a542015-10-19 04:51:35 +00005754 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
5755 return llvm::makeArrayRef(BuiltinInfo,
5756 clang::ARM::LastTSBuiltin-Builtin::FirstTSBuiltin);
Chris Lattner17df24e2008-04-21 18:56:49 +00005757 }
Craig Topper3164f332014-03-11 03:39:26 +00005758 bool isCLZForZeroUndef() const override { return false; }
5759 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northover5627d392015-10-30 16:30:45 +00005760 return IsAAPCS
5761 ? AAPCSABIBuiltinVaList
Tim Northoverd88ecb32016-01-27 19:32:40 +00005762 : (getTriple().isWatchABI() ? TargetInfo::CharPtrBuiltinVaList
5763 : TargetInfo::VoidPtrBuiltinVaList);
Chris Lattner17df24e2008-04-21 18:56:49 +00005764 }
Craig Topperf054e3a2015-10-19 03:52:27 +00005765 ArrayRef<const char *> getGCCRegNames() const override;
5766 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00005767 bool validateAsmConstraint(const char *&Name,
5768 TargetInfo::ConstraintInfo &Info) const override {
Anders Carlsson58436352009-02-28 17:11:49 +00005769 switch (*Name) {
Eric Christopher9e491882012-08-16 23:50:41 +00005770 default: break;
Nate Begeman2908fa02008-04-22 05:03:19 +00005771 case 'l': // r0-r7
5772 case 'h': // r8-r15
JF Bastien750caef2016-02-19 06:54:45 +00005773 case 't': // VFP Floating point register single precision
5774 case 'w': // VFP Floating point register double precision
Chris Lattnerd9725f72009-04-26 07:16:29 +00005775 Info.setAllowsRegister();
Nate Begeman2908fa02008-04-22 05:03:19 +00005776 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00005777 case 'I':
5778 case 'J':
5779 case 'K':
5780 case 'L':
5781 case 'M':
5782 // FIXME
5783 return true;
Eric Christopherb081ba62011-07-29 21:20:35 +00005784 case 'Q': // A memory address that is a single base register.
5785 Info.setAllowsMemory();
5786 return true;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00005787 case 'U': // a memory reference...
5788 switch (Name[1]) {
5789 case 'q': // ...ARMV4 ldrsb
5790 case 'v': // ...VFP load/store (reg+constant offset)
5791 case 'y': // ...iWMMXt load/store
Eric Christopherd1048542011-06-17 01:40:49 +00005792 case 't': // address valid for load/store opaque types wider
Eric Christopherfd081ca2012-11-14 22:08:59 +00005793 // than 128-bits
Eric Christopherd1048542011-06-17 01:40:49 +00005794 case 'n': // valid address for Neon doubleword vector load/store
5795 case 'm': // valid address for Neon element and structure load/store
5796 case 's': // valid address for non-offset loads/stores of quad-word
Eric Christopherfd081ca2012-11-14 22:08:59 +00005797 // values in four ARM registers
Stuart Hastings7fdc6702011-06-07 23:45:05 +00005798 Info.setAllowsMemory();
5799 Name++;
5800 return true;
5801 }
Nate Begeman2908fa02008-04-22 05:03:19 +00005802 }
Chris Lattner17df24e2008-04-21 18:56:49 +00005803 return false;
5804 }
Craig Topper3164f332014-03-11 03:39:26 +00005805 std::string convertConstraint(const char *&Constraint) const override {
Stuart Hastings7fdc6702011-06-07 23:45:05 +00005806 std::string R;
5807 switch (*Constraint) {
5808 case 'U': // Two-character constraint; add "^" hint for later parsing.
Stuart Hastings5b7b11c2011-06-08 16:06:31 +00005809 R = std::string("^") + std::string(Constraint, 2);
Stuart Hastings7fdc6702011-06-07 23:45:05 +00005810 Constraint++;
5811 break;
Eric Christopher7d237c12011-06-17 00:40:18 +00005812 case 'p': // 'p' should be translated to 'r' by default.
5813 R = std::string("r");
5814 break;
Stuart Hastings7fdc6702011-06-07 23:45:05 +00005815 default:
5816 return std::string(1, *Constraint);
5817 }
5818 return R;
5819 }
Akira Hatanaka987f1862014-08-22 06:05:21 +00005820 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00005821 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00005822 std::string &SuggestedModifier) const override {
Bill Wendling3c6591d2012-11-30 23:18:12 +00005823 bool isOutput = (Constraint[0] == '=');
Bill Wendling05175082012-11-30 23:46:56 +00005824 bool isInOut = (Constraint[0] == '+');
Bill Wendling3c6591d2012-11-30 23:18:12 +00005825
Bill Wendling9d1ee112012-10-25 23:28:48 +00005826 // Strip off constraint modifiers.
5827 while (Constraint[0] == '=' ||
5828 Constraint[0] == '+' ||
5829 Constraint[0] == '&')
5830 Constraint = Constraint.substr(1);
5831
5832 switch (Constraint[0]) {
5833 default: break;
5834 case 'r': {
5835 switch (Modifier) {
5836 default:
Tim Northover8f24b172013-12-08 15:24:55 +00005837 return (isInOut || isOutput || Size <= 64);
Bill Wendling9d1ee112012-10-25 23:28:48 +00005838 case 'q':
5839 // A register of size 32 cannot fit a vector type.
5840 return false;
5841 }
5842 }
5843 }
5844
5845 return true;
5846 }
Craig Topper3164f332014-03-11 03:39:26 +00005847 const char *getClobbers() const override {
Eli Friedmanf05b7722008-08-20 07:44:10 +00005848 // FIXME: Is this really right?
Chris Lattner17df24e2008-04-21 18:56:49 +00005849 return "";
5850 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00005851
Craig Topper3164f332014-03-11 03:39:26 +00005852 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
John McCall477f2bb2016-03-03 06:39:32 +00005853 switch (CC) {
5854 case CC_AAPCS:
5855 case CC_AAPCS_VFP:
5856 case CC_Swift:
5857 return CCCR_OK;
5858 default:
5859 return CCCR_Warning;
5860 }
Aaron Ballmane91c6be2012-10-02 14:26:08 +00005861 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00005862
Craig Topper3164f332014-03-11 03:39:26 +00005863 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00005864 if (RegNo == 0) return 0;
5865 if (RegNo == 1) return 1;
5866 return -1;
5867 }
Matthias Braund1e2fad2015-07-17 00:15:22 +00005868
5869 bool hasSjLjLowering() const override {
5870 return true;
5871 }
Chris Lattner17df24e2008-04-21 18:56:49 +00005872};
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005873
Rafael Espindolaeb265472013-08-21 21:59:03 +00005874bool ARMTargetInfo::setFPMath(StringRef Name) {
5875 if (Name == "neon") {
5876 FPMath = FP_Neon;
5877 return true;
5878 } else if (Name == "vfp" || Name == "vfp2" || Name == "vfp3" ||
5879 Name == "vfp4") {
5880 FPMath = FP_VFP;
5881 return true;
5882 }
5883 return false;
5884}
5885
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005886const char * const ARMTargetInfo::GCCRegNames[] = {
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005887 // Integer registers
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005888 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005889 "r8", "r9", "r10", "r11", "r12", "sp", "lr", "pc",
5890
5891 // Float registers
5892 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
5893 "s8", "s9", "s10", "s11", "s12", "s13", "s14", "s15",
5894 "s16", "s17", "s18", "s19", "s20", "s21", "s22", "s23",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005895 "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
Daniel Dunbar9034aa32010-08-11 02:17:20 +00005896
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005897 // Double registers
5898 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
5899 "d8", "d9", "d10", "d11", "d12", "d13", "d14", "d15",
Dale Johannesend2b2ad02010-10-28 01:05:37 +00005900 "d16", "d17", "d18", "d19", "d20", "d21", "d22", "d23",
5901 "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005902
5903 // Quad registers
Dale Johannesend2b2ad02010-10-28 01:05:37 +00005904 "q0", "q1", "q2", "q3", "q4", "q5", "q6", "q7",
5905 "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15"
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005906};
5907
Craig Topperf054e3a2015-10-19 03:52:27 +00005908ArrayRef<const char *> ARMTargetInfo::getGCCRegNames() const {
5909 return llvm::makeArrayRef(GCCRegNames);
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005910}
5911
5912const TargetInfo::GCCRegAlias ARMTargetInfo::GCCRegAliases[] = {
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005913 { { "a1" }, "r0" },
5914 { { "a2" }, "r1" },
5915 { { "a3" }, "r2" },
5916 { { "a4" }, "r3" },
5917 { { "v1" }, "r4" },
5918 { { "v2" }, "r5" },
5919 { { "v3" }, "r6" },
5920 { { "v4" }, "r7" },
5921 { { "v5" }, "r8" },
5922 { { "v6", "rfp" }, "r9" },
5923 { { "sl" }, "r10" },
5924 { { "fp" }, "r11" },
5925 { { "ip" }, "r12" },
Daniel Dunbar256e1f32010-08-11 02:17:11 +00005926 { { "r13" }, "sp" },
5927 { { "r14" }, "lr" },
5928 { { "r15" }, "pc" },
Dale Johannesen7fd51bc2010-10-27 23:34:42 +00005929 // The S, D and Q registers overlap, but aren't really aliases; we
5930 // don't want to substitute one of these for a different-sized one.
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005931};
5932
Craig Topperf054e3a2015-10-19 03:52:27 +00005933ArrayRef<TargetInfo::GCCRegAlias> ARMTargetInfo::getGCCRegAliases() const {
5934 return llvm::makeArrayRef(GCCRegAliases);
Daniel Dunbar1da76c42009-09-17 07:03:19 +00005935}
Chris Lattner5cc15e02010-03-03 19:03:45 +00005936
5937const Builtin::Info ARMTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00005938#define BUILTIN(ID, TYPE, ATTRS) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005939 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005940#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5941 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Tim Northovera2ee4332014-03-29 15:09:45 +00005942#include "clang/Basic/BuiltinsNEON.def"
Tim Northoverc322f832014-01-30 14:47:51 +00005943
Craig Topper07d3b622015-08-07 05:14:44 +00005944#define BUILTIN(ID, TYPE, ATTRS) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005945 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005946#define LANGBUILTIN(ID, TYPE, ATTRS, LANG) \
Eric Christopherc48497a2015-09-18 21:26:24 +00005947 { #ID, TYPE, ATTRS, nullptr, LANG, nullptr },
Craig Topper07d3b622015-08-07 05:14:44 +00005948#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
5949 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Albert Gutowski2a0621e2016-10-12 22:01:05 +00005950#define TARGET_HEADER_BUILTIN(ID, TYPE, ATTRS, HEADER, LANGS, FEATURE) \
5951 { #ID, TYPE, ATTRS, HEADER, LANGS, FEATURE },
Chris Lattner5cc15e02010-03-03 19:03:45 +00005952#include "clang/Basic/BuiltinsARM.def"
5953};
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005954
5955class ARMleTargetInfo : public ARMTargetInfo {
5956public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005957 ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Matt Arsenaultf333de32016-09-07 07:08:02 +00005958 : ARMTargetInfo(Triple, Opts) {}
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005959 void getTargetDefines(const LangOptions &Opts,
5960 MacroBuilder &Builder) const override {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005961 Builder.defineMacro("__ARMEL__");
5962 ARMTargetInfo::getTargetDefines(Opts, Builder);
5963 }
5964};
5965
5966class ARMbeTargetInfo : public ARMTargetInfo {
5967public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005968 ARMbeTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Matt Arsenaultf333de32016-09-07 07:08:02 +00005969 : ARMTargetInfo(Triple, Opts) {}
Alexander Kornienko34eb2072015-04-11 02:00:23 +00005970 void getTargetDefines(const LangOptions &Opts,
5971 MacroBuilder &Builder) const override {
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00005972 Builder.defineMacro("__ARMEB__");
5973 Builder.defineMacro("__ARM_BIG_ENDIAN");
5974 ARMTargetInfo::getTargetDefines(Opts, Builder);
5975 }
5976};
Chris Lattner17df24e2008-04-21 18:56:49 +00005977
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005978class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
5979 const llvm::Triple Triple;
5980public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00005981 WindowsARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
5982 : WindowsTargetInfo<ARMleTargetInfo>(Triple, Opts), Triple(Triple) {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005983 WCharType = UnsignedShort;
5984 SizeType = UnsignedInt;
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00005985 }
5986 void getVisualStudioDefines(const LangOptions &Opts,
5987 MacroBuilder &Builder) const {
5988 WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
5989
5990 // FIXME: this is invalid for WindowsCE
5991 Builder.defineMacro("_M_ARM_NT", "1");
5992 Builder.defineMacro("_M_ARMT", "_M_ARM");
5993 Builder.defineMacro("_M_THUMB", "_M_ARM");
5994
5995 assert((Triple.getArch() == llvm::Triple::arm ||
5996 Triple.getArch() == llvm::Triple::thumb) &&
5997 "invalid architecture for Windows ARM target info");
5998 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6;
5999 Builder.defineMacro("_M_ARM", Triple.getArchName().substr(Offset));
6000
6001 // TODO map the complete set of values
6002 // 31: VFPv3 40: VFPv4
6003 Builder.defineMacro("_M_ARM_FP", "31");
6004 }
Saleem Abdulrasool521cec82014-06-29 23:05:41 +00006005 BuiltinVaListKind getBuiltinVaListKind() const override {
6006 return TargetInfo::CharPtrBuiltinVaList;
6007 }
Martell Malone7ccda3c2015-08-14 18:00:09 +00006008 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
6009 switch (CC) {
6010 case CC_X86StdCall:
6011 case CC_X86ThisCall:
6012 case CC_X86FastCall:
6013 case CC_X86VectorCall:
6014 return CCCR_Ignore;
6015 case CC_C:
6016 return CCCR_OK;
6017 default:
6018 return CCCR_Warning;
6019 }
6020 }
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006021};
6022
6023// Windows ARM + Itanium C++ ABI Target
6024class ItaniumWindowsARMleTargetInfo : public WindowsARMTargetInfo {
6025public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006026 ItaniumWindowsARMleTargetInfo(const llvm::Triple &Triple,
6027 const TargetOptions &Opts)
6028 : WindowsARMTargetInfo(Triple, Opts) {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006029 TheCXXABI.set(TargetCXXABI::GenericARM);
6030 }
6031
6032 void getTargetDefines(const LangOptions &Opts,
6033 MacroBuilder &Builder) const override {
6034 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
6035
6036 if (Opts.MSVCCompat)
6037 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
6038 }
6039};
6040
6041// Windows ARM, MS (C++) ABI
6042class MicrosoftARMleTargetInfo : public WindowsARMTargetInfo {
6043public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006044 MicrosoftARMleTargetInfo(const llvm::Triple &Triple,
6045 const TargetOptions &Opts)
6046 : WindowsARMTargetInfo(Triple, Opts) {
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006047 TheCXXABI.set(TargetCXXABI::Microsoft);
6048 }
6049
6050 void getTargetDefines(const LangOptions &Opts,
6051 MacroBuilder &Builder) const override {
6052 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
6053 WindowsARMTargetInfo::getVisualStudioDefines(Opts, Builder);
6054 }
6055};
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00006056
Yaron Keren321249c2015-07-15 13:32:23 +00006057// ARM MinGW target
6058class MinGWARMTargetInfo : public WindowsARMTargetInfo {
6059public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006060 MinGWARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6061 : WindowsARMTargetInfo(Triple, Opts) {
Yaron Keren321249c2015-07-15 13:32:23 +00006062 TheCXXABI.set(TargetCXXABI::GenericARM);
6063 }
6064
6065 void getTargetDefines(const LangOptions &Opts,
6066 MacroBuilder &Builder) const override {
6067 WindowsARMTargetInfo::getTargetDefines(Opts, Builder);
6068 DefineStd(Builder, "WIN32", Opts);
6069 DefineStd(Builder, "WINNT", Opts);
6070 Builder.defineMacro("_ARM_");
6071 addMinGWDefines(Opts, Builder);
6072 }
6073};
6074
6075// ARM Cygwin target
6076class CygwinARMTargetInfo : public ARMleTargetInfo {
6077public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006078 CygwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6079 : ARMleTargetInfo(Triple, Opts) {
Yaron Keren321249c2015-07-15 13:32:23 +00006080 TLSSupported = false;
6081 WCharType = UnsignedShort;
6082 DoubleAlign = LongLongAlign = 64;
James Y Knightb214cbc2016-03-04 19:00:41 +00006083 resetDataLayout("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64");
Yaron Keren321249c2015-07-15 13:32:23 +00006084 }
6085 void getTargetDefines(const LangOptions &Opts,
6086 MacroBuilder &Builder) const override {
6087 ARMleTargetInfo::getTargetDefines(Opts, Builder);
6088 Builder.defineMacro("_ARM_");
6089 Builder.defineMacro("__CYGWIN__");
6090 Builder.defineMacro("__CYGWIN32__");
Saleem Abdulrasool56027092017-02-07 19:00:06 +00006091 DefineStd(Builder, "unix", Opts);
Yaron Keren321249c2015-07-15 13:32:23 +00006092 if (Opts.CPlusPlus)
6093 Builder.defineMacro("_GNU_SOURCE");
6094 }
6095};
6096
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006097class DarwinARMTargetInfo : public DarwinTargetInfo<ARMleTargetInfo> {
Torok Edwinb2b37c62009-06-30 17:10:35 +00006098protected:
Craig Topper3164f332014-03-11 03:39:26 +00006099 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
6100 MacroBuilder &Builder) const override {
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00006101 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
Eli Friedmand88c8a12009-04-19 21:38:35 +00006102 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00006103
Torok Edwinb2b37c62009-06-30 17:10:35 +00006104public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006105 DarwinARMTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6106 : DarwinTargetInfo<ARMleTargetInfo>(Triple, Opts) {
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00006107 HasAlignMac68kSupport = true;
Eli Friedman4b72fdd2011-10-14 20:59:01 +00006108 // iOS always has 64-bit atomic instructions.
Eric Christopher917e9522014-11-18 22:36:15 +00006109 // FIXME: This should be based off of the target features in
6110 // ARMleTargetInfo.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00006111 MaxAtomicInlineWidth = 64;
John McCall359b8852013-01-25 22:30:49 +00006112
Tim Northoverd88ecb32016-01-27 19:32:40 +00006113 if (Triple.isWatchABI()) {
Tim Northover5627d392015-10-30 16:30:45 +00006114 // Darwin on iOS uses a variant of the ARM C++ ABI.
6115 TheCXXABI.set(TargetCXXABI::WatchOS);
6116
6117 // The 32-bit ABI is silent on what ptrdiff_t should be, but given that
6118 // size_t is long, it's a bit weird for it to be int.
6119 PtrDiffType = SignedLong;
6120
6121 // BOOL should be a real boolean on the new ABI
6122 UseSignedCharForObjCBool = false;
6123 } else
6124 TheCXXABI.set(TargetCXXABI::iOS);
Daniel Dunbar3eeeccd2010-05-27 07:00:26 +00006125 }
Eli Friedmanf05b7722008-08-20 07:44:10 +00006126};
Eli Friedmanf05b7722008-08-20 07:44:10 +00006127
Tim Northover573cbee2014-05-24 12:52:07 +00006128class AArch64TargetInfo : public TargetInfo {
James Y Knightb214cbc2016-03-04 19:00:41 +00006129 virtual void setDataLayout() = 0;
Tim Northovera2ee4332014-03-29 15:09:45 +00006130 static const TargetInfo::GCCRegAlias GCCRegAliases[];
6131 static const char *const GCCRegNames[];
6132
James Molloy75f5f9e2014-04-16 15:33:48 +00006133 enum FPUModeEnum {
6134 FPUMode,
6135 NeonMode
6136 };
6137
6138 unsigned FPU;
Bradley Smith418c5932014-05-02 15:17:51 +00006139 unsigned CRC;
James Molloy75f5f9e2014-04-16 15:33:48 +00006140 unsigned Crypto;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006141 unsigned Unaligned;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00006142 unsigned V8_1A;
James Molloy75f5f9e2014-04-16 15:33:48 +00006143
Tim Northovera2ee4332014-03-29 15:09:45 +00006144 static const Builtin::Info BuiltinInfo[];
6145
6146 std::string ABI;
6147
6148public:
Saleem Abdulrasool9b5ba542016-04-10 03:19:47 +00006149 AArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
Tim Northovera2ee4332014-03-29 15:09:45 +00006150 : TargetInfo(Triple), ABI("aapcs") {
Brad Smith9aa2bf22017-02-21 23:13:09 +00006151 if (getTriple().getOS() == llvm::Triple::NetBSD ||
6152 getTriple().getOS() == llvm::Triple::OpenBSD) {
Tim Northover25e8a672014-05-24 12:51:25 +00006153 WCharType = SignedInt;
6154
6155 // NetBSD apparently prefers consistency across ARM targets to consistency
6156 // across 64-bit targets.
6157 Int64Type = SignedLongLong;
6158 IntMaxType = SignedLongLong;
Tim Northover25e8a672014-05-24 12:51:25 +00006159 } else {
6160 WCharType = UnsignedInt;
6161 Int64Type = SignedLong;
6162 IntMaxType = SignedLong;
Tim Northover25e8a672014-05-24 12:51:25 +00006163 }
6164
Tim Northovera2ee4332014-03-29 15:09:45 +00006165 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Tim Northovera2ee4332014-03-29 15:09:45 +00006166 MaxVectorAlign = 128;
Tim Northovera2ee4332014-03-29 15:09:45 +00006167 MaxAtomicInlineWidth = 128;
6168 MaxAtomicPromoteWidth = 128;
6169
Tim Northovera6a19f12015-02-06 01:25:07 +00006170 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00006171 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Tim Northovera2ee4332014-03-29 15:09:45 +00006172
Tim Northovera2ee4332014-03-29 15:09:45 +00006173 // {} in inline assembly are neon specifiers, not assembly variant
6174 // specifiers.
6175 NoAsmVariants = true;
6176
Tim Northover7ad87af2015-01-16 18:44:04 +00006177 // AAPCS gives rules for bitfields. 7.1.7 says: "The container type
6178 // contributes to the alignment of the containing aggregate in the same way
6179 // a plain (non bit-field) member of that type would, without exception for
6180 // zero-sized or anonymous bit-fields."
Tim Northover5627d392015-10-30 16:30:45 +00006181 assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
Tim Northover7ad87af2015-01-16 18:44:04 +00006182 UseZeroLengthBitfieldAlignment = true;
6183
Tim Northover573cbee2014-05-24 12:52:07 +00006184 // AArch64 targets default to using the ARM C++ ABI.
Tim Northovera2ee4332014-03-29 15:09:45 +00006185 TheCXXABI.set(TargetCXXABI::GenericAArch64);
Saleem Abdulrasoolc066d9c2016-04-12 03:05:03 +00006186
Eric Christopherfb834a82017-02-28 17:22:05 +00006187 if (Triple.getOS() == llvm::Triple::Linux)
6188 this->MCountName = "\01_mcount";
6189 else if (Triple.getOS() == llvm::Triple::UnknownOS)
Saleem Abdulrasoolc066d9c2016-04-12 03:05:03 +00006190 this->MCountName = Opts.EABIVersion == "gnu" ? "\01_mcount" : "mcount";
Tim Northovera2ee4332014-03-29 15:09:45 +00006191 }
6192
Alp Toker4925ba72014-06-07 23:30:42 +00006193 StringRef getABI() const override { return ABI; }
David Blaikie1cbb9712014-11-14 19:09:44 +00006194 bool setABI(const std::string &Name) override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006195 if (Name != "aapcs" && Name != "darwinpcs")
6196 return false;
6197
6198 ABI = Name;
6199 return true;
6200 }
6201
David Blaikie1cbb9712014-11-14 19:09:44 +00006202 bool setCPU(const std::string &Name) override {
Zijiao Ma33e95212016-07-28 06:24:48 +00006203 return Name == "generic" ||
6204 llvm::AArch64::parseCPUArch(Name) !=
6205 static_cast<unsigned>(llvm::AArch64::ArchKind::AK_INVALID);
Tim Northovera2ee4332014-03-29 15:09:45 +00006206 }
6207
Alexander Kornienko34eb2072015-04-11 02:00:23 +00006208 void getTargetDefines(const LangOptions &Opts,
6209 MacroBuilder &Builder) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006210 // Target identification.
Tim Northovera2ee4332014-03-29 15:09:45 +00006211 Builder.defineMacro("__aarch64__");
Oliver Stannard233310f2017-04-18 13:12:36 +00006212 // For bare-metal none-eabi.
6213 if (getTriple().getOS() == llvm::Triple::UnknownOS &&
6214 (getTriple().getEnvironment() == llvm::Triple::EABI ||
6215 getTriple().getEnvironment() == llvm::Triple::EABIHF))
6216 Builder.defineMacro("__ELF__");
Tim Northovera2ee4332014-03-29 15:09:45 +00006217
6218 // Target properties.
6219 Builder.defineMacro("_LP64");
6220 Builder.defineMacro("__LP64__");
Tim Northovera2ee4332014-03-29 15:09:45 +00006221
6222 // ACLE predefines. Many can only have one possible value on v8 AArch64.
6223 Builder.defineMacro("__ARM_ACLE", "200");
6224 Builder.defineMacro("__ARM_ARCH", "8");
6225 Builder.defineMacro("__ARM_ARCH_PROFILE", "'A'");
6226
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006227 Builder.defineMacro("__ARM_64BIT_STATE", "1");
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00006228 Builder.defineMacro("__ARM_PCS_AAPCS64", "1");
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006229 Builder.defineMacro("__ARM_ARCH_ISA_A64", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00006230
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006231 Builder.defineMacro("__ARM_FEATURE_CLZ", "1");
6232 Builder.defineMacro("__ARM_FEATURE_FMA", "1");
6233 Builder.defineMacro("__ARM_FEATURE_LDREX", "0xF");
6234 Builder.defineMacro("__ARM_FEATURE_IDIV", "1"); // As specified in ACLE
James Molloy0ffb0932014-09-15 11:25:38 +00006235 Builder.defineMacro("__ARM_FEATURE_DIV"); // For backwards compatibility
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006236 Builder.defineMacro("__ARM_FEATURE_NUMERIC_MAXMIN", "1");
6237 Builder.defineMacro("__ARM_FEATURE_DIRECTED_ROUNDING", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00006238
6239 Builder.defineMacro("__ARM_ALIGN_MAX_STACK_PWR", "4");
6240
6241 // 0xe implies support for half, single and double precision operations.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006242 Builder.defineMacro("__ARM_FP", "0xE");
Tim Northovera2ee4332014-03-29 15:09:45 +00006243
6244 // PCS specifies this for SysV variants, which is all we support. Other ABIs
6245 // may choose __ARM_FP16_FORMAT_ALTERNATIVE.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006246 Builder.defineMacro("__ARM_FP16_FORMAT_IEEE", "1");
6247 Builder.defineMacro("__ARM_FP16_ARGS", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00006248
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00006249 if (Opts.UnsafeFPMath)
6250 Builder.defineMacro("__ARM_FP_FAST", "1");
Tim Northovera2ee4332014-03-29 15:09:45 +00006251
6252 Builder.defineMacro("__ARM_SIZEOF_WCHAR_T", Opts.ShortWChar ? "2" : "4");
6253
6254 Builder.defineMacro("__ARM_SIZEOF_MINIMAL_ENUM",
6255 Opts.ShortEnums ? "1" : "4");
6256
James Molloy75f5f9e2014-04-16 15:33:48 +00006257 if (FPU == NeonMode) {
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006258 Builder.defineMacro("__ARM_NEON", "1");
James Molloy75f5f9e2014-04-16 15:33:48 +00006259 // 64-bit NEON supports half, single and double precision operations.
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006260 Builder.defineMacro("__ARM_NEON_FP", "0xE");
James Molloy75f5f9e2014-04-16 15:33:48 +00006261 }
Tim Northovera2ee4332014-03-29 15:09:45 +00006262
Bradley Smith418c5932014-05-02 15:17:51 +00006263 if (CRC)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006264 Builder.defineMacro("__ARM_FEATURE_CRC32", "1");
Bradley Smith418c5932014-05-02 15:17:51 +00006265
James Molloy75f5f9e2014-04-16 15:33:48 +00006266 if (Crypto)
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006267 Builder.defineMacro("__ARM_FEATURE_CRYPTO", "1");
6268
6269 if (Unaligned)
6270 Builder.defineMacro("__ARM_FEATURE_UNALIGNED", "1");
Reid Klecknerd167d422015-05-06 15:31:46 +00006271
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00006272 if (V8_1A)
6273 Builder.defineMacro("__ARM_FEATURE_QRDMX", "1");
6274
Reid Klecknerd167d422015-05-06 15:31:46 +00006275 // All of the __sync_(bool|val)_compare_and_swap_(1|2|4|8) builtins work.
6276 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
6277 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
6278 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
6279 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Tim Northovera2ee4332014-03-29 15:09:45 +00006280 }
6281
Craig Topper6c03a542015-10-19 04:51:35 +00006282 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6283 return llvm::makeArrayRef(BuiltinInfo,
6284 clang::AArch64::LastTSBuiltin - Builtin::FirstTSBuiltin);
Tim Northovera2ee4332014-03-29 15:09:45 +00006285 }
6286
David Blaikie1cbb9712014-11-14 19:09:44 +00006287 bool hasFeature(StringRef Feature) const override {
James Molloy75f5f9e2014-04-16 15:33:48 +00006288 return Feature == "aarch64" ||
6289 Feature == "arm64" ||
Ben Langmuir587aeaf2015-08-07 01:59:56 +00006290 Feature == "arm" ||
James Molloy75f5f9e2014-04-16 15:33:48 +00006291 (Feature == "neon" && FPU == NeonMode);
Tim Northovera2ee4332014-03-29 15:09:45 +00006292 }
6293
James Molloy5e73df52014-04-16 15:06:20 +00006294 bool handleTargetFeatures(std::vector<std::string> &Features,
6295 DiagnosticsEngine &Diags) override {
James Molloy75f5f9e2014-04-16 15:33:48 +00006296 FPU = FPUMode;
Bradley Smith418c5932014-05-02 15:17:51 +00006297 CRC = 0;
James Molloy75f5f9e2014-04-16 15:33:48 +00006298 Crypto = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006299 Unaligned = 1;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00006300 V8_1A = 0;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006301
Eric Christopher610fe112015-08-26 08:21:55 +00006302 for (const auto &Feature : Features) {
6303 if (Feature == "+neon")
James Molloy75f5f9e2014-04-16 15:33:48 +00006304 FPU = NeonMode;
Eric Christopher610fe112015-08-26 08:21:55 +00006305 if (Feature == "+crc")
Bradley Smith418c5932014-05-02 15:17:51 +00006306 CRC = 1;
Eric Christopher610fe112015-08-26 08:21:55 +00006307 if (Feature == "+crypto")
James Molloy75f5f9e2014-04-16 15:33:48 +00006308 Crypto = 1;
Alexandros Lamprineasa448f042015-09-03 14:40:57 +00006309 if (Feature == "+strict-align")
6310 Unaligned = 0;
Alexandros Lamprineas502592c2015-11-29 10:43:59 +00006311 if (Feature == "+v8.1a")
6312 V8_1A = 1;
James Molloy75f5f9e2014-04-16 15:33:48 +00006313 }
6314
James Y Knightb214cbc2016-03-04 19:00:41 +00006315 setDataLayout();
James Molloy5e73df52014-04-16 15:06:20 +00006316
6317 return true;
6318 }
6319
John McCall477f2bb2016-03-03 06:39:32 +00006320 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
6321 switch (CC) {
6322 case CC_C:
6323 case CC_Swift:
Roman Levenstein35aa5ce2016-03-16 18:00:46 +00006324 case CC_PreserveMost:
6325 case CC_PreserveAll:
John McCall477f2bb2016-03-03 06:39:32 +00006326 return CCCR_OK;
6327 default:
6328 return CCCR_Warning;
6329 }
6330 }
6331
David Blaikie1cbb9712014-11-14 19:09:44 +00006332 bool isCLZForZeroUndef() const override { return false; }
Tim Northovera2ee4332014-03-29 15:09:45 +00006333
David Blaikie1cbb9712014-11-14 19:09:44 +00006334 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006335 return TargetInfo::AArch64ABIBuiltinVaList;
6336 }
6337
Craig Topperf054e3a2015-10-19 03:52:27 +00006338 ArrayRef<const char *> getGCCRegNames() const override;
6339 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Tim Northovera2ee4332014-03-29 15:09:45 +00006340
Alexander Kornienko34eb2072015-04-11 02:00:23 +00006341 bool validateAsmConstraint(const char *&Name,
6342 TargetInfo::ConstraintInfo &Info) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006343 switch (*Name) {
6344 default:
6345 return false;
6346 case 'w': // Floating point and SIMD registers (V0-V31)
6347 Info.setAllowsRegister();
6348 return true;
James Molloy8bdd24b2014-04-23 10:26:19 +00006349 case 'I': // Constant that can be used with an ADD instruction
6350 case 'J': // Constant that can be used with a SUB instruction
6351 case 'K': // Constant that can be used with a 32-bit logical instruction
6352 case 'L': // Constant that can be used with a 64-bit logical instruction
6353 case 'M': // Constant that can be used as a 32-bit MOV immediate
6354 case 'N': // Constant that can be used as a 64-bit MOV immediate
6355 case 'Y': // Floating point constant zero
6356 case 'Z': // Integer constant zero
6357 return true;
6358 case 'Q': // A memory reference with base register and no offset
6359 Info.setAllowsMemory();
6360 return true;
6361 case 'S': // A symbolic address
6362 Info.setAllowsRegister();
6363 return true;
6364 case 'U':
Eric Christopher917e9522014-11-18 22:36:15 +00006365 // Ump: A memory address suitable for ldp/stp in SI, DI, SF and DF modes.
6366 // Utf: A memory address suitable for ldp/stp in TF mode.
6367 // Usa: An absolute symbolic address.
6368 // Ush: The high part (bits 32:12) of a pc-relative symbolic address.
6369 llvm_unreachable("FIXME: Unimplemented support for U* constraints.");
Tim Northovera2ee4332014-03-29 15:09:45 +00006370 case 'z': // Zero register, wzr or xzr
6371 Info.setAllowsRegister();
6372 return true;
6373 case 'x': // Floating point and SIMD registers (V0-V15)
6374 Info.setAllowsRegister();
6375 return true;
Tim Northovera2ee4332014-03-29 15:09:45 +00006376 }
6377 return false;
6378 }
6379
Akira Hatanaka987f1862014-08-22 06:05:21 +00006380 bool
Aaron Ballmane9c64792014-08-22 13:26:37 +00006381 validateConstraintModifier(StringRef Constraint, char Modifier, unsigned Size,
Akira Hatanaka987f1862014-08-22 06:05:21 +00006382 std::string &SuggestedModifier) const override {
James Molloy8a157bf2014-07-25 10:19:47 +00006383 // Strip off constraint modifiers.
6384 while (Constraint[0] == '=' || Constraint[0] == '+' || Constraint[0] == '&')
6385 Constraint = Constraint.substr(1);
6386
6387 switch (Constraint[0]) {
6388 default:
6389 return true;
6390 case 'z':
6391 case 'r': {
6392 switch (Modifier) {
6393 case 'x':
6394 case 'w':
6395 // For now assume that the person knows what they're
6396 // doing with the modifier.
6397 return true;
6398 default:
6399 // By default an 'r' constraint will be in the 'x'
6400 // registers.
Akira Hatanaka987f1862014-08-22 06:05:21 +00006401 if (Size == 64)
6402 return true;
6403
6404 SuggestedModifier = "w";
6405 return false;
James Molloy8a157bf2014-07-25 10:19:47 +00006406 }
6407 }
6408 }
6409 }
6410
David Blaikie1cbb9712014-11-14 19:09:44 +00006411 const char *getClobbers() const override { return ""; }
Tim Northovera2ee4332014-03-29 15:09:45 +00006412
Fariborz Jahanian5afc8692014-10-01 16:56:40 +00006413 int getEHDataRegisterNumber(unsigned RegNo) const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006414 if (RegNo == 0)
6415 return 0;
6416 if (RegNo == 1)
6417 return 1;
6418 return -1;
6419 }
6420};
6421
Tim Northover573cbee2014-05-24 12:52:07 +00006422const char *const AArch64TargetInfo::GCCRegNames[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00006423 // 32-bit Integer registers
6424 "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8", "w9", "w10",
6425 "w11", "w12", "w13", "w14", "w15", "w16", "w17", "w18", "w19", "w20", "w21",
6426 "w22", "w23", "w24", "w25", "w26", "w27", "w28", "w29", "w30", "wsp",
6427
6428 // 64-bit Integer registers
6429 "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9", "x10",
6430 "x11", "x12", "x13", "x14", "x15", "x16", "x17", "x18", "x19", "x20", "x21",
6431 "x22", "x23", "x24", "x25", "x26", "x27", "x28", "fp", "lr", "sp",
6432
6433 // 32-bit floating point regsisters
6434 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10",
6435 "s11", "s12", "s13", "s14", "s15", "s16", "s17", "s18", "s19", "s20", "s21",
6436 "s22", "s23", "s24", "s25", "s26", "s27", "s28", "s29", "s30", "s31",
6437
6438 // 64-bit floating point regsisters
6439 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "d10",
6440 "d11", "d12", "d13", "d14", "d15", "d16", "d17", "d18", "d19", "d20", "d21",
6441 "d22", "d23", "d24", "d25", "d26", "d27", "d28", "d29", "d30", "d31",
6442
6443 // Vector registers
6444 "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10",
6445 "v11", "v12", "v13", "v14", "v15", "v16", "v17", "v18", "v19", "v20", "v21",
6446 "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31"
6447};
6448
Craig Topperf054e3a2015-10-19 03:52:27 +00006449ArrayRef<const char *> AArch64TargetInfo::getGCCRegNames() const {
6450 return llvm::makeArrayRef(GCCRegNames);
Tim Northovera2ee4332014-03-29 15:09:45 +00006451}
6452
Tim Northover573cbee2014-05-24 12:52:07 +00006453const TargetInfo::GCCRegAlias AArch64TargetInfo::GCCRegAliases[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00006454 { { "w31" }, "wsp" },
6455 { { "x29" }, "fp" },
6456 { { "x30" }, "lr" },
6457 { { "x31" }, "sp" },
6458 // The S/D/Q and W/X registers overlap, but aren't really aliases; we
6459 // don't want to substitute one of these for a different-sized one.
6460};
6461
Craig Topperf054e3a2015-10-19 03:52:27 +00006462ArrayRef<TargetInfo::GCCRegAlias> AArch64TargetInfo::getGCCRegAliases() const {
6463 return llvm::makeArrayRef(GCCRegAliases);
Tim Northovera2ee4332014-03-29 15:09:45 +00006464}
6465
Tim Northover573cbee2014-05-24 12:52:07 +00006466const Builtin::Info AArch64TargetInfo::BuiltinInfo[] = {
Tim Northovera2ee4332014-03-29 15:09:45 +00006467#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00006468 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Tim Northovera2ee4332014-03-29 15:09:45 +00006469#include "clang/Basic/BuiltinsNEON.def"
6470
6471#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00006472 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Tim Northover573cbee2014-05-24 12:52:07 +00006473#include "clang/Basic/BuiltinsAArch64.def"
Tim Northovera2ee4332014-03-29 15:09:45 +00006474};
James Molloy5e73df52014-04-16 15:06:20 +00006475
Tim Northover573cbee2014-05-24 12:52:07 +00006476class AArch64leTargetInfo : public AArch64TargetInfo {
James Y Knightb214cbc2016-03-04 19:00:41 +00006477 void setDataLayout() override {
James Molloy5e73df52014-04-16 15:06:20 +00006478 if (getTriple().isOSBinFormatMachO())
James Y Knightb214cbc2016-03-04 19:00:41 +00006479 resetDataLayout("e-m:o-i64:64-i128:128-n32:64-S128");
James Molloy5e73df52014-04-16 15:06:20 +00006480 else
Chad Rosier4c077aa2016-07-07 20:02:25 +00006481 resetDataLayout("e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
James Molloy5e73df52014-04-16 15:06:20 +00006482 }
6483
6484public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006485 AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6486 : AArch64TargetInfo(Triple, Opts) {
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006487 }
James Molloy5e73df52014-04-16 15:06:20 +00006488 void getTargetDefines(const LangOptions &Opts,
6489 MacroBuilder &Builder) const override {
6490 Builder.defineMacro("__AARCH64EL__");
Tim Northover573cbee2014-05-24 12:52:07 +00006491 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00006492 }
6493};
6494
Tim Northover573cbee2014-05-24 12:52:07 +00006495class AArch64beTargetInfo : public AArch64TargetInfo {
James Y Knightb214cbc2016-03-04 19:00:41 +00006496 void setDataLayout() override {
James Molloy5e73df52014-04-16 15:06:20 +00006497 assert(!getTriple().isOSBinFormatMachO());
Chad Rosier4c077aa2016-07-07 20:02:25 +00006498 resetDataLayout("E-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128");
James Molloy5e73df52014-04-16 15:06:20 +00006499 }
6500
6501public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006502 AArch64beTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6503 : AArch64TargetInfo(Triple, Opts) {}
James Molloy5e73df52014-04-16 15:06:20 +00006504 void getTargetDefines(const LangOptions &Opts,
6505 MacroBuilder &Builder) const override {
6506 Builder.defineMacro("__AARCH64EB__");
6507 Builder.defineMacro("__AARCH_BIG_ENDIAN");
6508 Builder.defineMacro("__ARM_BIG_ENDIAN");
Tim Northover573cbee2014-05-24 12:52:07 +00006509 AArch64TargetInfo::getTargetDefines(Opts, Builder);
James Molloy5e73df52014-04-16 15:06:20 +00006510 }
6511};
Tim Northovera2ee4332014-03-29 15:09:45 +00006512
Tim Northover573cbee2014-05-24 12:52:07 +00006513class DarwinAArch64TargetInfo : public DarwinTargetInfo<AArch64leTargetInfo> {
James Molloy5e73df52014-04-16 15:06:20 +00006514protected:
6515 void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
6516 MacroBuilder &Builder) const override {
6517 Builder.defineMacro("__AARCH64_SIMD__");
6518 Builder.defineMacro("__ARM64_ARCH_8__");
6519 Builder.defineMacro("__ARM_NEON__");
6520 Builder.defineMacro("__LITTLE_ENDIAN__");
6521 Builder.defineMacro("__REGISTER_PREFIX__", "");
6522 Builder.defineMacro("__arm64", "1");
6523 Builder.defineMacro("__arm64__", "1");
6524
6525 getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
6526 }
6527
Tim Northovera2ee4332014-03-29 15:09:45 +00006528public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006529 DarwinAArch64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
6530 : DarwinTargetInfo<AArch64leTargetInfo>(Triple, Opts) {
Tim Northovera2ee4332014-03-29 15:09:45 +00006531 Int64Type = SignedLongLong;
6532 WCharType = SignedInt;
6533 UseSignedCharForObjCBool = false;
6534
Tim Northovera6a19f12015-02-06 01:25:07 +00006535 LongDoubleWidth = LongDoubleAlign = SuitableAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00006536 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Tim Northovera2ee4332014-03-29 15:09:45 +00006537
6538 TheCXXABI.set(TargetCXXABI::iOS64);
6539 }
6540
David Blaikie1cbb9712014-11-14 19:09:44 +00006541 BuiltinVaListKind getBuiltinVaListKind() const override {
Tim Northovera2ee4332014-03-29 15:09:45 +00006542 return TargetInfo::CharPtrBuiltinVaList;
6543 }
6544};
Tim Northovera2ee4332014-03-29 15:09:45 +00006545
Tony Linthicum76329bf2011-12-12 21:14:55 +00006546// Hexagon abstract base class
6547class HexagonTargetInfo : public TargetInfo {
6548 static const Builtin::Info BuiltinInfo[];
6549 static const char * const GCCRegNames[];
6550 static const TargetInfo::GCCRegAlias GCCRegAliases[];
6551 std::string CPU;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006552 bool HasHVX, HasHVXDouble;
Krzysztof Parzyszek1f269122016-08-30 13:57:50 +00006553 bool UseLongCalls;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006554
Tony Linthicum76329bf2011-12-12 21:14:55 +00006555public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006556 HexagonTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
6557 : TargetInfo(Triple) {
Krzysztof Parzyszek8e576972016-02-12 14:48:34 +00006558 // Specify the vector alignment explicitly. For v512x1, the calculated
6559 // alignment would be 512*alignment(i1), which is 512 bytes, instead of
6560 // the required minimum of 64 bytes.
James Y Knightb214cbc2016-03-04 19:00:41 +00006561 resetDataLayout("e-m:e-p:32:32:32-a:0-n16:32-"
Krzysztof Parzyszek8e576972016-02-12 14:48:34 +00006562 "i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
James Y Knightb214cbc2016-03-04 19:00:41 +00006563 "v32:32:32-v64:64:64-v512:512:512-v1024:1024:1024-v2048:2048:2048");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006564 SizeType = UnsignedInt;
6565 PtrDiffType = SignedInt;
6566 IntPtrType = SignedInt;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006567
6568 // {} in inline assembly are packet specifiers, not assembly variant
6569 // specifiers.
6570 NoAsmVariants = true;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006571
6572 LargeArrayMinWidth = 64;
6573 LargeArrayAlign = 64;
6574 UseBitFieldTypeAlignment = true;
6575 ZeroLengthBitfieldBoundary = 32;
6576 HasHVX = HasHVXDouble = false;
Krzysztof Parzyszek1f269122016-08-30 13:57:50 +00006577 UseLongCalls = false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006578 }
6579
Craig Topper6c03a542015-10-19 04:51:35 +00006580 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
6581 return llvm::makeArrayRef(BuiltinInfo,
6582 clang::Hexagon::LastTSBuiltin-Builtin::FirstTSBuiltin);
Tony Linthicum76329bf2011-12-12 21:14:55 +00006583 }
6584
Craig Topper3164f332014-03-11 03:39:26 +00006585 bool validateAsmConstraint(const char *&Name,
6586 TargetInfo::ConstraintInfo &Info) const override {
Krzysztof Parzyszeke0026e42016-05-18 14:56:14 +00006587 switch (*Name) {
6588 case 'v':
6589 case 'q':
6590 if (HasHVX) {
6591 Info.setAllowsRegister();
6592 return true;
6593 }
6594 break;
Krzysztof Parzyszek89fb4412016-05-20 13:50:32 +00006595 case 's':
6596 // Relocatable constant.
6597 return true;
Krzysztof Parzyszeke0026e42016-05-18 14:56:14 +00006598 }
6599 return false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006600 }
6601
Craig Topper3164f332014-03-11 03:39:26 +00006602 void getTargetDefines(const LangOptions &Opts,
6603 MacroBuilder &Builder) const override;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006604
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006605 bool isCLZForZeroUndef() const override { return false; }
6606
Craig Topper3164f332014-03-11 03:39:26 +00006607 bool hasFeature(StringRef Feature) const override {
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006608 return llvm::StringSwitch<bool>(Feature)
6609 .Case("hexagon", true)
6610 .Case("hvx", HasHVX)
6611 .Case("hvx-double", HasHVXDouble)
Krzysztof Parzyszek1f269122016-08-30 13:57:50 +00006612 .Case("long-calls", UseLongCalls)
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006613 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00006614 }
Craig Topper3164f332014-03-11 03:39:26 +00006615
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006616 bool initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
6617 StringRef CPU, const std::vector<std::string> &FeaturesVec)
6618 const override;
6619
6620 bool handleTargetFeatures(std::vector<std::string> &Features,
6621 DiagnosticsEngine &Diags) override;
6622
Krzysztof Parzyszek7cd30bd2016-08-30 14:17:10 +00006623 void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
6624 bool Enabled) const override;
6625
Craig Topper3164f332014-03-11 03:39:26 +00006626 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00006627 return TargetInfo::CharPtrBuiltinVaList;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006628 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006629 ArrayRef<const char *> getGCCRegNames() const override;
6630 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00006631 const char *getClobbers() const override {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006632 return "";
6633 }
Sebastian Pop86500282012-01-13 20:37:10 +00006634
6635 static const char *getHexagonCPUSuffix(StringRef Name) {
6636 return llvm::StringSwitch<const char*>(Name)
Sebastian Pop86500282012-01-13 20:37:10 +00006637 .Case("hexagonv4", "4")
Sirish Pande11ebc4e2012-05-10 20:19:54 +00006638 .Case("hexagonv5", "5")
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006639 .Case("hexagonv55", "55")
6640 .Case("hexagonv60", "60")
Krzysztof Parzyszekff7f6672017-03-14 20:29:23 +00006641 .Case("hexagonv62", "62")
Craig Topperf1186c52014-05-08 06:41:40 +00006642 .Default(nullptr);
Sebastian Pop86500282012-01-13 20:37:10 +00006643 }
6644
Craig Topper3164f332014-03-11 03:39:26 +00006645 bool setCPU(const std::string &Name) override {
Sebastian Pop86500282012-01-13 20:37:10 +00006646 if (!getHexagonCPUSuffix(Name))
6647 return false;
Tony Linthicum76329bf2011-12-12 21:14:55 +00006648 CPU = Name;
6649 return true;
6650 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006651
6652 int getEHDataRegisterNumber(unsigned RegNo) const override {
6653 return RegNo < 2 ? RegNo : -1;
6654 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006655};
6656
6657void HexagonTargetInfo::getTargetDefines(const LangOptions &Opts,
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006658 MacroBuilder &Builder) const {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006659 Builder.defineMacro("__qdsp6__", "1");
Tony Linthicum76329bf2011-12-12 21:14:55 +00006660 Builder.defineMacro("__hexagon__", "1");
6661
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006662 if (CPU == "hexagonv4") {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006663 Builder.defineMacro("__HEXAGON_V4__");
6664 Builder.defineMacro("__HEXAGON_ARCH__", "4");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006665 if (Opts.HexagonQdsp6Compat) {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006666 Builder.defineMacro("__QDSP6_V4__");
6667 Builder.defineMacro("__QDSP6_ARCH__", "4");
6668 }
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006669 } else if (CPU == "hexagonv5") {
Sirish Pande11ebc4e2012-05-10 20:19:54 +00006670 Builder.defineMacro("__HEXAGON_V5__");
6671 Builder.defineMacro("__HEXAGON_ARCH__", "5");
6672 if(Opts.HexagonQdsp6Compat) {
6673 Builder.defineMacro("__QDSP6_V5__");
6674 Builder.defineMacro("__QDSP6_ARCH__", "5");
6675 }
Krzysztof Parzyszeka58ff512016-04-21 14:30:04 +00006676 } else if (CPU == "hexagonv55") {
6677 Builder.defineMacro("__HEXAGON_V55__");
6678 Builder.defineMacro("__HEXAGON_ARCH__", "55");
6679 Builder.defineMacro("__QDSP6_V55__");
6680 Builder.defineMacro("__QDSP6_ARCH__", "55");
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006681 } else if (CPU == "hexagonv60") {
6682 Builder.defineMacro("__HEXAGON_V60__");
6683 Builder.defineMacro("__HEXAGON_ARCH__", "60");
6684 Builder.defineMacro("__QDSP6_V60__");
6685 Builder.defineMacro("__QDSP6_ARCH__", "60");
Krzysztof Parzyszekff7f6672017-03-14 20:29:23 +00006686 } else if (CPU == "hexagonv62") {
6687 Builder.defineMacro("__HEXAGON_V62__");
6688 Builder.defineMacro("__HEXAGON_ARCH__", "62");
Sirish Pande11ebc4e2012-05-10 20:19:54 +00006689 }
Krzysztof Parzyszek7f0756c2016-04-18 18:38:11 +00006690
6691 if (hasFeature("hvx")) {
6692 Builder.defineMacro("__HVX__");
6693 if (hasFeature("hvx-double"))
6694 Builder.defineMacro("__HVXDBL__");
6695 }
Tony Linthicum76329bf2011-12-12 21:14:55 +00006696}
6697
Krzysztof Parzyszek7cd30bd2016-08-30 14:17:10 +00006698bool HexagonTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features,
6699 DiagnosticsEngine &Diags, StringRef CPU,
6700 const std::vector<std::string> &FeaturesVec) const {
6701 // Default for v60: -hvx, -hvx-double.
6702 Features["hvx"] = false;
6703 Features["hvx-double"] = false;
6704 Features["long-calls"] = false;
6705
6706 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
6707}
6708
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006709bool HexagonTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
6710 DiagnosticsEngine &Diags) {
6711 for (auto &F : Features) {
6712 if (F == "+hvx")
6713 HasHVX = true;
6714 else if (F == "-hvx")
6715 HasHVX = HasHVXDouble = false;
6716 else if (F == "+hvx-double")
6717 HasHVX = HasHVXDouble = true;
6718 else if (F == "-hvx-double")
6719 HasHVXDouble = false;
Krzysztof Parzyszek1f269122016-08-30 13:57:50 +00006720
6721 if (F == "+long-calls")
6722 UseLongCalls = true;
Krzysztof Parzyszek7cd30bd2016-08-30 14:17:10 +00006723 else if (F == "-long-calls")
6724 UseLongCalls = false;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006725 }
6726 return true;
6727}
6728
Krzysztof Parzyszek7cd30bd2016-08-30 14:17:10 +00006729void HexagonTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
6730 StringRef Name, bool Enabled) const {
6731 if (Enabled) {
6732 if (Name == "hvx-double")
6733 Features["hvx"] = true;
6734 } else {
6735 if (Name == "hvx")
6736 Features["hvx-double"] = false;
6737 }
6738 Features[Name] = Enabled;
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006739}
6740
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006741const char *const HexagonTargetInfo::GCCRegNames[] = {
Tony Linthicum76329bf2011-12-12 21:14:55 +00006742 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
6743 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
6744 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
6745 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
6746 "p0", "p1", "p2", "p3",
6747 "sa0", "lc0", "sa1", "lc1", "m0", "m1", "usr", "ugp"
6748};
6749
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006750ArrayRef<const char*> HexagonTargetInfo::getGCCRegNames() const {
Craig Topperf054e3a2015-10-19 03:52:27 +00006751 return llvm::makeArrayRef(GCCRegNames);
Tony Linthicum76329bf2011-12-12 21:14:55 +00006752}
6753
Tony Linthicum76329bf2011-12-12 21:14:55 +00006754const TargetInfo::GCCRegAlias HexagonTargetInfo::GCCRegAliases[] = {
6755 { { "sp" }, "r29" },
6756 { { "fp" }, "r30" },
6757 { { "lr" }, "r31" },
Krzysztof Parzyszek1e6e3c62015-12-14 15:03:57 +00006758};
Tony Linthicum76329bf2011-12-12 21:14:55 +00006759
Craig Topperf054e3a2015-10-19 03:52:27 +00006760ArrayRef<TargetInfo::GCCRegAlias> HexagonTargetInfo::getGCCRegAliases() const {
6761 return llvm::makeArrayRef(GCCRegAliases);
Tony Linthicum76329bf2011-12-12 21:14:55 +00006762}
6763
6764
6765const Builtin::Info HexagonTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00006766#define BUILTIN(ID, TYPE, ATTRS) \
6767 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
6768#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
6769 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Tony Linthicum76329bf2011-12-12 21:14:55 +00006770#include "clang/Basic/BuiltinsHexagon.def"
6771};
Tony Linthicum76329bf2011-12-12 21:14:55 +00006772
Jacques Pienaard964cc22016-03-28 21:02:54 +00006773class LanaiTargetInfo : public TargetInfo {
6774 // Class for Lanai (32-bit).
6775 // The CPU profiles supported by the Lanai backend
6776 enum CPUKind {
6777 CK_NONE,
6778 CK_V11,
6779 } CPU;
6780
6781 static const TargetInfo::GCCRegAlias GCCRegAliases[];
6782 static const char *const GCCRegNames[];
6783
6784public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006785 LanaiTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
6786 : TargetInfo(Triple) {
Jacques Pienaard964cc22016-03-28 21:02:54 +00006787 // Description string has to be kept in sync with backend.
6788 resetDataLayout("E" // Big endian
6789 "-m:e" // ELF name manging
6790 "-p:32:32" // 32 bit pointers, 32 bit aligned
6791 "-i64:64" // 64 bit integers, 64 bit aligned
6792 "-a:0:32" // 32 bit alignment of objects of aggregate type
6793 "-n32" // 32 bit native integer width
6794 "-S64" // 64 bit natural stack alignment
6795 );
6796
6797 // Setting RegParmMax equal to what mregparm was set to in the old
6798 // toolchain
6799 RegParmMax = 4;
6800
6801 // Set the default CPU to V11
6802 CPU = CK_V11;
6803
6804 // Temporary approach to make everything at least word-aligned and allow for
6805 // safely casting between pointers with different alignment requirements.
6806 // TODO: Remove this when there are no more cast align warnings on the
6807 // firmware.
6808 MinGlobalAlign = 32;
6809 }
6810
6811 void getTargetDefines(const LangOptions &Opts,
6812 MacroBuilder &Builder) const override {
6813 // Define __lanai__ when building for target lanai.
6814 Builder.defineMacro("__lanai__");
6815
6816 // Set define for the CPU specified.
6817 switch (CPU) {
6818 case CK_V11:
6819 Builder.defineMacro("__LANAI_V11__");
6820 break;
6821 case CK_NONE:
6822 llvm_unreachable("Unhandled target CPU");
6823 }
6824 }
6825
6826 bool setCPU(const std::string &Name) override {
6827 CPU = llvm::StringSwitch<CPUKind>(Name)
6828 .Case("v11", CK_V11)
6829 .Default(CK_NONE);
6830
6831 return CPU != CK_NONE;
6832 }
6833
6834 bool hasFeature(StringRef Feature) const override {
6835 return llvm::StringSwitch<bool>(Feature).Case("lanai", true).Default(false);
6836 }
6837
6838 ArrayRef<const char *> getGCCRegNames() const override;
6839
6840 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
6841
6842 BuiltinVaListKind getBuiltinVaListKind() const override {
6843 return TargetInfo::VoidPtrBuiltinVaList;
6844 }
6845
6846 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
6847
6848 bool validateAsmConstraint(const char *&Name,
6849 TargetInfo::ConstraintInfo &info) const override {
6850 return false;
6851 }
6852
6853 const char *getClobbers() const override { return ""; }
6854};
6855
6856const char *const LanaiTargetInfo::GCCRegNames[] = {
6857 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10",
6858 "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", "r20", "r21",
6859 "r22", "r23", "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"};
6860
6861ArrayRef<const char *> LanaiTargetInfo::getGCCRegNames() const {
6862 return llvm::makeArrayRef(GCCRegNames);
6863}
6864
6865const TargetInfo::GCCRegAlias LanaiTargetInfo::GCCRegAliases[] = {
6866 {{"pc"}, "r2"},
6867 {{"sp"}, "r4"},
6868 {{"fp"}, "r5"},
6869 {{"rv"}, "r8"},
6870 {{"rr1"}, "r10"},
6871 {{"rr2"}, "r11"},
6872 {{"rca"}, "r15"},
6873};
6874
6875ArrayRef<TargetInfo::GCCRegAlias> LanaiTargetInfo::getGCCRegAliases() const {
6876 return llvm::makeArrayRef(GCCRegAliases);
6877}
6878
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006879// Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
6880class SparcTargetInfo : public TargetInfo {
Chris Lattner9b415d62009-01-27 01:58:38 +00006881 static const TargetInfo::GCCRegAlias GCCRegAliases[];
6882 static const char * const GCCRegNames[];
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00006883 bool SoftFloat;
Gabor Greif49991682008-02-21 16:29:08 +00006884public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00006885 SparcTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
James Y Knighta3518ad2016-01-27 01:04:51 +00006886 : TargetInfo(Triple), SoftFloat(false) {}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00006887
Joerg Sonnenbergerd0be8dc2016-03-07 17:19:15 +00006888 int getEHDataRegisterNumber(unsigned RegNo) const override {
6889 if (RegNo == 0) return 24;
6890 if (RegNo == 1) return 25;
6891 return -1;
6892 }
6893
Craig Topper3164f332014-03-11 03:39:26 +00006894 bool handleTargetFeatures(std::vector<std::string> &Features,
6895 DiagnosticsEngine &Diags) override {
Jacob Baungard Hansen13a49372016-05-24 08:30:08 +00006896 // Check if software floating point is enabled
Eric Christopherfb481a42015-04-29 23:32:17 +00006897 auto Feature = std::find(Features.begin(), Features.end(), "+soft-float");
6898 if (Feature != Features.end()) {
6899 SoftFloat = true;
Eric Christopherfb481a42015-04-29 23:32:17 +00006900 }
Rafael Espindolaeb265472013-08-21 21:59:03 +00006901 return true;
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00006902 }
Craig Topper3164f332014-03-11 03:39:26 +00006903 void getTargetDefines(const LangOptions &Opts,
6904 MacroBuilder &Builder) const override {
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00006905 DefineStd(Builder, "sparc", Opts);
Benjamin Kramer2d6fda32010-01-09 17:55:51 +00006906 Builder.defineMacro("__REGISTER_PREFIX__", "");
Bruno Cardoso Lopese7f211c2010-11-09 17:21:19 +00006907
6908 if (SoftFloat)
6909 Builder.defineMacro("SOFT_FLOAT", "1");
Gabor Greif49991682008-02-21 16:29:08 +00006910 }
Craig Topper3164f332014-03-11 03:39:26 +00006911
6912 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00006913 return llvm::StringSwitch<bool>(Feature)
6914 .Case("softfloat", SoftFloat)
6915 .Case("sparc", true)
6916 .Default(false);
6917 }
Craig Topper3164f332014-03-11 03:39:26 +00006918
Chris Dewhurst0381cd72016-06-15 12:44:47 +00006919 bool hasSjLjLowering() const override {
6920 return true;
6921 }
6922
Craig Topper6c03a542015-10-19 04:51:35 +00006923 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00006924 // FIXME: Implement!
Craig Topper6c03a542015-10-19 04:51:35 +00006925 return None;
Gabor Greif49991682008-02-21 16:29:08 +00006926 }
Craig Topper3164f332014-03-11 03:39:26 +00006927 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00006928 return TargetInfo::VoidPtrBuiltinVaList;
Gabor Greif49991682008-02-21 16:29:08 +00006929 }
Craig Topperf054e3a2015-10-19 03:52:27 +00006930 ArrayRef<const char *> getGCCRegNames() const override;
6931 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00006932 bool validateAsmConstraint(const char *&Name,
6933 TargetInfo::ConstraintInfo &info) const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00006934 // FIXME: Implement!
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00006935 switch (*Name) {
6936 case 'I': // Signed 13-bit constant
6937 case 'J': // Zero
6938 case 'K': // 32-bit constant with the low 12 bits clear
6939 case 'L': // A constant in the range supported by movcc (11-bit signed imm)
6940 case 'M': // A constant in the range supported by movrcc (19-bit signed imm)
6941 case 'N': // Same as 'K' but zext (required for SIMode)
6942 case 'O': // The constant 4096
6943 return true;
James Y Knighteb96e442017-05-12 16:01:23 +00006944
6945 case 'f':
6946 case 'e':
6947 info.setAllowsRegister();
6948 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00006949 }
Eli Friedmanda8f5a92008-08-20 07:28:14 +00006950 return false;
Gabor Greif49991682008-02-21 16:29:08 +00006951 }
Craig Topper3164f332014-03-11 03:39:26 +00006952 const char *getClobbers() const override {
Eli Friedmanda8f5a92008-08-20 07:28:14 +00006953 // FIXME: Implement!
6954 return "";
Gabor Greif49991682008-02-21 16:29:08 +00006955 }
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006956
6957 // No Sparc V7 for now, the backend doesn't support it anyway.
6958 enum CPUKind {
6959 CK_GENERIC,
6960 CK_V8,
6961 CK_SUPERSPARC,
6962 CK_SPARCLITE,
6963 CK_F934,
6964 CK_HYPERSPARC,
6965 CK_SPARCLITE86X,
6966 CK_SPARCLET,
6967 CK_TSC701,
6968 CK_V9,
6969 CK_ULTRASPARC,
6970 CK_ULTRASPARC3,
6971 CK_NIAGARA,
6972 CK_NIAGARA2,
6973 CK_NIAGARA3,
Douglas Katzman6871afc2016-03-15 22:34:02 +00006974 CK_NIAGARA4,
Douglas Katzman87da5f42016-07-25 16:36:02 +00006975 CK_MYRIAD2100,
6976 CK_MYRIAD2150,
6977 CK_MYRIAD2450,
Jacob Baungard Hansen1bf12822016-07-04 08:56:08 +00006978 CK_LEON2,
6979 CK_LEON2_AT697E,
6980 CK_LEON2_AT697F,
6981 CK_LEON3,
6982 CK_LEON3_UT699,
6983 CK_LEON3_GR712RC,
6984 CK_LEON4,
6985 CK_LEON4_GR740
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00006986 } CPU = CK_GENERIC;
6987
6988 enum CPUGeneration {
6989 CG_V8,
6990 CG_V9,
6991 };
6992
6993 CPUGeneration getCPUGeneration(CPUKind Kind) const {
6994 switch (Kind) {
6995 case CK_GENERIC:
6996 case CK_V8:
6997 case CK_SUPERSPARC:
6998 case CK_SPARCLITE:
6999 case CK_F934:
7000 case CK_HYPERSPARC:
7001 case CK_SPARCLITE86X:
7002 case CK_SPARCLET:
7003 case CK_TSC701:
Douglas Katzman87da5f42016-07-25 16:36:02 +00007004 case CK_MYRIAD2100:
7005 case CK_MYRIAD2150:
7006 case CK_MYRIAD2450:
Jacob Baungard Hansen1bf12822016-07-04 08:56:08 +00007007 case CK_LEON2:
7008 case CK_LEON2_AT697E:
7009 case CK_LEON2_AT697F:
7010 case CK_LEON3:
7011 case CK_LEON3_UT699:
7012 case CK_LEON3_GR712RC:
7013 case CK_LEON4:
7014 case CK_LEON4_GR740:
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007015 return CG_V8;
7016 case CK_V9:
7017 case CK_ULTRASPARC:
7018 case CK_ULTRASPARC3:
7019 case CK_NIAGARA:
7020 case CK_NIAGARA2:
7021 case CK_NIAGARA3:
7022 case CK_NIAGARA4:
7023 return CG_V9;
7024 }
Aaron Ballmana9a72852015-11-11 13:42:02 +00007025 llvm_unreachable("Unexpected CPU kind");
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007026 }
7027
7028 CPUKind getCPUKind(StringRef Name) const {
7029 return llvm::StringSwitch<CPUKind>(Name)
7030 .Case("v8", CK_V8)
7031 .Case("supersparc", CK_SUPERSPARC)
7032 .Case("sparclite", CK_SPARCLITE)
7033 .Case("f934", CK_F934)
7034 .Case("hypersparc", CK_HYPERSPARC)
7035 .Case("sparclite86x", CK_SPARCLITE86X)
7036 .Case("sparclet", CK_SPARCLET)
7037 .Case("tsc701", CK_TSC701)
7038 .Case("v9", CK_V9)
7039 .Case("ultrasparc", CK_ULTRASPARC)
7040 .Case("ultrasparc3", CK_ULTRASPARC3)
7041 .Case("niagara", CK_NIAGARA)
7042 .Case("niagara2", CK_NIAGARA2)
7043 .Case("niagara3", CK_NIAGARA3)
7044 .Case("niagara4", CK_NIAGARA4)
Douglas Katzman87da5f42016-07-25 16:36:02 +00007045 .Case("ma2100", CK_MYRIAD2100)
7046 .Case("ma2150", CK_MYRIAD2150)
7047 .Case("ma2450", CK_MYRIAD2450)
7048 // FIXME: the myriad2[.n] spellings are obsolete,
7049 // but a grace period is needed to allow updating dependent builds.
7050 .Case("myriad2", CK_MYRIAD2100)
7051 .Case("myriad2.1", CK_MYRIAD2100)
7052 .Case("myriad2.2", CK_MYRIAD2150)
Jacob Baungard Hansen1bf12822016-07-04 08:56:08 +00007053 .Case("leon2", CK_LEON2)
7054 .Case("at697e", CK_LEON2_AT697E)
7055 .Case("at697f", CK_LEON2_AT697F)
7056 .Case("leon3", CK_LEON3)
7057 .Case("ut699", CK_LEON3_UT699)
7058 .Case("gr712rc", CK_LEON3_GR712RC)
7059 .Case("leon4", CK_LEON4)
7060 .Case("gr740", CK_LEON4_GR740)
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007061 .Default(CK_GENERIC);
7062 }
7063
7064 bool setCPU(const std::string &Name) override {
7065 CPU = getCPUKind(Name);
7066 return CPU != CK_GENERIC;
7067 }
Gabor Greif49991682008-02-21 16:29:08 +00007068};
7069
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007070const char * const SparcTargetInfo::GCCRegNames[] = {
Chris Lattner9b415d62009-01-27 01:58:38 +00007071 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
7072 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
7073 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
7074 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31"
7075};
7076
Craig Topperf054e3a2015-10-19 03:52:27 +00007077ArrayRef<const char *> SparcTargetInfo::getGCCRegNames() const {
7078 return llvm::makeArrayRef(GCCRegNames);
Chris Lattner9b415d62009-01-27 01:58:38 +00007079}
7080
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007081const TargetInfo::GCCRegAlias SparcTargetInfo::GCCRegAliases[] = {
Anton Korobeynikov9d026dd2009-05-03 13:42:53 +00007082 { { "g0" }, "r0" },
7083 { { "g1" }, "r1" },
7084 { { "g2" }, "r2" },
7085 { { "g3" }, "r3" },
7086 { { "g4" }, "r4" },
7087 { { "g5" }, "r5" },
7088 { { "g6" }, "r6" },
7089 { { "g7" }, "r7" },
7090 { { "o0" }, "r8" },
7091 { { "o1" }, "r9" },
7092 { { "o2" }, "r10" },
7093 { { "o3" }, "r11" },
7094 { { "o4" }, "r12" },
7095 { { "o5" }, "r13" },
7096 { { "o6", "sp" }, "r14" },
7097 { { "o7" }, "r15" },
7098 { { "l0" }, "r16" },
7099 { { "l1" }, "r17" },
7100 { { "l2" }, "r18" },
7101 { { "l3" }, "r19" },
7102 { { "l4" }, "r20" },
7103 { { "l5" }, "r21" },
7104 { { "l6" }, "r22" },
7105 { { "l7" }, "r23" },
7106 { { "i0" }, "r24" },
7107 { { "i1" }, "r25" },
7108 { { "i2" }, "r26" },
7109 { { "i3" }, "r27" },
7110 { { "i4" }, "r28" },
7111 { { "i5" }, "r29" },
7112 { { "i6", "fp" }, "r30" },
7113 { { "i7" }, "r31" },
Chris Lattner9b415d62009-01-27 01:58:38 +00007114};
7115
Craig Topperf054e3a2015-10-19 03:52:27 +00007116ArrayRef<TargetInfo::GCCRegAlias> SparcTargetInfo::getGCCRegAliases() const {
7117 return llvm::makeArrayRef(GCCRegAliases);
Chris Lattner9b415d62009-01-27 01:58:38 +00007118}
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007119
7120// SPARC v8 is the 32-bit mode selected by Triple::sparc.
7121class SparcV8TargetInfo : public SparcTargetInfo {
7122public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007123 SparcV8TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7124 : SparcTargetInfo(Triple, Opts) {
James Y Knightb214cbc2016-03-04 19:00:41 +00007125 resetDataLayout("E-m:e-p:32:32-i64:64-f128:64-n32-S64");
Brad Smith73859112015-08-13 21:45:57 +00007126 // NetBSD / OpenBSD use long (same as llvm default); everyone else uses int.
7127 switch (getTriple().getOS()) {
7128 default:
James Y Knight4b4d19e2015-06-04 15:36:29 +00007129 SizeType = UnsignedInt;
7130 IntPtrType = SignedInt;
7131 PtrDiffType = SignedInt;
Brad Smith73859112015-08-13 21:45:57 +00007132 break;
7133 case llvm::Triple::NetBSD:
7134 case llvm::Triple::OpenBSD:
7135 SizeType = UnsignedLong;
7136 IntPtrType = SignedLong;
7137 PtrDiffType = SignedLong;
7138 break;
Brad Smith56495d52015-08-13 22:00:53 +00007139 }
Douglas Katzman13f4a912016-11-09 15:43:51 +00007140 // Up to 32 bits are lock-free atomic, but we're willing to do atomic ops
7141 // on up to 64 bits.
7142 MaxAtomicPromoteWidth = 64;
7143 MaxAtomicInlineWidth = 32;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007144 }
7145
Craig Topper3164f332014-03-11 03:39:26 +00007146 void getTargetDefines(const LangOptions &Opts,
7147 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007148 SparcTargetInfo::getTargetDefines(Opts, Builder);
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007149 switch (getCPUGeneration(CPU)) {
7150 case CG_V8:
7151 Builder.defineMacro("__sparcv8");
7152 if (getTriple().getOS() != llvm::Triple::Solaris)
7153 Builder.defineMacro("__sparcv8__");
7154 break;
7155 case CG_V9:
7156 Builder.defineMacro("__sparcv9");
Joerg Sonnenberger4ecfa622015-11-10 19:28:17 +00007157 if (getTriple().getOS() != llvm::Triple::Solaris) {
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007158 Builder.defineMacro("__sparcv9__");
Joerg Sonnenberger4ecfa622015-11-10 19:28:17 +00007159 Builder.defineMacro("__sparc_v9__");
7160 }
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007161 break;
7162 }
Douglas Katzman6871afc2016-03-15 22:34:02 +00007163 if (getTriple().getVendor() == llvm::Triple::Myriad) {
Douglas Katzman87da5f42016-07-25 16:36:02 +00007164 std::string MyriadArchValue, Myriad2Value;
7165 Builder.defineMacro("__sparc_v8__");
7166 Builder.defineMacro("__leon__");
Douglas Katzman6871afc2016-03-15 22:34:02 +00007167 switch (CPU) {
Douglas Katzman87da5f42016-07-25 16:36:02 +00007168 case CK_MYRIAD2150:
7169 MyriadArchValue = "__ma2150";
7170 Myriad2Value = "2";
Douglas Katzman6871afc2016-03-15 22:34:02 +00007171 break;
Douglas Katzman87da5f42016-07-25 16:36:02 +00007172 case CK_MYRIAD2450:
7173 MyriadArchValue = "__ma2450";
7174 Myriad2Value = "2";
Douglas Katzman6871afc2016-03-15 22:34:02 +00007175 break;
7176 default:
Douglas Katzman87da5f42016-07-25 16:36:02 +00007177 MyriadArchValue = "__ma2100";
7178 Myriad2Value = "1";
Douglas Katzman6871afc2016-03-15 22:34:02 +00007179 break;
7180 }
Douglas Katzman87da5f42016-07-25 16:36:02 +00007181 Builder.defineMacro(MyriadArchValue, "1");
7182 Builder.defineMacro(MyriadArchValue+"__", "1");
7183 Builder.defineMacro("__myriad2__", Myriad2Value);
7184 Builder.defineMacro("__myriad2", Myriad2Value);
Douglas Katzman6871afc2016-03-15 22:34:02 +00007185 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007186 }
Chris Dewhurst69fa1922016-05-04 09:33:30 +00007187
7188 bool hasSjLjLowering() const override {
7189 return true;
7190 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007191};
7192
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007193// SPARCV8el is the 32-bit little-endian mode selected by Triple::sparcel.
7194class SparcV8elTargetInfo : public SparcV8TargetInfo {
7195 public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007196 SparcV8elTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7197 : SparcV8TargetInfo(Triple, Opts) {
7198 resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32-S64");
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00007199 }
7200};
7201
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007202// SPARC v9 is the 64-bit mode selected by Triple::sparcv9.
7203class SparcV9TargetInfo : public SparcTargetInfo {
7204public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007205 SparcV9TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7206 : SparcTargetInfo(Triple, Opts) {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007207 // FIXME: Support Sparc quad-precision long double?
James Y Knightb214cbc2016-03-04 19:00:41 +00007208 resetDataLayout("E-m:e-i64:64-n32:64-S128");
Jakob Stoklund Olesen248520b2013-05-15 03:22:33 +00007209 // This is an LP64 platform.
7210 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00007211
7212 // OpenBSD uses long long for int64_t and intmax_t.
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00007213 if (getTriple().getOS() == llvm::Triple::OpenBSD)
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00007214 IntMaxType = SignedLongLong;
Joerg Sonnenberger9b7060e2014-07-14 21:00:38 +00007215 else
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00007216 IntMaxType = SignedLong;
Jakob Stoklund Olesen826df142013-05-19 17:53:37 +00007217 Int64Type = IntMaxType;
Jakob Stoklund Olesen497332c2014-01-16 16:43:19 +00007218
7219 // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
7220 // aligned. The SPARCv9 SCD 2.4.1 says 16-byte aligned.
7221 LongDoubleWidth = 128;
7222 LongDoubleAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007223 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Jakob Stoklund Olesen5b630b42014-01-30 04:48:04 +00007224 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007225 }
7226
Craig Topper3164f332014-03-11 03:39:26 +00007227 void getTargetDefines(const LangOptions &Opts,
7228 MacroBuilder &Builder) const override {
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007229 SparcTargetInfo::getTargetDefines(Opts, Builder);
7230 Builder.defineMacro("__sparcv9");
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00007231 Builder.defineMacro("__arch64__");
Rafael Espindola76483742014-08-14 15:14:51 +00007232 // Solaris doesn't need these variants, but the BSDs do.
7233 if (getTriple().getOS() != llvm::Triple::Solaris) {
Jakob Stoklund Olesenf7599892013-04-24 04:36:38 +00007234 Builder.defineMacro("__sparc64__");
7235 Builder.defineMacro("__sparc_v9__");
7236 Builder.defineMacro("__sparcv9__");
7237 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007238 }
Roman Divackyb1ae3d42014-02-25 18:35:30 +00007239
Craig Topper3164f332014-03-11 03:39:26 +00007240 bool setCPU(const std::string &Name) override {
Joerg Sonnenbergerec353d32015-11-09 23:39:45 +00007241 if (!SparcTargetInfo::setCPU(Name))
7242 return false;
7243 return getCPUGeneration(CPU) == CG_V9;
Roman Divackyb1ae3d42014-02-25 18:35:30 +00007244 }
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00007245};
7246
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007247class SystemZTargetInfo : public TargetInfo {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007248 static const Builtin::Info BuiltinInfo[];
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007249 static const char *const GCCRegNames[];
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007250 std::string CPU;
7251 bool HasTransactionalExecution;
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007252 bool HasVector;
Ulrich Weigand47445072013-05-06 16:26:41 +00007253
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007254public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007255 SystemZTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
Eric Christopherb093d692015-10-09 18:39:59 +00007256 : TargetInfo(Triple), CPU("z10"), HasTransactionalExecution(false),
7257 HasVector(false) {
Ulrich Weigand881497a2015-03-30 13:50:21 +00007258 IntMaxType = SignedLong;
7259 Int64Type = SignedLong;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007260 TLSSupported = true;
7261 IntWidth = IntAlign = 32;
7262 LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;
7263 PointerWidth = PointerAlign = 64;
7264 LongDoubleWidth = 128;
7265 LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007266 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Ulrich Weigandca3cb7f2015-04-21 17:29:35 +00007267 DefaultAlignForAttributeAligned = 64;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007268 MinGlobalAlign = 16;
James Y Knightb214cbc2016-03-04 19:00:41 +00007269 resetDataLayout("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 +00007270 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7271 }
7272 void getTargetDefines(const LangOptions &Opts,
7273 MacroBuilder &Builder) const override {
7274 Builder.defineMacro("__s390__");
7275 Builder.defineMacro("__s390x__");
7276 Builder.defineMacro("__zarch__");
7277 Builder.defineMacro("__LONG_DOUBLE_128__");
Ulrich Weigandb038a522016-02-05 21:34:28 +00007278
Ulrich Weigand82a86cb2017-02-06 17:04:22 +00007279 const std::string ISARev = llvm::StringSwitch<std::string>(CPU)
7280 .Cases("arch8", "z10", "8")
7281 .Cases("arch9", "z196", "9")
7282 .Cases("arch10", "zEC12", "10")
7283 .Cases("arch11", "z13", "11")
7284 .Default("");
7285 if (!ISARev.empty())
7286 Builder.defineMacro("__ARCH__", ISARev);
7287
Ulrich Weigandb038a522016-02-05 21:34:28 +00007288 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
7289 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
7290 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
7291 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
7292
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007293 if (HasTransactionalExecution)
7294 Builder.defineMacro("__HTM__");
Ulrich Weigand82a86cb2017-02-06 17:04:22 +00007295 if (HasVector)
7296 Builder.defineMacro("__VX__");
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00007297 if (Opts.ZVector)
7298 Builder.defineMacro("__VEC__", "10301");
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007299 }
Craig Topper6c03a542015-10-19 04:51:35 +00007300 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7301 return llvm::makeArrayRef(BuiltinInfo,
7302 clang::SystemZ::LastTSBuiltin-Builtin::FirstTSBuiltin);
Ulrich Weigand47445072013-05-06 16:26:41 +00007303 }
7304
Craig Topperf054e3a2015-10-19 03:52:27 +00007305 ArrayRef<const char *> getGCCRegNames() const override;
7306 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007307 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00007308 return None;
Ulrich Weigand47445072013-05-06 16:26:41 +00007309 }
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007310 bool validateAsmConstraint(const char *&Name,
7311 TargetInfo::ConstraintInfo &info) const override;
7312 const char *getClobbers() const override {
7313 // FIXME: Is this really right?
7314 return "";
7315 }
7316 BuiltinVaListKind getBuiltinVaListKind() const override {
7317 return TargetInfo::SystemZBuiltinVaList;
7318 }
7319 bool setCPU(const std::string &Name) override {
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007320 CPU = Name;
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007321 bool CPUKnown = llvm::StringSwitch<bool>(Name)
7322 .Case("z10", true)
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007323 .Case("arch8", true)
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007324 .Case("z196", true)
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007325 .Case("arch9", true)
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007326 .Case("zEC12", true)
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007327 .Case("arch10", true)
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007328 .Case("z13", true)
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007329 .Case("arch11", true)
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007330 .Default(false);
7331
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007332 return CPUKnown;
7333 }
Eric Christopher8c47b422015-10-09 18:39:55 +00007334 bool
7335 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
7336 StringRef CPU,
7337 const std::vector<std::string> &FeaturesVec) const override {
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007338 if (CPU == "zEC12" || CPU == "arch10")
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007339 Features["transactional-execution"] = true;
Ulrich Weigand30354eb2016-10-31 14:38:05 +00007340 if (CPU == "z13" || CPU == "arch11") {
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007341 Features["transactional-execution"] = true;
7342 Features["vector"] = true;
7343 }
Eric Christopher007b0a02015-08-28 22:32:01 +00007344 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007345 }
7346
7347 bool handleTargetFeatures(std::vector<std::string> &Features,
7348 DiagnosticsEngine &Diags) override {
7349 HasTransactionalExecution = false;
Eric Christopher610fe112015-08-26 08:21:55 +00007350 for (const auto &Feature : Features) {
7351 if (Feature == "+transactional-execution")
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007352 HasTransactionalExecution = true;
Eric Christopher610fe112015-08-26 08:21:55 +00007353 else if (Feature == "+vector")
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007354 HasVector = true;
7355 }
7356 // If we use the vector ABI, vector types are 64-bit aligned.
7357 if (HasVector) {
7358 MaxVectorAlign = 64;
James Y Knightb214cbc2016-03-04 19:00:41 +00007359 resetDataLayout("E-m:e-i1:8:16-i8:8:16-i64:64-f128:64"
7360 "-v128:64-a:8:16-n32:64");
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007361 }
7362 return true;
7363 }
7364
7365 bool hasFeature(StringRef Feature) const override {
7366 return llvm::StringSwitch<bool>(Feature)
Ulrich Weigandcc673442015-04-01 14:15:35 +00007367 .Case("systemz", true)
7368 .Case("htm", HasTransactionalExecution)
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007369 .Case("vx", HasVector)
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007370 .Default(false);
7371 }
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007372
Bryan Chane3f1ed52016-04-28 13:56:43 +00007373 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
7374 switch (CC) {
7375 case CC_C:
7376 case CC_Swift:
7377 return CCCR_OK;
7378 default:
7379 return CCCR_Warning;
7380 }
7381 }
7382
Ulrich Weigand66ff51b2015-05-05 19:35:52 +00007383 StringRef getABI() const override {
7384 if (HasVector)
7385 return "vector";
7386 return "";
7387 }
Ulrich Weigand47fd2532015-06-16 15:21:47 +00007388
7389 bool useFloat128ManglingForLongDouble() const override {
7390 return true;
7391 }
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007392};
7393
7394const Builtin::Info SystemZTargetInfo::BuiltinInfo[] = {
7395#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00007396 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
Jonas Paulsson3ace74a2016-03-30 15:51:24 +00007397#define TARGET_BUILTIN(ID, TYPE, ATTRS, FEATURE) \
7398 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, FEATURE },
Ulrich Weigand3a610eb2015-04-01 12:54:25 +00007399#include "clang/Basic/BuiltinsSystemZ.def"
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007400};
7401
7402const char *const SystemZTargetInfo::GCCRegNames[] = {
7403 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
7404 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
7405 "f0", "f2", "f4", "f6", "f1", "f3", "f5", "f7",
7406 "f8", "f10", "f12", "f14", "f9", "f11", "f13", "f15"
7407};
7408
Craig Topperf054e3a2015-10-19 03:52:27 +00007409ArrayRef<const char *> SystemZTargetInfo::getGCCRegNames() const {
7410 return llvm::makeArrayRef(GCCRegNames);
Richard Sandifordd03f7b72014-04-10 09:56:24 +00007411}
7412
7413bool SystemZTargetInfo::
7414validateAsmConstraint(const char *&Name,
7415 TargetInfo::ConstraintInfo &Info) const {
7416 switch (*Name) {
7417 default:
7418 return false;
7419
7420 case 'a': // Address register
7421 case 'd': // Data register (equivalent to 'r')
7422 case 'f': // Floating-point register
7423 Info.setAllowsRegister();
7424 return true;
7425
7426 case 'I': // Unsigned 8-bit constant
7427 case 'J': // Unsigned 12-bit constant
7428 case 'K': // Signed 16-bit constant
7429 case 'L': // Signed 20-bit displacement (on all targets we support)
7430 case 'M': // 0x7fffffff
7431 return true;
7432
7433 case 'Q': // Memory with base and unsigned 12-bit displacement
7434 case 'R': // Likewise, plus an index
7435 case 'S': // Memory with base and signed 20-bit displacement
7436 case 'T': // Likewise, plus an index
7437 Info.setAllowsMemory();
7438 return true;
7439 }
7440}
Ulrich Weigand47445072013-05-06 16:26:41 +00007441
Eric Christopherc48497a2015-09-18 21:26:24 +00007442class MSP430TargetInfo : public TargetInfo {
7443 static const char *const GCCRegNames[];
Anton Korobeynikova0f54372009-05-03 13:43:08 +00007444
Eric Christopherc48497a2015-09-18 21:26:24 +00007445public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007446 MSP430TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7447 : TargetInfo(Triple) {
Eric Christopherc48497a2015-09-18 21:26:24 +00007448 TLSSupported = false;
7449 IntWidth = 16;
7450 IntAlign = 16;
7451 LongWidth = 32;
7452 LongLongWidth = 64;
7453 LongAlign = LongLongAlign = 16;
7454 PointerWidth = 16;
7455 PointerAlign = 16;
7456 SuitableAlign = 16;
7457 SizeType = UnsignedInt;
7458 IntMaxType = SignedLongLong;
7459 IntPtrType = SignedInt;
7460 PtrDiffType = SignedInt;
7461 SigAtomicType = SignedLong;
James Y Knightb214cbc2016-03-04 19:00:41 +00007462 resetDataLayout("e-m:e-p:16:16-i32:16:32-a:16-n8:16");
Anton Korobeynikova0f54372009-05-03 13:43:08 +00007463 }
Eric Christopherc48497a2015-09-18 21:26:24 +00007464 void getTargetDefines(const LangOptions &Opts,
7465 MacroBuilder &Builder) const override {
7466 Builder.defineMacro("MSP430");
7467 Builder.defineMacro("__MSP430__");
7468 // FIXME: defines for different 'flavours' of MCU
7469 }
Craig Topper6c03a542015-10-19 04:51:35 +00007470 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00007471 // FIXME: Implement.
Craig Topper6c03a542015-10-19 04:51:35 +00007472 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00007473 }
7474 bool hasFeature(StringRef Feature) const override {
7475 return Feature == "msp430";
7476 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007477 ArrayRef<const char *> getGCCRegNames() const override;
7478 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
Eric Christopherc48497a2015-09-18 21:26:24 +00007479 // No aliases.
Craig Topperf054e3a2015-10-19 03:52:27 +00007480 return None;
Eric Christopherc48497a2015-09-18 21:26:24 +00007481 }
7482 bool validateAsmConstraint(const char *&Name,
7483 TargetInfo::ConstraintInfo &info) const override {
7484 // FIXME: implement
7485 switch (*Name) {
7486 case 'K': // the constant 1
7487 case 'L': // constant -1^20 .. 1^19
7488 case 'M': // constant 1-4:
Eli Friedmana9c3d712009-08-19 20:47:07 +00007489 return true;
7490 }
Eric Christopherc48497a2015-09-18 21:26:24 +00007491 // No target constraints for now.
7492 return false;
7493 }
7494 const char *getClobbers() const override {
7495 // FIXME: Is this really right?
7496 return "";
7497 }
7498 BuiltinVaListKind getBuiltinVaListKind() const override {
7499 // FIXME: implement
7500 return TargetInfo::CharPtrBuiltinVaList;
7501 }
7502};
7503
7504const char *const MSP430TargetInfo::GCCRegNames[] = {
7505 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
7506 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"};
7507
Craig Topperf054e3a2015-10-19 03:52:27 +00007508ArrayRef<const char *> MSP430TargetInfo::getGCCRegNames() const {
7509 return llvm::makeArrayRef(GCCRegNames);
Eric Christopherc48497a2015-09-18 21:26:24 +00007510}
7511
7512// LLVM and Clang cannot be used directly to output native binaries for
7513// target, but is used to compile C code to llvm bitcode with correct
7514// type and alignment information.
7515//
7516// TCE uses the llvm bitcode as input and uses it for generating customized
7517// target processor and program binary. TCE co-design environment is
7518// publicly available in http://tce.cs.tut.fi
7519
7520static const unsigned TCEOpenCLAddrSpaceMap[] = {
Yaxun Liub34ec822017-04-11 17:24:23 +00007521 0, // Default
Eric Christopherc48497a2015-09-18 21:26:24 +00007522 3, // opencl_global
7523 4, // opencl_local
7524 5, // opencl_constant
7525 // FIXME: generic has to be added to the target
7526 0, // opencl_generic
7527 0, // cuda_device
7528 0, // cuda_constant
7529 0 // cuda_shared
7530};
7531
7532class TCETargetInfo : public TargetInfo {
7533public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007534 TCETargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7535 : TargetInfo(Triple) {
Eric Christopherc48497a2015-09-18 21:26:24 +00007536 TLSSupported = false;
7537 IntWidth = 32;
7538 LongWidth = LongLongWidth = 32;
7539 PointerWidth = 32;
7540 IntAlign = 32;
7541 LongAlign = LongLongAlign = 32;
7542 PointerAlign = 32;
7543 SuitableAlign = 32;
7544 SizeType = UnsignedInt;
7545 IntMaxType = SignedLong;
7546 IntPtrType = SignedInt;
7547 PtrDiffType = SignedInt;
7548 FloatWidth = 32;
7549 FloatAlign = 32;
7550 DoubleWidth = 32;
7551 DoubleAlign = 32;
7552 LongDoubleWidth = 32;
7553 LongDoubleAlign = 32;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007554 FloatFormat = &llvm::APFloat::IEEEsingle();
7555 DoubleFormat = &llvm::APFloat::IEEEsingle();
7556 LongDoubleFormat = &llvm::APFloat::IEEEsingle();
Pekka Jaaskelainen67354482016-11-16 15:22:31 +00007557 resetDataLayout("E-p:32:32:32-i1:8:8-i8:8:32-"
7558 "i16:16:32-i32:32:32-i64:32:32-"
7559 "f32:32:32-f64:32:32-v64:32:32-"
7560 "v128:32:32-v256:32:32-v512:32:32-"
7561 "v1024:32:32-a0:0:32-n32");
Eric Christopherc48497a2015-09-18 21:26:24 +00007562 AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
7563 UseAddrSpaceMapMangling = true;
7564 }
7565
7566 void getTargetDefines(const LangOptions &Opts,
7567 MacroBuilder &Builder) const override {
7568 DefineStd(Builder, "tce", Opts);
7569 Builder.defineMacro("__TCE__");
7570 Builder.defineMacro("__TCE_V1__");
7571 }
7572 bool hasFeature(StringRef Feature) const override { return Feature == "tce"; }
7573
Craig Topper6c03a542015-10-19 04:51:35 +00007574 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00007575 const char *getClobbers() const override { return ""; }
7576 BuiltinVaListKind getBuiltinVaListKind() const override {
7577 return TargetInfo::VoidPtrBuiltinVaList;
7578 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007579 ArrayRef<const char *> getGCCRegNames() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00007580 bool validateAsmConstraint(const char *&Name,
7581 TargetInfo::ConstraintInfo &info) const override {
7582 return true;
7583 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007584 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7585 return None;
7586 }
Eric Christopherc48497a2015-09-18 21:26:24 +00007587};
Eli Friedmana9c3d712009-08-19 20:47:07 +00007588
Pekka Jaaskelainen67354482016-11-16 15:22:31 +00007589class TCELETargetInfo : public TCETargetInfo {
7590public:
7591 TCELETargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
7592 : TCETargetInfo(Triple, Opts) {
7593 BigEndian = false;
7594
7595 resetDataLayout("e-p:32:32:32-i1:8:8-i8:8:32-"
7596 "i16:16:32-i32:32:32-i64:32:32-"
7597 "f32:32:32-f64:32:32-v64:32:32-"
7598 "v128:32:32-v256:32:32-v512:32:32-"
7599 "v1024:32:32-a0:0:32-n32");
7600
7601 }
7602
7603 virtual void getTargetDefines(const LangOptions &Opts,
7604 MacroBuilder &Builder) const {
7605 DefineStd(Builder, "tcele", Opts);
7606 Builder.defineMacro("__TCE__");
7607 Builder.defineMacro("__TCE_V1__");
7608 Builder.defineMacro("__TCELE__");
7609 Builder.defineMacro("__TCELE_V1__");
7610 }
7611
7612};
7613
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007614class BPFTargetInfo : public TargetInfo {
7615public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00007616 BPFTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
7617 : TargetInfo(Triple) {
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007618 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
7619 SizeType = UnsignedLong;
7620 PtrDiffType = SignedLong;
7621 IntPtrType = SignedLong;
7622 IntMaxType = SignedLong;
7623 Int64Type = SignedLong;
7624 RegParmMax = 5;
7625 if (Triple.getArch() == llvm::Triple::bpfeb) {
James Y Knightb214cbc2016-03-04 19:00:41 +00007626 resetDataLayout("E-m:e-p:64:64-i64:64-n32:64-S128");
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007627 } else {
James Y Knightb214cbc2016-03-04 19:00:41 +00007628 resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007629 }
7630 MaxAtomicPromoteWidth = 64;
7631 MaxAtomicInlineWidth = 64;
7632 TLSSupported = false;
7633 }
7634 void getTargetDefines(const LangOptions &Opts,
7635 MacroBuilder &Builder) const override {
7636 DefineStd(Builder, "bpf", Opts);
7637 Builder.defineMacro("__BPF__");
7638 }
7639 bool hasFeature(StringRef Feature) const override {
7640 return Feature == "bpf";
7641 }
7642
Craig Topper6c03a542015-10-19 04:51:35 +00007643 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007644 const char *getClobbers() const override {
7645 return "";
7646 }
7647 BuiltinVaListKind getBuiltinVaListKind() const override {
7648 return TargetInfo::VoidPtrBuiltinVaList;
7649 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007650 ArrayRef<const char *> getGCCRegNames() const override {
7651 return None;
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007652 }
7653 bool validateAsmConstraint(const char *&Name,
7654 TargetInfo::ConstraintInfo &info) const override {
7655 return true;
7656 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007657 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
7658 return None;
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00007659 }
7660};
7661
Daniel Sanders4672af62016-05-27 11:51:02 +00007662class MipsTargetInfo : public TargetInfo {
7663 void setDataLayout() {
Daniel Sanders55e40692016-06-03 10:11:01 +00007664 StringRef Layout;
7665
7666 if (ABI == "o32")
7667 Layout = "m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64";
7668 else if (ABI == "n32")
Daniel Sanders6a738832016-07-19 10:49:03 +00007669 Layout = "m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Daniel Sanders55e40692016-06-03 10:11:01 +00007670 else if (ABI == "n64")
Daniel Sanders6a738832016-07-19 10:49:03 +00007671 Layout = "m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128";
Daniel Sanders55e40692016-06-03 10:11:01 +00007672 else
7673 llvm_unreachable("Invalid ABI");
7674
7675 if (BigEndian)
7676 resetDataLayout(("E-" + Layout).str());
7677 else
7678 resetDataLayout(("e-" + Layout).str());
Daniel Sanders4672af62016-05-27 11:51:02 +00007679 }
7680
Akira Hatanaka9064e362013-10-29 18:30:33 +00007681
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00007682 static const Builtin::Info BuiltinInfo[];
Akira Hatanakaf6da3312011-09-20 19:00:23 +00007683 std::string CPU;
Simon Atanasyan72244b62012-07-05 16:06:06 +00007684 bool IsMips16;
Simon Atanasyan60777612013-04-14 14:07:51 +00007685 bool IsMicromips;
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007686 bool IsNan2008;
Simon Atanasyan16071912013-04-14 14:07:30 +00007687 bool IsSingleFloat;
Simon Dardisdf827a72017-02-21 16:01:00 +00007688 bool IsNoABICalls;
7689 bool CanUseBSDABICalls;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007690 enum MipsFloatABI {
Simon Atanasyan16071912013-04-14 14:07:30 +00007691 HardFloat, SoftFloat
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007692 } FloatABI;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00007693 enum DspRevEnum {
7694 NoDSP, DSP1, DSP2
7695 } DspRev;
Jack Carter44ff1e52013-08-12 17:20:29 +00007696 bool HasMSA;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00007697
Akira Hatanakaf6da3312011-09-20 19:00:23 +00007698protected:
Akira Hatanaka618b2982013-10-29 19:00:35 +00007699 bool HasFP64;
Akira Hatanakaf6da3312011-09-20 19:00:23 +00007700 std::string ABI;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00007701
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007702public:
Daniel Sanders4672af62016-05-27 11:51:02 +00007703 MipsTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007704 : TargetInfo(Triple), IsMips16(false), IsMicromips(false),
Simon Dardisdf827a72017-02-21 16:01:00 +00007705 IsNan2008(false), IsSingleFloat(false), IsNoABICalls(false),
7706 CanUseBSDABICalls(false), FloatABI(HardFloat), DspRev(NoDSP),
7707 HasMSA(false), HasFP64(false) {
Zoran Jovanovic26a12162015-02-18 15:21:35 +00007708 TheCXXABI.set(TargetCXXABI::GenericMIPS);
Daniel Sanders4672af62016-05-27 11:51:02 +00007709
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007710 setABI((getTriple().getArch() == llvm::Triple::mips ||
7711 getTriple().getArch() == llvm::Triple::mipsel)
7712 ? "o32"
7713 : "n64");
7714
7715 CPU = ABI == "o32" ? "mips32r2" : "mips64r2";
Simon Dardisdf827a72017-02-21 16:01:00 +00007716
7717 CanUseBSDABICalls = Triple.getOS() == llvm::Triple::FreeBSD ||
7718 Triple.getOS() == llvm::Triple::OpenBSD;
Zoran Jovanovic26a12162015-02-18 15:21:35 +00007719 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00007720
Daniel Sanders9500d2d2014-07-09 13:56:23 +00007721 bool isNaN2008Default() const {
7722 return CPU == "mips32r6" || CPU == "mips64r6";
7723 }
7724
7725 bool isFP64Default() const {
7726 return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
7727 }
7728
Petar Jovanovicd55ae6b2015-02-26 18:19:22 +00007729 bool isNan2008() const override {
7730 return IsNan2008;
7731 }
7732
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007733 bool processorSupportsGPR64() const {
7734 return llvm::StringSwitch<bool>(CPU)
7735 .Case("mips3", true)
7736 .Case("mips4", true)
7737 .Case("mips5", true)
7738 .Case("mips64", true)
7739 .Case("mips64r2", true)
7740 .Case("mips64r3", true)
7741 .Case("mips64r5", true)
7742 .Case("mips64r6", true)
7743 .Case("octeon", true)
7744 .Default(false);
7745 return false;
7746 }
7747
Alp Toker4925ba72014-06-07 23:30:42 +00007748 StringRef getABI() const override { return ABI; }
Daniel Sanders4672af62016-05-27 11:51:02 +00007749 bool setABI(const std::string &Name) override {
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007750 if (Name == "o32") {
7751 setO32ABITypes();
7752 ABI = Name;
7753 return true;
Daniel Sanders4672af62016-05-27 11:51:02 +00007754 }
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007755
7756 if (Name == "n32") {
7757 setN32ABITypes();
7758 ABI = Name;
7759 return true;
7760 }
7761 if (Name == "n64") {
7762 setN64ABITypes();
7763 ABI = Name;
7764 return true;
Daniel Sanders4672af62016-05-27 11:51:02 +00007765 }
7766 return false;
7767 }
7768
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007769 void setO32ABITypes() {
7770 Int64Type = SignedLongLong;
7771 IntMaxType = Int64Type;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007772 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007773 LongDoubleWidth = LongDoubleAlign = 64;
7774 LongWidth = LongAlign = 32;
7775 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
7776 PointerWidth = PointerAlign = 32;
7777 PtrDiffType = SignedInt;
7778 SizeType = UnsignedInt;
7779 SuitableAlign = 64;
7780 }
7781
7782 void setN32N64ABITypes() {
7783 LongDoubleWidth = LongDoubleAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007784 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007785 if (getTriple().getOS() == llvm::Triple::FreeBSD) {
7786 LongDoubleWidth = LongDoubleAlign = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00007787 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007788 }
7789 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
7790 SuitableAlign = 128;
7791 }
7792
Daniel Sanders4672af62016-05-27 11:51:02 +00007793 void setN64ABITypes() {
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007794 setN32N64ABITypes();
Brad Smith8e55bd52017-03-06 23:48:31 +00007795 if (getTriple().getOS() == llvm::Triple::OpenBSD) {
7796 Int64Type = SignedLongLong;
7797 } else {
7798 Int64Type = SignedLong;
7799 }
Daniel Sanders4672af62016-05-27 11:51:02 +00007800 IntMaxType = Int64Type;
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007801 LongWidth = LongAlign = 64;
7802 PointerWidth = PointerAlign = 64;
7803 PtrDiffType = SignedLong;
7804 SizeType = UnsignedLong;
Daniel Sanders4672af62016-05-27 11:51:02 +00007805 }
7806
7807 void setN32ABITypes() {
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007808 setN32N64ABITypes();
Daniel Sanders4672af62016-05-27 11:51:02 +00007809 Int64Type = SignedLongLong;
7810 IntMaxType = Int64Type;
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007811 LongWidth = LongAlign = 32;
7812 PointerWidth = PointerAlign = 32;
7813 PtrDiffType = SignedInt;
7814 SizeType = UnsignedInt;
Daniel Sanders4672af62016-05-27 11:51:02 +00007815 }
7816
Craig Topper3164f332014-03-11 03:39:26 +00007817 bool setCPU(const std::string &Name) override {
Eric Christopher0b26a612010-03-02 02:41:08 +00007818 CPU = Name;
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00007819 return llvm::StringSwitch<bool>(Name)
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007820 .Case("mips1", true)
7821 .Case("mips2", true)
Simon Atanasyan26610c52014-07-04 12:36:56 +00007822 .Case("mips3", true)
7823 .Case("mips4", true)
7824 .Case("mips5", true)
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007825 .Case("mips32", true)
7826 .Case("mips32r2", true)
7827 .Case("mips32r3", true)
7828 .Case("mips32r5", true)
7829 .Case("mips32r6", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00007830 .Case("mips64", true)
7831 .Case("mips64r2", true)
Simon Atanasyan162feb52015-02-20 23:37:40 +00007832 .Case("mips64r3", true)
7833 .Case("mips64r5", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00007834 .Case("mips64r6", true)
Simon Atanasyan4e16a422014-07-04 12:37:04 +00007835 .Case("octeon", true)
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00007836 .Case("p5600", true)
Simon Atanasyan6b3544e2014-07-03 08:31:23 +00007837 .Default(false);
Eric Christopher0b26a612010-03-02 02:41:08 +00007838 }
Matheus Almeidab84b37d2014-06-05 14:59:18 +00007839 const std::string& getCPU() const { return CPU; }
Eric Christopher8c47b422015-10-09 18:39:55 +00007840 bool
7841 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
7842 StringRef CPU,
7843 const std::vector<std::string> &FeaturesVec) const override {
Bhushan D. Attardebacb988732016-03-04 06:56:29 +00007844 if (CPU.empty())
7845 CPU = getCPU();
Simon Atanasyan4e16a422014-07-04 12:37:04 +00007846 if (CPU == "octeon")
7847 Features["mips64r2"] = Features["cnmips"] = true;
7848 else
7849 Features[CPU] = true;
Eric Christopher007b0a02015-08-28 22:32:01 +00007850 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
Eric Christopher0b26a612010-03-02 02:41:08 +00007851 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00007852
Craig Topper3164f332014-03-11 03:39:26 +00007853 void getTargetDefines(const LangOptions &Opts,
7854 MacroBuilder &Builder) const override {
Daniel Sanders4672af62016-05-27 11:51:02 +00007855 if (BigEndian) {
7856 DefineStd(Builder, "MIPSEB", Opts);
7857 Builder.defineMacro("_MIPSEB");
7858 } else {
7859 DefineStd(Builder, "MIPSEL", Opts);
7860 Builder.defineMacro("_MIPSEL");
7861 }
7862
Simon Atanasyan26292cc2014-01-27 13:59:11 +00007863 Builder.defineMacro("__mips__");
Simon Atanasyan683535b2012-08-29 19:14:58 +00007864 Builder.defineMacro("_mips");
Simon Atanasyan26292cc2014-01-27 13:59:11 +00007865 if (Opts.GNUMode)
7866 Builder.defineMacro("mips");
7867
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007868 if (ABI == "o32") {
Daniel Sanders4672af62016-05-27 11:51:02 +00007869 Builder.defineMacro("__mips", "32");
7870 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS32");
7871 } else {
7872 Builder.defineMacro("__mips", "64");
7873 Builder.defineMacro("__mips64");
7874 Builder.defineMacro("__mips64__");
7875 Builder.defineMacro("_MIPS_ISA", "_MIPS_ISA_MIPS64");
7876 }
7877
7878 const std::string ISARev = llvm::StringSwitch<std::string>(getCPU())
7879 .Cases("mips32", "mips64", "1")
7880 .Cases("mips32r2", "mips64r2", "2")
7881 .Cases("mips32r3", "mips64r3", "3")
7882 .Cases("mips32r5", "mips64r5", "5")
7883 .Cases("mips32r6", "mips64r6", "6")
7884 .Default("");
7885 if (!ISARev.empty())
7886 Builder.defineMacro("__mips_isa_rev", ISARev);
7887
7888 if (ABI == "o32") {
7889 Builder.defineMacro("__mips_o32");
7890 Builder.defineMacro("_ABIO32", "1");
7891 Builder.defineMacro("_MIPS_SIM", "_ABIO32");
Daniel Sanders07c86542016-05-27 14:30:23 +00007892 } else if (ABI == "n32") {
Daniel Sanders4672af62016-05-27 11:51:02 +00007893 Builder.defineMacro("__mips_n32");
7894 Builder.defineMacro("_ABIN32", "2");
7895 Builder.defineMacro("_MIPS_SIM", "_ABIN32");
7896 } else if (ABI == "n64") {
7897 Builder.defineMacro("__mips_n64");
7898 Builder.defineMacro("_ABI64", "3");
7899 Builder.defineMacro("_MIPS_SIM", "_ABI64");
7900 } else
7901 llvm_unreachable("Invalid ABI.");
7902
Simon Dardisdf827a72017-02-21 16:01:00 +00007903 if (!IsNoABICalls) {
7904 Builder.defineMacro("__mips_abicalls");
7905 if (CanUseBSDABICalls)
7906 Builder.defineMacro("__ABICALLS__");
7907 }
7908
Simon Atanasyan683535b2012-08-29 19:14:58 +00007909 Builder.defineMacro("__REGISTER_PREFIX__", "");
7910
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007911 switch (FloatABI) {
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007912 case HardFloat:
Simon Atanasyand3d173d2012-06-05 13:06:56 +00007913 Builder.defineMacro("__mips_hard_float", Twine(1));
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007914 break;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00007915 case SoftFloat:
7916 Builder.defineMacro("__mips_soft_float", Twine(1));
7917 break;
Simon Atanasyand3d173d2012-06-05 13:06:56 +00007918 }
Simon Atanasyan26f19672012-04-05 19:28:31 +00007919
Simon Atanasyan16071912013-04-14 14:07:30 +00007920 if (IsSingleFloat)
7921 Builder.defineMacro("__mips_single_float", Twine(1));
7922
Simon Atanasyan2c97a812013-10-18 13:13:53 +00007923 Builder.defineMacro("__mips_fpr", HasFP64 ? Twine(64) : Twine(32));
7924 Builder.defineMacro("_MIPS_FPSET",
7925 Twine(32 / (HasFP64 || IsSingleFloat ? 1 : 2)));
7926
Simon Atanasyan72244b62012-07-05 16:06:06 +00007927 if (IsMips16)
7928 Builder.defineMacro("__mips16", Twine(1));
7929
Simon Atanasyan60777612013-04-14 14:07:51 +00007930 if (IsMicromips)
7931 Builder.defineMacro("__mips_micromips", Twine(1));
7932
Simon Atanasyan22127ce2013-09-24 09:09:16 +00007933 if (IsNan2008)
7934 Builder.defineMacro("__mips_nan2008", Twine(1));
7935
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00007936 switch (DspRev) {
7937 default:
7938 break;
7939 case DSP1:
7940 Builder.defineMacro("__mips_dsp_rev", Twine(1));
7941 Builder.defineMacro("__mips_dsp", Twine(1));
7942 break;
7943 case DSP2:
7944 Builder.defineMacro("__mips_dsp_rev", Twine(2));
7945 Builder.defineMacro("__mips_dspr2", Twine(1));
7946 Builder.defineMacro("__mips_dsp", Twine(1));
7947 break;
7948 }
7949
Jack Carter44ff1e52013-08-12 17:20:29 +00007950 if (HasMSA)
7951 Builder.defineMacro("__mips_msa", Twine(1));
7952
Simon Atanasyan26f19672012-04-05 19:28:31 +00007953 Builder.defineMacro("_MIPS_SZPTR", Twine(getPointerWidth(0)));
7954 Builder.defineMacro("_MIPS_SZINT", Twine(getIntWidth()));
7955 Builder.defineMacro("_MIPS_SZLONG", Twine(getLongWidth()));
Simon Atanasyan5a0642f2012-08-29 15:17:29 +00007956
7957 Builder.defineMacro("_MIPS_ARCH", "\"" + CPU + "\"");
7958 Builder.defineMacro("_MIPS_ARCH_" + StringRef(CPU).upper());
Daniel Sanders5176f7e2015-12-22 12:59:30 +00007959
7960 // These shouldn't be defined for MIPS-I but there's no need to check
7961 // for that since MIPS-I isn't supported.
7962 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
7963 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
7964 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
Daniel Sanders26a56ad2016-06-06 09:07:08 +00007965
7966 // 32-bit MIPS processors don't have the necessary lld/scd instructions
7967 // found in 64-bit processors. In the case of O32 on a 64-bit processor,
7968 // the instructions exist but using them violates the ABI since they
7969 // require 64-bit GPRs and O32 only supports 32-bit GPRs.
7970 if (ABI == "n32" || ABI == "n64")
Daniel Sanders4672af62016-05-27 11:51:02 +00007971 Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
Akira Hatanaka6976ec82012-03-23 23:07:09 +00007972 }
7973
Craig Topper6c03a542015-10-19 04:51:35 +00007974 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
7975 return llvm::makeArrayRef(BuiltinInfo,
7976 clang::Mips::LastTSBuiltin - Builtin::FirstTSBuiltin);
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007977 }
Craig Topper3164f332014-03-11 03:39:26 +00007978 bool hasFeature(StringRef Feature) const override {
Akira Hatanaka618b2982013-10-29 19:00:35 +00007979 return llvm::StringSwitch<bool>(Feature)
7980 .Case("mips", true)
7981 .Case("fp64", HasFP64)
7982 .Default(false);
Douglas Gregor0070c0b2012-01-30 06:38:25 +00007983 }
Craig Topper3164f332014-03-11 03:39:26 +00007984 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00007985 return TargetInfo::VoidPtrBuiltinVaList;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00007986 }
Craig Topperf054e3a2015-10-19 03:52:27 +00007987 ArrayRef<const char *> getGCCRegNames() const override {
Daniel Sanders8b59af12013-11-12 12:56:01 +00007988 static const char *const GCCRegNames[] = {
Eric Christopher8b6d0512012-03-27 19:56:11 +00007989 // CPU register names
7990 // Must match second column of GCCRegAliases
Akira Hatanakaf6da3312011-09-20 19:00:23 +00007991 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
7992 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
7993 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
Eric Christopher8b6d0512012-03-27 19:56:11 +00007994 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31",
7995 // Floating point register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00007996 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
7997 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
7998 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
7999 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31",
Eric Christopher8b6d0512012-03-27 19:56:11 +00008000 // Hi/lo and condition register names
Akira Hatanakaf6da3312011-09-20 19:00:23 +00008001 "hi", "lo", "", "$fcc0","$fcc1","$fcc2","$fcc3","$fcc4",
Hrvoje Varga14c42ee2016-03-29 12:46:16 +00008002 "$fcc5","$fcc6","$fcc7","$ac1hi","$ac1lo","$ac2hi","$ac2lo",
8003 "$ac3hi","$ac3lo",
Daniel Sanders8b59af12013-11-12 12:56:01 +00008004 // MSA register names
8005 "$w0", "$w1", "$w2", "$w3", "$w4", "$w5", "$w6", "$w7",
8006 "$w8", "$w9", "$w10", "$w11", "$w12", "$w13", "$w14", "$w15",
8007 "$w16", "$w17", "$w18", "$w19", "$w20", "$w21", "$w22", "$w23",
8008 "$w24", "$w25", "$w26", "$w27", "$w28", "$w29", "$w30", "$w31",
8009 // MSA control register names
8010 "$msair", "$msacsr", "$msaaccess", "$msasave", "$msamodify",
8011 "$msarequest", "$msamap", "$msaunmap"
Akira Hatanakaf6da3312011-09-20 19:00:23 +00008012 };
Craig Topperf054e3a2015-10-19 03:52:27 +00008013 return llvm::makeArrayRef(GCCRegNames);
Akira Hatanakaf6da3312011-09-20 19:00:23 +00008014 }
Craig Topper3164f332014-03-11 03:39:26 +00008015 bool validateAsmConstraint(const char *&Name,
8016 TargetInfo::ConstraintInfo &Info) const override {
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008017 switch (*Name) {
8018 default:
Douglas Gregor07216d12011-11-02 20:52:01 +00008019 return false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008020 case 'r': // CPU registers.
8021 case 'd': // Equivalent to "r" unless generating MIPS16 code.
Alp Toker958027b2014-07-14 19:42:55 +00008022 case 'y': // Equivalent to "r", backward compatibility only.
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008023 case 'f': // floating-point registers.
Eric Christopherb7e28cc2012-04-03 01:16:32 +00008024 case 'c': // $25 for indirect jumps
8025 case 'l': // lo register
8026 case 'x': // hilo register pair
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008027 Info.setAllowsRegister();
8028 return true;
Saleem Abdulrasoola2823572015-01-06 04:26:34 +00008029 case 'I': // Signed 16-bit constant
8030 case 'J': // Integer 0
8031 case 'K': // Unsigned 16-bit constant
8032 case 'L': // Signed 32-bit constant, lower 16-bit zeros (for lui)
8033 case 'M': // Constants not loadable via lui, addiu, or ori
8034 case 'N': // Constant -1 to -65535
8035 case 'O': // A signed 15-bit constant
8036 case 'P': // A constant between 1 go 65535
8037 return true;
Jack Carterbeaccdd2013-03-05 19:10:54 +00008038 case 'R': // An address that can be used in a non-macro load or store
Jack Carter427b4042013-03-04 21:36:11 +00008039 Info.setAllowsMemory();
8040 return true;
Daniel Sanders48fa39e2015-03-30 13:47:23 +00008041 case 'Z':
8042 if (Name[1] == 'C') { // An address usable by ll, and sc.
8043 Info.setAllowsMemory();
8044 Name++; // Skip over 'Z'.
8045 return true;
8046 }
8047 return false;
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008048 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008049 }
8050
Daniel Sanders48fa39e2015-03-30 13:47:23 +00008051 std::string convertConstraint(const char *&Constraint) const override {
8052 std::string R;
8053 switch (*Constraint) {
8054 case 'Z': // Two-character constraint; add "^" hint for later parsing.
8055 if (Constraint[1] == 'C') {
8056 R = std::string("^") + std::string(Constraint, 2);
8057 Constraint++;
8058 return R;
8059 }
8060 break;
8061 }
8062 return TargetInfo::convertConstraint(Constraint);
8063 }
8064
Craig Topper3164f332014-03-11 03:39:26 +00008065 const char *getClobbers() const override {
Toma Tabacucfab40f2015-01-12 14:41:30 +00008066 // In GCC, $1 is not widely used in generated code (it's used only in a few
8067 // specific situations), so there is no real need for users to add it to
8068 // the clobbers list if they want to use it in their inline assembly code.
8069 //
8070 // In LLVM, $1 is treated as a normal GPR and is always allocatable during
8071 // code generation, so using it in inline assembly without adding it to the
8072 // clobbers list can cause conflicts between the inline assembly code and
8073 // the surrounding generated code.
8074 //
8075 // Another problem is that LLVM is allowed to choose $1 for inline assembly
8076 // operands, which will conflict with the ".set at" assembler option (which
8077 // we use only for inline assembly, in order to maintain compatibility with
8078 // GCC) and will also conflict with the user's usage of $1.
8079 //
8080 // The easiest way to avoid these conflicts and keep $1 as an allocatable
8081 // register for generated code is to automatically clobber $1 for all inline
8082 // assembly code.
8083 //
8084 // FIXME: We should automatically clobber $1 only for inline assembly code
8085 // which actually uses it. This would allow LLVM to use $1 for inline
8086 // assembly operands if the user's assembly code doesn't use it.
Toma Tabacu99411952014-12-17 12:02:58 +00008087 return "~{$1}";
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008088 }
Akira Hatanaka6976ec82012-03-23 23:07:09 +00008089
Craig Topper3164f332014-03-11 03:39:26 +00008090 bool handleTargetFeatures(std::vector<std::string> &Features,
8091 DiagnosticsEngine &Diags) override {
Simon Atanasyan72244b62012-07-05 16:06:06 +00008092 IsMips16 = false;
Simon Atanasyan60777612013-04-14 14:07:51 +00008093 IsMicromips = false;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00008094 IsNan2008 = isNaN2008Default();
Simon Atanasyan16071912013-04-14 14:07:30 +00008095 IsSingleFloat = false;
Simon Atanasyan9f444d52012-07-05 15:32:46 +00008096 FloatABI = HardFloat;
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00008097 DspRev = NoDSP;
Daniel Sanders9500d2d2014-07-09 13:56:23 +00008098 HasFP64 = isFP64Default();
Akira Hatanaka6976ec82012-03-23 23:07:09 +00008099
Eric Christopher610fe112015-08-26 08:21:55 +00008100 for (const auto &Feature : Features) {
8101 if (Feature == "+single-float")
Simon Atanasyan16071912013-04-14 14:07:30 +00008102 IsSingleFloat = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008103 else if (Feature == "+soft-float")
Simon Atanasyan9f444d52012-07-05 15:32:46 +00008104 FloatABI = SoftFloat;
Eric Christopher610fe112015-08-26 08:21:55 +00008105 else if (Feature == "+mips16")
Simon Atanasyan72244b62012-07-05 16:06:06 +00008106 IsMips16 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008107 else if (Feature == "+micromips")
Simon Atanasyan60777612013-04-14 14:07:51 +00008108 IsMicromips = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008109 else if (Feature == "+dsp")
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00008110 DspRev = std::max(DspRev, DSP1);
Eric Christopher610fe112015-08-26 08:21:55 +00008111 else if (Feature == "+dspr2")
Simon Atanasyan9780e4a2012-07-05 20:16:22 +00008112 DspRev = std::max(DspRev, DSP2);
Eric Christopher610fe112015-08-26 08:21:55 +00008113 else if (Feature == "+msa")
Jack Carter44ff1e52013-08-12 17:20:29 +00008114 HasMSA = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008115 else if (Feature == "+fp64")
Simon Atanasyan2c97a812013-10-18 13:13:53 +00008116 HasFP64 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008117 else if (Feature == "-fp64")
Simon Atanasyan2c97a812013-10-18 13:13:53 +00008118 HasFP64 = false;
Eric Christopher610fe112015-08-26 08:21:55 +00008119 else if (Feature == "+nan2008")
Simon Atanasyan22127ce2013-09-24 09:09:16 +00008120 IsNan2008 = true;
Eric Christopher610fe112015-08-26 08:21:55 +00008121 else if (Feature == "-nan2008")
Daniel Sanders9500d2d2014-07-09 13:56:23 +00008122 IsNan2008 = false;
Simon Dardisdf827a72017-02-21 16:01:00 +00008123 else if (Feature == "+noabicalls")
8124 IsNoABICalls = true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00008125 }
Simon Atanasyan9f444d52012-07-05 15:32:46 +00008126
James Y Knightb214cbc2016-03-04 19:00:41 +00008127 setDataLayout();
Akira Hatanaka9064e362013-10-29 18:30:33 +00008128
Rafael Espindolaeb265472013-08-21 21:59:03 +00008129 return true;
Akira Hatanaka6976ec82012-03-23 23:07:09 +00008130 }
Logan Chien5a5a96b2013-02-23 04:24:36 +00008131
Craig Topper3164f332014-03-11 03:39:26 +00008132 int getEHDataRegisterNumber(unsigned RegNo) const override {
Logan Chien5a5a96b2013-02-23 04:24:36 +00008133 if (RegNo == 0) return 4;
8134 if (RegNo == 1) return 5;
8135 return -1;
8136 }
Daniel Sanderscfbb71d2014-07-09 13:43:19 +00008137
8138 bool isCLZForZeroUndef() const override { return false; }
Daniel Sanders4672af62016-05-27 11:51:02 +00008139
8140 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8141 static const TargetInfo::GCCRegAlias O32RegAliases[] = {
8142 {{"at"}, "$1"}, {{"v0"}, "$2"}, {{"v1"}, "$3"},
8143 {{"a0"}, "$4"}, {{"a1"}, "$5"}, {{"a2"}, "$6"},
8144 {{"a3"}, "$7"}, {{"t0"}, "$8"}, {{"t1"}, "$9"},
8145 {{"t2"}, "$10"}, {{"t3"}, "$11"}, {{"t4"}, "$12"},
8146 {{"t5"}, "$13"}, {{"t6"}, "$14"}, {{"t7"}, "$15"},
8147 {{"s0"}, "$16"}, {{"s1"}, "$17"}, {{"s2"}, "$18"},
8148 {{"s3"}, "$19"}, {{"s4"}, "$20"}, {{"s5"}, "$21"},
8149 {{"s6"}, "$22"}, {{"s7"}, "$23"}, {{"t8"}, "$24"},
8150 {{"t9"}, "$25"}, {{"k0"}, "$26"}, {{"k1"}, "$27"},
8151 {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
8152 {{"ra"}, "$31"}};
8153 static const TargetInfo::GCCRegAlias NewABIRegAliases[] = {
8154 {{"at"}, "$1"}, {{"v0"}, "$2"}, {{"v1"}, "$3"},
8155 {{"a0"}, "$4"}, {{"a1"}, "$5"}, {{"a2"}, "$6"},
8156 {{"a3"}, "$7"}, {{"a4"}, "$8"}, {{"a5"}, "$9"},
8157 {{"a6"}, "$10"}, {{"a7"}, "$11"}, {{"t0"}, "$12"},
8158 {{"t1"}, "$13"}, {{"t2"}, "$14"}, {{"t3"}, "$15"},
8159 {{"s0"}, "$16"}, {{"s1"}, "$17"}, {{"s2"}, "$18"},
8160 {{"s3"}, "$19"}, {{"s4"}, "$20"}, {{"s5"}, "$21"},
8161 {{"s6"}, "$22"}, {{"s7"}, "$23"}, {{"t8"}, "$24"},
8162 {{"t9"}, "$25"}, {{"k0"}, "$26"}, {{"k1"}, "$27"},
8163 {{"gp"}, "$28"}, {{"sp", "$sp"}, "$29"}, {{"fp", "$fp"}, "$30"},
8164 {{"ra"}, "$31"}};
Daniel Sanders26a56ad2016-06-06 09:07:08 +00008165 if (ABI == "o32")
Daniel Sanders4672af62016-05-27 11:51:02 +00008166 return llvm::makeArrayRef(O32RegAliases);
8167 return llvm::makeArrayRef(NewABIRegAliases);
8168 }
8169
8170 bool hasInt128Type() const override {
Daniel Sanders26a56ad2016-06-06 09:07:08 +00008171 return ABI == "n32" || ABI == "n64";
Daniel Sanders4672af62016-05-27 11:51:02 +00008172 }
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00008173
8174 bool validateTarget(DiagnosticsEngine &Diags) const override {
8175 // FIXME: It's valid to use O32 on a 64-bit CPU but the backend can't handle
8176 // this yet. It's better to fail here than on the backend assertion.
8177 if (processorSupportsGPR64() && ABI == "o32") {
8178 Diags.Report(diag::err_target_unsupported_abi) << ABI << CPU;
8179 return false;
8180 }
8181
8182 // 64-bit ABI's require 64-bit CPU's.
8183 if (!processorSupportsGPR64() && (ABI == "n32" || ABI == "n64")) {
8184 Diags.Report(diag::err_target_unsupported_abi) << ABI << CPU;
8185 return false;
8186 }
8187
8188 // FIXME: It's valid to use O32 on a mips64/mips64el triple but the backend
8189 // can't handle this yet. It's better to fail here than on the
8190 // backend assertion.
8191 if ((getTriple().getArch() == llvm::Triple::mips64 ||
8192 getTriple().getArch() == llvm::Triple::mips64el) &&
8193 ABI == "o32") {
8194 Diags.Report(diag::err_target_unsupported_abi_for_triple)
8195 << ABI << getTriple().str();
8196 return false;
8197 }
8198
8199 // FIXME: It's valid to use N32/N64 on a mips/mipsel triple but the backend
8200 // can't handle this yet. It's better to fail here than on the
8201 // backend assertion.
8202 if ((getTriple().getArch() == llvm::Triple::mips ||
8203 getTriple().getArch() == llvm::Triple::mipsel) &&
8204 (ABI == "n32" || ABI == "n64")) {
8205 Diags.Report(diag::err_target_unsupported_abi_for_triple)
8206 << ABI << getTriple().str();
8207 return false;
8208 }
8209
8210 return true;
8211 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00008212};
8213
Daniel Sanders4672af62016-05-27 11:51:02 +00008214const Builtin::Info MipsTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00008215#define BUILTIN(ID, TYPE, ATTRS) \
8216 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8217#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
8218 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Simon Atanasyan07ce7d8f2012-06-28 18:23:16 +00008219#include "clang/Basic/BuiltinsMips.def"
8220};
8221
Ivan Krasindd7403e2011-08-24 20:22:22 +00008222class PNaClTargetInfo : public TargetInfo {
8223public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008224 PNaClTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8225 : TargetInfo(Triple) {
Ivan Krasindd7403e2011-08-24 20:22:22 +00008226 this->LongAlign = 32;
8227 this->LongWidth = 32;
8228 this->PointerAlign = 32;
8229 this->PointerWidth = 32;
8230 this->IntMaxType = TargetInfo::SignedLongLong;
Ivan Krasindd7403e2011-08-24 20:22:22 +00008231 this->Int64Type = TargetInfo::SignedLongLong;
Ivan Krasin69a990b2011-08-29 22:39:12 +00008232 this->DoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00008233 this->LongDoubleWidth = 64;
Ivan Krasin69a990b2011-08-29 22:39:12 +00008234 this->LongDoubleAlign = 64;
Ivan Krasin96a80612011-09-20 14:56:54 +00008235 this->SizeType = TargetInfo::UnsignedInt;
8236 this->PtrDiffType = TargetInfo::SignedInt;
8237 this->IntPtrType = TargetInfo::SignedInt;
Eli Bendersky4f6791c2013-04-08 21:31:01 +00008238 this->RegParmMax = 0; // Disallow regparm
Ivan Krasindd7403e2011-08-24 20:22:22 +00008239 }
8240
Craig Toppere6f17d02014-03-11 04:07:52 +00008241 void getArchDefines(const LangOptions &Opts, MacroBuilder &Builder) const {
Ivan Krasindd7403e2011-08-24 20:22:22 +00008242 Builder.defineMacro("__le32__");
8243 Builder.defineMacro("__pnacl__");
8244 }
Craig Topper3164f332014-03-11 03:39:26 +00008245 void getTargetDefines(const LangOptions &Opts,
8246 MacroBuilder &Builder) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00008247 getArchDefines(Opts, Builder);
8248 }
Craig Topper3164f332014-03-11 03:39:26 +00008249 bool hasFeature(StringRef Feature) const override {
Douglas Gregor0070c0b2012-01-30 06:38:25 +00008250 return Feature == "pnacl";
8251 }
Craig Topper6c03a542015-10-19 04:51:35 +00008252 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Craig Topper3164f332014-03-11 03:39:26 +00008253 BuiltinVaListKind getBuiltinVaListKind() const override {
Meador Inge5d3fb222012-06-16 03:34:49 +00008254 return TargetInfo::PNaClABIBuiltinVaList;
Ivan Krasindd7403e2011-08-24 20:22:22 +00008255 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008256 ArrayRef<const char *> getGCCRegNames() const override;
8257 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override;
Craig Topper3164f332014-03-11 03:39:26 +00008258 bool validateAsmConstraint(const char *&Name,
8259 TargetInfo::ConstraintInfo &Info) const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00008260 return false;
8261 }
8262
Craig Topper3164f332014-03-11 03:39:26 +00008263 const char *getClobbers() const override {
Ivan Krasindd7403e2011-08-24 20:22:22 +00008264 return "";
8265 }
8266};
8267
Craig Topperf054e3a2015-10-19 03:52:27 +00008268ArrayRef<const char *> PNaClTargetInfo::getGCCRegNames() const {
8269 return None;
Ivan Krasindd7403e2011-08-24 20:22:22 +00008270}
8271
Craig Topperf054e3a2015-10-19 03:52:27 +00008272ArrayRef<TargetInfo::GCCRegAlias> PNaClTargetInfo::getGCCRegAliases() const {
8273 return None;
Ivan Krasindd7403e2011-08-24 20:22:22 +00008274}
Ivan Krasindd7403e2011-08-24 20:22:22 +00008275
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008276// We attempt to use PNaCl (le32) frontend and Mips32EL backend.
Daniel Sanders4672af62016-05-27 11:51:02 +00008277class NaClMips32TargetInfo : public MipsTargetInfo {
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008278public:
Daniel Sanders4672af62016-05-27 11:51:02 +00008279 NaClMips32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8280 : MipsTargetInfo(Triple, Opts) {}
Petar Jovanovic26a4a402015-07-08 13:07:31 +00008281
8282 BuiltinVaListKind getBuiltinVaListKind() const override {
8283 return TargetInfo::PNaClABIBuiltinVaList;
8284 }
8285};
8286
JF Bastien643817d2014-09-12 17:52:47 +00008287class Le64TargetInfo : public TargetInfo {
8288 static const Builtin::Info BuiltinInfo[];
8289
8290public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008291 Le64TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8292 : TargetInfo(Triple) {
JF Bastien643817d2014-09-12 17:52:47 +00008293 NoAsmVariants = true;
8294 LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
8295 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
James Y Knightb214cbc2016-03-04 19:00:41 +00008296 resetDataLayout("e-m:e-v128:32-v16:16-v32:32-v96:32-n8:16:32:64-S128");
JF Bastien643817d2014-09-12 17:52:47 +00008297 }
8298
8299 void getTargetDefines(const LangOptions &Opts,
8300 MacroBuilder &Builder) const override {
Saleem Abdulrasool56027092017-02-07 19:00:06 +00008301 DefineStd(Builder, "unix", Opts);
JF Bastien643817d2014-09-12 17:52:47 +00008302 defineCPUMacros(Builder, "le64", /*Tuning=*/false);
8303 Builder.defineMacro("__ELF__");
8304 }
Craig Topper6c03a542015-10-19 04:51:35 +00008305 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
8306 return llvm::makeArrayRef(BuiltinInfo,
8307 clang::Le64::LastTSBuiltin - Builtin::FirstTSBuiltin);
JF Bastien643817d2014-09-12 17:52:47 +00008308 }
8309 BuiltinVaListKind getBuiltinVaListKind() const override {
8310 return TargetInfo::PNaClABIBuiltinVaList;
8311 }
8312 const char *getClobbers() const override { return ""; }
Craig Topperf054e3a2015-10-19 03:52:27 +00008313 ArrayRef<const char *> getGCCRegNames() const override {
8314 return None;
JF Bastien643817d2014-09-12 17:52:47 +00008315 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008316 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8317 return None;
JF Bastien643817d2014-09-12 17:52:47 +00008318 }
8319 bool validateAsmConstraint(const char *&Name,
8320 TargetInfo::ConstraintInfo &Info) const override {
8321 return false;
8322 }
8323
8324 bool hasProtectedVisibility() const override { return false; }
JF Bastien643817d2014-09-12 17:52:47 +00008325};
Dan Gohmanc2853072015-09-03 22:51:53 +00008326
8327class WebAssemblyTargetInfo : public TargetInfo {
8328 static const Builtin::Info BuiltinInfo[];
8329
8330 enum SIMDEnum {
8331 NoSIMD,
8332 SIMD128,
8333 } SIMDLevel;
8334
8335public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008336 explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &)
Dan Gohmanc2853072015-09-03 22:51:53 +00008337 : TargetInfo(T), SIMDLevel(NoSIMD) {
Dan Gohmanc2853072015-09-03 22:51:53 +00008338 NoAsmVariants = true;
8339 SuitableAlign = 128;
8340 LargeArrayMinWidth = 128;
8341 LargeArrayAlign = 128;
8342 SimdDefaultAlign = 128;
Dan Gohmanf1c34e62015-09-14 21:56:37 +00008343 SigAtomicType = SignedLong;
Dan Gohman6db46402015-11-10 21:01:46 +00008344 LongDoubleWidth = LongDoubleAlign = 128;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00008345 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Derek Schuffacdc8e62016-09-01 22:38:37 +00008346 SizeType = UnsignedInt;
8347 PtrDiffType = SignedInt;
8348 IntPtrType = SignedInt;
Dan Gohmanc2853072015-09-03 22:51:53 +00008349 }
8350
8351protected:
8352 void getTargetDefines(const LangOptions &Opts,
8353 MacroBuilder &Builder) const override {
8354 defineCPUMacros(Builder, "wasm", /*Tuning=*/false);
8355 if (SIMDLevel >= SIMD128)
8356 Builder.defineMacro("__wasm_simd128__");
8357 }
8358
8359private:
Eric Christopher8c47b422015-10-09 18:39:55 +00008360 bool
8361 initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags,
8362 StringRef CPU,
8363 const std::vector<std::string> &FeaturesVec) const override {
Dan Gohmanc2853072015-09-03 22:51:53 +00008364 if (CPU == "bleeding-edge")
8365 Features["simd128"] = true;
8366 return TargetInfo::initFeatureMap(Features, Diags, CPU, FeaturesVec);
8367 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00008368 bool hasFeature(StringRef Feature) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00008369 return llvm::StringSwitch<bool>(Feature)
8370 .Case("simd128", SIMDLevel >= SIMD128)
8371 .Default(false);
8372 }
8373 bool handleTargetFeatures(std::vector<std::string> &Features,
Hans Wennborg7eb54642015-09-10 17:07:54 +00008374 DiagnosticsEngine &Diags) final {
Dan Gohmanc2853072015-09-03 22:51:53 +00008375 for (const auto &Feature : Features) {
8376 if (Feature == "+simd128") {
8377 SIMDLevel = std::max(SIMDLevel, SIMD128);
8378 continue;
8379 }
8380 if (Feature == "-simd128") {
8381 SIMDLevel = std::min(SIMDLevel, SIMDEnum(SIMD128 - 1));
8382 continue;
8383 }
8384
8385 Diags.Report(diag::err_opt_not_valid_with_opt) << Feature
8386 << "-target-feature";
8387 return false;
8388 }
8389 return true;
8390 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00008391 bool setCPU(const std::string &Name) final {
Dan Gohmanc2853072015-09-03 22:51:53 +00008392 return llvm::StringSwitch<bool>(Name)
8393 .Case("mvp", true)
8394 .Case("bleeding-edge", true)
8395 .Case("generic", true)
8396 .Default(false);
8397 }
Craig Topper6c03a542015-10-19 04:51:35 +00008398 ArrayRef<Builtin::Info> getTargetBuiltins() const final {
8399 return llvm::makeArrayRef(BuiltinInfo,
8400 clang::WebAssembly::LastTSBuiltin - Builtin::FirstTSBuiltin);
Dan Gohmanc2853072015-09-03 22:51:53 +00008401 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00008402 BuiltinVaListKind getBuiltinVaListKind() const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00008403 return VoidPtrBuiltinVaList;
8404 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008405 ArrayRef<const char *> getGCCRegNames() const final {
8406 return None;
Dan Gohmanc2853072015-09-03 22:51:53 +00008407 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008408 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const final {
8409 return None;
Dan Gohmanc2853072015-09-03 22:51:53 +00008410 }
8411 bool
8412 validateAsmConstraint(const char *&Name,
Hans Wennborg7eb54642015-09-10 17:07:54 +00008413 TargetInfo::ConstraintInfo &Info) const final {
Dan Gohmanc2853072015-09-03 22:51:53 +00008414 return false;
8415 }
Hans Wennborg7eb54642015-09-10 17:07:54 +00008416 const char *getClobbers() const final { return ""; }
8417 bool isCLZForZeroUndef() const final { return false; }
8418 bool hasInt128Type() const final { return true; }
Dan Gohmanab0e31f2015-09-14 21:49:41 +00008419 IntType getIntTypeByWidth(unsigned BitWidth,
8420 bool IsSigned) const final {
8421 // WebAssembly prefers long long for explicitly 64-bit integers.
8422 return BitWidth == 64 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
8423 : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
8424 }
8425 IntType getLeastIntTypeByWidth(unsigned BitWidth,
8426 bool IsSigned) const final {
8427 // WebAssembly uses long long for int_least64_t and int_fast64_t.
8428 return BitWidth == 64
8429 ? (IsSigned ? SignedLongLong : UnsignedLongLong)
8430 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
8431 }
Dan Gohmanc2853072015-09-03 22:51:53 +00008432};
8433
8434const Builtin::Info WebAssemblyTargetInfo::BuiltinInfo[] = {
8435#define BUILTIN(ID, TYPE, ATTRS) \
8436 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8437#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
8438 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
8439#include "clang/Basic/BuiltinsWebAssembly.def"
8440};
8441
8442class WebAssembly32TargetInfo : public WebAssemblyTargetInfo {
8443public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008444 explicit WebAssembly32TargetInfo(const llvm::Triple &T,
8445 const TargetOptions &Opts)
8446 : WebAssemblyTargetInfo(T, Opts) {
Dan Gohmanf1c34e62015-09-14 21:56:37 +00008447 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
James Y Knightb214cbc2016-03-04 19:00:41 +00008448 resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128");
Dan Gohmanc2853072015-09-03 22:51:53 +00008449 }
8450
8451protected:
8452 void getTargetDefines(const LangOptions &Opts,
8453 MacroBuilder &Builder) const override {
8454 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
8455 defineCPUMacros(Builder, "wasm32", /*Tuning=*/false);
8456 }
8457};
8458
8459class WebAssembly64TargetInfo : public WebAssemblyTargetInfo {
8460public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008461 explicit WebAssembly64TargetInfo(const llvm::Triple &T,
8462 const TargetOptions &Opts)
8463 : WebAssemblyTargetInfo(T, Opts) {
Dan Gohmanc2853072015-09-03 22:51:53 +00008464 LongAlign = LongWidth = 64;
8465 PointerAlign = PointerWidth = 64;
Dan Gohmanf1c34e62015-09-14 21:56:37 +00008466 MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
Derek Schuffacdc8e62016-09-01 22:38:37 +00008467 SizeType = UnsignedLong;
8468 PtrDiffType = SignedLong;
8469 IntPtrType = SignedLong;
James Y Knightb214cbc2016-03-04 19:00:41 +00008470 resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128");
Dan Gohmanc2853072015-09-03 22:51:53 +00008471 }
8472
8473protected:
8474 void getTargetDefines(const LangOptions &Opts,
8475 MacroBuilder &Builder) const override {
8476 WebAssemblyTargetInfo::getTargetDefines(Opts, Builder);
8477 defineCPUMacros(Builder, "wasm64", /*Tuning=*/false);
8478 }
8479};
8480
JF Bastien643817d2014-09-12 17:52:47 +00008481const Builtin::Info Le64TargetInfo::BuiltinInfo[] = {
8482#define BUILTIN(ID, TYPE, ATTRS) \
Craig Topper07d3b622015-08-07 05:14:44 +00008483 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
JF Bastien643817d2014-09-12 17:52:47 +00008484#include "clang/Basic/BuiltinsLe64.def"
8485};
8486
Eric Christopherc48497a2015-09-18 21:26:24 +00008487static const unsigned SPIRAddrSpaceMap[] = {
Yaxun Liub34ec822017-04-11 17:24:23 +00008488 0, // Default
Eric Christopherc48497a2015-09-18 21:26:24 +00008489 1, // opencl_global
8490 3, // opencl_local
8491 2, // opencl_constant
8492 4, // opencl_generic
8493 0, // cuda_device
8494 0, // cuda_constant
8495 0 // cuda_shared
8496};
8497class SPIRTargetInfo : public TargetInfo {
8498public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008499 SPIRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8500 : TargetInfo(Triple) {
Eric Christopherc48497a2015-09-18 21:26:24 +00008501 assert(getTriple().getOS() == llvm::Triple::UnknownOS &&
8502 "SPIR target must use unknown OS");
8503 assert(getTriple().getEnvironment() == llvm::Triple::UnknownEnvironment &&
8504 "SPIR target must use unknown environment type");
Eric Christopherc48497a2015-09-18 21:26:24 +00008505 TLSSupported = false;
8506 LongWidth = LongAlign = 64;
8507 AddrSpaceMap = &SPIRAddrSpaceMap;
8508 UseAddrSpaceMapMangling = true;
8509 // Define available target features
8510 // These must be defined in sorted order!
8511 NoAsmVariants = true;
8512 }
8513 void getTargetDefines(const LangOptions &Opts,
8514 MacroBuilder &Builder) const override {
8515 DefineStd(Builder, "SPIR", Opts);
8516 }
8517 bool hasFeature(StringRef Feature) const override {
8518 return Feature == "spir";
8519 }
Craig Topper3164f332014-03-11 03:39:26 +00008520
Craig Topper6c03a542015-10-19 04:51:35 +00008521 ArrayRef<Builtin::Info> getTargetBuiltins() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00008522 const char *getClobbers() const override { return ""; }
Craig Topperf054e3a2015-10-19 03:52:27 +00008523 ArrayRef<const char *> getGCCRegNames() const override { return None; }
Eric Christopherc48497a2015-09-18 21:26:24 +00008524 bool validateAsmConstraint(const char *&Name,
8525 TargetInfo::ConstraintInfo &info) const override {
8526 return true;
8527 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008528 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8529 return None;
8530 }
Eric Christopherc48497a2015-09-18 21:26:24 +00008531 BuiltinVaListKind getBuiltinVaListKind() const override {
8532 return TargetInfo::VoidPtrBuiltinVaList;
8533 }
Alexander Kornienko21de0ae2015-01-20 11:20:41 +00008534
Eric Christopherc48497a2015-09-18 21:26:24 +00008535 CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
Nikolay Haustov8c6538b2016-06-30 09:06:33 +00008536 return (CC == CC_SpirFunction || CC == CC_OpenCLKernel) ? CCCR_OK
8537 : CCCR_Warning;
Eric Christopherc48497a2015-09-18 21:26:24 +00008538 }
Alexander Kornienko21de0ae2015-01-20 11:20:41 +00008539
Eric Christopherc48497a2015-09-18 21:26:24 +00008540 CallingConv getDefaultCallingConv(CallingConvMethodType MT) const override {
8541 return CC_SpirFunction;
8542 }
Yaxun Liu39cf40f2016-05-16 17:06:34 +00008543
8544 void setSupportedOpenCLOpts() override {
8545 // Assume all OpenCL extensions and optional core features are supported
8546 // for SPIR since it is a generic target.
Yaxun Liu5b746652016-12-18 05:18:55 +00008547 getSupportedOpenCLOpts().supportAll();
Yaxun Liu39cf40f2016-05-16 17:06:34 +00008548 }
Eric Christopherc48497a2015-09-18 21:26:24 +00008549};
Guy Benyeib798fc92012-12-11 21:38:14 +00008550
Eric Christopherc48497a2015-09-18 21:26:24 +00008551class SPIR32TargetInfo : public SPIRTargetInfo {
8552public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008553 SPIR32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8554 : SPIRTargetInfo(Triple, Opts) {
Eric Christopherc48497a2015-09-18 21:26:24 +00008555 PointerWidth = PointerAlign = 32;
8556 SizeType = TargetInfo::UnsignedInt;
8557 PtrDiffType = IntPtrType = TargetInfo::SignedInt;
James Y Knightb214cbc2016-03-04 19:00:41 +00008558 resetDataLayout("e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-"
8559 "v96:128-v192:256-v256:256-v512:512-v1024:1024");
Eric Christopherc48497a2015-09-18 21:26:24 +00008560 }
8561 void getTargetDefines(const LangOptions &Opts,
8562 MacroBuilder &Builder) const override {
8563 DefineStd(Builder, "SPIR32", Opts);
8564 }
8565};
Guy Benyeib798fc92012-12-11 21:38:14 +00008566
Eric Christopherc48497a2015-09-18 21:26:24 +00008567class SPIR64TargetInfo : public SPIRTargetInfo {
8568public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008569 SPIR64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8570 : SPIRTargetInfo(Triple, Opts) {
Eric Christopherc48497a2015-09-18 21:26:24 +00008571 PointerWidth = PointerAlign = 64;
8572 SizeType = TargetInfo::UnsignedLong;
8573 PtrDiffType = IntPtrType = TargetInfo::SignedLong;
James Y Knightb214cbc2016-03-04 19:00:41 +00008574 resetDataLayout("e-i64:64-v16:16-v24:32-v32:32-v48:64-"
8575 "v96:128-v192:256-v256:256-v512:512-v1024:1024");
Eric Christopherc48497a2015-09-18 21:26:24 +00008576 }
8577 void getTargetDefines(const LangOptions &Opts,
8578 MacroBuilder &Builder) const override {
8579 DefineStd(Builder, "SPIR64", Opts);
8580 }
8581};
Guy Benyeib798fc92012-12-11 21:38:14 +00008582
Robert Lytton0e076492013-08-13 09:43:10 +00008583class XCoreTargetInfo : public TargetInfo {
8584 static const Builtin::Info BuiltinInfo[];
8585public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008586 XCoreTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8587 : TargetInfo(Triple) {
Robert Lytton0e076492013-08-13 09:43:10 +00008588 NoAsmVariants = true;
8589 LongLongAlign = 32;
8590 SuitableAlign = 32;
8591 DoubleAlign = LongDoubleAlign = 32;
Robert Lyttoncc424662013-11-12 10:09:30 +00008592 SizeType = UnsignedInt;
8593 PtrDiffType = SignedInt;
8594 IntPtrType = SignedInt;
8595 WCharType = UnsignedChar;
8596 WIntType = UnsignedInt;
Robert Lytton0e076492013-08-13 09:43:10 +00008597 UseZeroLengthBitfieldAlignment = true;
James Y Knightb214cbc2016-03-04 19:00:41 +00008598 resetDataLayout("e-m:e-p:32:32-i1:8:32-i8:8:32-i16:16:32-i64:32"
8599 "-f64:32-a:0:32-n32");
Robert Lytton0e076492013-08-13 09:43:10 +00008600 }
Craig Topper3164f332014-03-11 03:39:26 +00008601 void getTargetDefines(const LangOptions &Opts,
8602 MacroBuilder &Builder) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00008603 Builder.defineMacro("__XS1B__");
8604 }
Craig Topper6c03a542015-10-19 04:51:35 +00008605 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
8606 return llvm::makeArrayRef(BuiltinInfo,
8607 clang::XCore::LastTSBuiltin-Builtin::FirstTSBuiltin);
Robert Lytton0e076492013-08-13 09:43:10 +00008608 }
Craig Topper3164f332014-03-11 03:39:26 +00008609 BuiltinVaListKind getBuiltinVaListKind() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00008610 return TargetInfo::VoidPtrBuiltinVaList;
8611 }
Craig Topper3164f332014-03-11 03:39:26 +00008612 const char *getClobbers() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00008613 return "";
8614 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008615 ArrayRef<const char *> getGCCRegNames() const override {
Robert Lytton0e076492013-08-13 09:43:10 +00008616 static const char * const GCCRegNames[] = {
8617 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
8618 "r8", "r9", "r10", "r11", "cp", "dp", "sp", "lr"
8619 };
Craig Topperf054e3a2015-10-19 03:52:27 +00008620 return llvm::makeArrayRef(GCCRegNames);
Robert Lytton0e076492013-08-13 09:43:10 +00008621 }
Craig Topperf054e3a2015-10-19 03:52:27 +00008622 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
8623 return None;
Robert Lytton0e076492013-08-13 09:43:10 +00008624 }
Craig Topper3164f332014-03-11 03:39:26 +00008625 bool validateAsmConstraint(const char *&Name,
8626 TargetInfo::ConstraintInfo &Info) const override {
Robert Lytton0e076492013-08-13 09:43:10 +00008627 return false;
8628 }
Craig Topper3164f332014-03-11 03:39:26 +00008629 int getEHDataRegisterNumber(unsigned RegNo) const override {
Robert Lytton1a229262014-01-27 17:56:25 +00008630 // R0=ExceptionPointerRegister R1=ExceptionSelectorRegister
8631 return (RegNo < 2)? RegNo : -1;
8632 }
Andrey Turetskiydb6655f2016-02-10 11:58:46 +00008633 bool allowsLargerPreferedTypeAlignment() const override {
8634 return false;
8635 }
Robert Lytton0e076492013-08-13 09:43:10 +00008636};
8637
8638const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
Craig Topper07d3b622015-08-07 05:14:44 +00008639#define BUILTIN(ID, TYPE, ATTRS) \
8640 { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
8641#define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
8642 { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
Robert Lytton0e076492013-08-13 09:43:10 +00008643#include "clang/Basic/BuiltinsXCore.def"
8644};
Robert Lytton0e076492013-08-13 09:43:10 +00008645
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008646// x86_32 Android target
8647class AndroidX86_32TargetInfo : public LinuxTargetInfo<X86_32TargetInfo> {
8648public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008649 AndroidX86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8650 : LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts) {
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008651 SuitableAlign = 32;
8652 LongDoubleWidth = 64;
Stephan Bergmann17c7f702016-12-14 11:57:17 +00008653 LongDoubleFormat = &llvm::APFloat::IEEEdouble();
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008654 }
8655};
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008656
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008657// x86_64 Android target
8658class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> {
8659public:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00008660 AndroidX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
8661 : LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts) {
Stephan Bergmann17c7f702016-12-14 11:57:17 +00008662 LongDoubleFormat = &llvm::APFloat::IEEEquad();
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008663 }
Chih-Hung Hsieh0b0eeaa2015-07-24 18:12:54 +00008664
8665 bool useFloat128ManglingForLongDouble() const override {
8666 return true;
8667 }
Tamas Berghammer6373cee2015-03-25 10:38:50 +00008668};
Pirama Arumuga Nainar54a213d2016-07-02 00:05:42 +00008669
8670// 32-bit RenderScript is armv7 with width and align of 'long' set to 8-bytes
8671class RenderScript32TargetInfo : public ARMleTargetInfo {
8672public:
8673 RenderScript32TargetInfo(const llvm::Triple &Triple,
8674 const TargetOptions &Opts)
8675 : ARMleTargetInfo(llvm::Triple("armv7", Triple.getVendorName(),
8676 Triple.getOSName(),
8677 Triple.getEnvironmentName()),
8678 Opts) {
Pirama Arumuga Nainarbb846a32016-07-27 19:01:51 +00008679 IsRenderScriptTarget = true;
Pirama Arumuga Nainar54a213d2016-07-02 00:05:42 +00008680 LongWidth = LongAlign = 64;
8681 }
8682 void getTargetDefines(const LangOptions &Opts,
8683 MacroBuilder &Builder) const override {
8684 Builder.defineMacro("__RENDERSCRIPT__");
8685 ARMleTargetInfo::getTargetDefines(Opts, Builder);
8686 }
8687};
8688
8689// 64-bit RenderScript is aarch64
8690class RenderScript64TargetInfo : public AArch64leTargetInfo {
8691public:
8692 RenderScript64TargetInfo(const llvm::Triple &Triple,
8693 const TargetOptions &Opts)
8694 : AArch64leTargetInfo(llvm::Triple("aarch64", Triple.getVendorName(),
8695 Triple.getOSName(),
8696 Triple.getEnvironmentName()),
Pirama Arumuga Nainarbb846a32016-07-27 19:01:51 +00008697 Opts) {
8698 IsRenderScriptTarget = true;
8699 }
Pirama Arumuga Nainar54a213d2016-07-02 00:05:42 +00008700
8701 void getTargetDefines(const LangOptions &Opts,
8702 MacroBuilder &Builder) const override {
8703 Builder.defineMacro("__RENDERSCRIPT__");
8704 AArch64leTargetInfo::getTargetDefines(Opts, Builder);
8705 }
8706};
8707
Dylan McKayecb6e7b2017-02-07 06:04:18 +00008708/// Information about a specific microcontroller.
8709struct MCUInfo {
8710 const char *Name;
8711 const char *DefineName;
8712};
8713
8714// This list should be kept up-to-date with AVRDevices.td in LLVM.
8715static ArrayRef<MCUInfo> AVRMcus = {
8716 { "at90s1200", "__AVR_AT90S1200__" },
Dylan McKay315edb02017-02-11 21:06:07 +00008717 { "attiny11", "__AVR_ATtiny11__" },
8718 { "attiny12", "__AVR_ATtiny12__" },
8719 { "attiny15", "__AVR_ATtiny15__" },
8720 { "attiny28", "__AVR_ATtiny28__" },
8721 { "at90s2313", "__AVR_AT90S2313__" },
8722 { "at90s2323", "__AVR_AT90S2323__" },
8723 { "at90s2333", "__AVR_AT90S2333__" },
8724 { "at90s2343", "__AVR_AT90S2343__" },
8725 { "attiny22", "__AVR_ATtiny22__" },
8726 { "attiny26", "__AVR_ATtiny26__" },
8727 { "at86rf401", "__AVR_AT86RF401__" },
8728 { "at90s4414", "__AVR_AT90S4414__" },
8729 { "at90s4433", "__AVR_AT90S4433__" },
8730 { "at90s4434", "__AVR_AT90S4434__" },
8731 { "at90s8515", "__AVR_AT90S8515__" },
8732 { "at90c8534", "__AVR_AT90c8534__" },
8733 { "at90s8535", "__AVR_AT90S8535__" },
8734 { "ata5272", "__AVR_ATA5272__" },
8735 { "attiny13", "__AVR_ATtiny13__" },
8736 { "attiny13a", "__AVR_ATtiny13A__" },
8737 { "attiny2313", "__AVR_ATtiny2313__" },
8738 { "attiny2313a", "__AVR_ATtiny2313A__" },
8739 { "attiny24", "__AVR_ATtiny24__" },
8740 { "attiny24a", "__AVR_ATtiny24A__" },
8741 { "attiny4313", "__AVR_ATtiny4313__" },
8742 { "attiny44", "__AVR_ATtiny44__" },
8743 { "attiny44a", "__AVR_ATtiny44A__" },
8744 { "attiny84", "__AVR_ATtiny84__" },
8745 { "attiny84a", "__AVR_ATtiny84A__" },
8746 { "attiny25", "__AVR_ATtiny25__" },
8747 { "attiny45", "__AVR_ATtiny45__" },
8748 { "attiny85", "__AVR_ATtiny85__" },
8749 { "attiny261", "__AVR_ATtiny261__" },
8750 { "attiny261a", "__AVR_ATtiny261A__" },
8751 { "attiny461", "__AVR_ATtiny461__" },
8752 { "attiny461a", "__AVR_ATtiny461A__" },
8753 { "attiny861", "__AVR_ATtiny861__" },
8754 { "attiny861a", "__AVR_ATtiny861A__" },
8755 { "attiny87", "__AVR_ATtiny87__" },
8756 { "attiny43u", "__AVR_ATtiny43U__" },
8757 { "attiny48", "__AVR_ATtiny48__" },
8758 { "attiny88", "__AVR_ATtiny88__" },
8759 { "attiny828", "__AVR_ATtiny828__" },
8760 { "at43usb355", "__AVR_AT43USB355__" },
8761 { "at76c711", "__AVR_AT76C711__" },
8762 { "atmega103", "__AVR_ATmega103__" },
8763 { "at43usb320", "__AVR_AT43USB320__" },
8764 { "attiny167", "__AVR_ATtiny167__" },
8765 { "at90usb82", "__AVR_AT90USB82__" },
8766 { "at90usb162", "__AVR_AT90USB162__" },
8767 { "ata5505", "__AVR_ATA5505__" },
8768 { "atmega8u2", "__AVR_ATmega8U2__" },
8769 { "atmega16u2", "__AVR_ATmega16U2__" },
8770 { "atmega32u2", "__AVR_ATmega32U2__" },
8771 { "attiny1634", "__AVR_ATtiny1634__" },
8772 { "atmega8", "__AVR_ATmega8__" },
8773 { "ata6289", "__AVR_ATA6289__" },
8774 { "atmega8a", "__AVR_ATmega8A__" },
8775 { "ata6285", "__AVR_ATA6285__" },
8776 { "ata6286", "__AVR_ATA6286__" },
8777 { "atmega48", "__AVR_ATmega48__" },
8778 { "atmega48a", "__AVR_ATmega48A__" },
8779 { "atmega48pa", "__AVR_ATmega48PA__" },
8780 { "atmega48p", "__AVR_ATmega48P__" },
8781 { "atmega88", "__AVR_ATmega88__" },
8782 { "atmega88a", "__AVR_ATmega88A__" },
8783 { "atmega88p", "__AVR_ATmega88P__" },
8784 { "atmega88pa", "__AVR_ATmega88PA__" },
8785 { "atmega8515", "__AVR_ATmega8515__" },
8786 { "atmega8535", "__AVR_ATmega8535__" },
8787 { "atmega8hva", "__AVR_ATmega8HVA__" },
8788 { "at90pwm1", "__AVR_AT90PWM1__" },
8789 { "at90pwm2", "__AVR_AT90PWM2__" },
8790 { "at90pwm2b", "__AVR_AT90PWM2B__" },
8791 { "at90pwm3", "__AVR_AT90PWM3__" },
8792 { "at90pwm3b", "__AVR_AT90PWM3B__" },
8793 { "at90pwm81", "__AVR_AT90PWM81__" },
8794 { "ata5790", "__AVR_ATA5790__" },
8795 { "ata5795", "__AVR_ATA5795__" },
8796 { "atmega16", "__AVR_ATmega16__" },
8797 { "atmega16a", "__AVR_ATmega16A__" },
8798 { "atmega161", "__AVR_ATmega161__" },
8799 { "atmega162", "__AVR_ATmega162__" },
8800 { "atmega163", "__AVR_ATmega163__" },
8801 { "atmega164a", "__AVR_ATmega164A__" },
8802 { "atmega164p", "__AVR_ATmega164P__" },
8803 { "atmega164pa", "__AVR_ATmega164PA__" },
8804 { "atmega165", "__AVR_ATmega165__" },
8805 { "atmega165a", "__AVR_ATmega165A__" },
8806 { "atmega165p", "__AVR_ATmega165P__" },
8807 { "atmega165pa", "__AVR_ATmega165PA__" },
8808 { "atmega168", "__AVR_ATmega168__" },
8809 { "atmega168a", "__AVR_ATmega168A__" },
8810 { "atmega168p", "__AVR_ATmega168P__" },
8811 { "atmega168pa", "__AVR_ATmega168PA__" },
8812 { "atmega169", "__AVR_ATmega169__" },
8813 { "atmega169a", "__AVR_ATmega169A__" },
8814 { "atmega169p", "__AVR_ATmega169P__" },
8815 { "atmega169pa", "__AVR_ATmega169PA__" },
8816 { "atmega32", "__AVR_ATmega32__" },
8817 { "atmega32a", "__AVR_ATmega32A__" },
8818 { "atmega323", "__AVR_ATmega323__" },
8819 { "atmega324a", "__AVR_ATmega324A__" },
8820 { "atmega324p", "__AVR_ATmega324P__" },
8821 { "atmega324pa", "__AVR_ATmega324PA__" },
8822 { "atmega325", "__AVR_ATmega325__" },
8823 { "atmega325a", "__AVR_ATmega325A__" },
8824 { "atmega325p", "__AVR_ATmega325P__" },
8825 { "atmega325pa", "__AVR_ATmega325PA__" },
8826 { "atmega3250", "__AVR_ATmega3250__" },
8827 { "atmega3250a", "__AVR_ATmega3250A__" },
8828 { "atmega3250p", "__AVR_ATmega3250P__" },
8829 { "atmega3250pa", "__AVR_ATmega3250PA__" },
8830 { "atmega328", "__AVR_ATmega328__" },
8831 { "atmega328p", "__AVR_ATmega328P__" },
8832 { "atmega329", "__AVR_ATmega329__" },
8833 { "atmega329a", "__AVR_ATmega329A__" },
8834 { "atmega329p", "__AVR_ATmega329P__" },
8835 { "atmega329pa", "__AVR_ATmega329PA__" },
8836 { "atmega3290", "__AVR_ATmega3290__" },
8837 { "atmega3290a", "__AVR_ATmega3290A__" },
8838 { "atmega3290p", "__AVR_ATmega3290P__" },
8839 { "atmega3290pa", "__AVR_ATmega3290PA__" },
8840 { "atmega406", "__AVR_ATmega406__" },
8841 { "atmega64", "__AVR_ATmega64__" },
8842 { "atmega64a", "__AVR_ATmega64A__" },
8843 { "atmega640", "__AVR_ATmega640__" },
8844 { "atmega644", "__AVR_ATmega644__" },
8845 { "atmega644a", "__AVR_ATmega644A__" },
8846 { "atmega644p", "__AVR_ATmega644P__" },
8847 { "atmega644pa", "__AVR_ATmega644PA__" },
8848 { "atmega645", "__AVR_ATmega645__" },
8849 { "atmega645a", "__AVR_ATmega645A__" },
8850 { "atmega645p", "__AVR_ATmega645P__" },
8851 { "atmega649", "__AVR_ATmega649__" },
8852 { "atmega649a", "__AVR_ATmega649A__" },
8853 { "atmega649p", "__AVR_ATmega649P__" },
8854 { "atmega6450", "__AVR_ATmega6450__" },
8855 { "atmega6450a", "__AVR_ATmega6450A__" },
8856 { "atmega6450p", "__AVR_ATmega6450P__" },
8857 { "atmega6490", "__AVR_ATmega6490__" },
8858 { "atmega6490a", "__AVR_ATmega6490A__" },
8859 { "atmega6490p", "__AVR_ATmega6490P__" },
8860 { "atmega64rfr2", "__AVR_ATmega64RFR2__" },
8861 { "atmega644rfr2", "__AVR_ATmega644RFR2__" },
8862 { "atmega16hva", "__AVR_ATmega16HVA__" },
8863 { "atmega16hva2", "__AVR_ATmega16HVA2__" },
8864 { "atmega16hvb", "__AVR_ATmega16HVB__" },
8865 { "atmega16hvbrevb", "__AVR_ATmega16HVBREVB__" },
8866 { "atmega32hvb", "__AVR_ATmega32HVB__" },
8867 { "atmega32hvbrevb", "__AVR_ATmega32HVBREVB__" },
8868 { "atmega64hve", "__AVR_ATmega64HVE__" },
8869 { "at90can32", "__AVR_AT90CAN32__" },
8870 { "at90can64", "__AVR_AT90CAN64__" },
8871 { "at90pwm161", "__AVR_AT90PWM161__" },
8872 { "at90pwm216", "__AVR_AT90PWM216__" },
8873 { "at90pwm316", "__AVR_AT90PWM316__" },
8874 { "atmega32c1", "__AVR_ATmega32C1__" },
8875 { "atmega64c1", "__AVR_ATmega64C1__" },
8876 { "atmega16m1", "__AVR_ATmega16M1__" },
8877 { "atmega32m1", "__AVR_ATmega32M1__" },
8878 { "atmega64m1", "__AVR_ATmega64M1__" },
8879 { "atmega16u4", "__AVR_ATmega16U4__" },
8880 { "atmega32u4", "__AVR_ATmega32U4__" },
8881 { "atmega32u6", "__AVR_ATmega32U6__" },
8882 { "at90usb646", "__AVR_AT90USB646__" },
8883 { "at90usb647", "__AVR_AT90USB647__" },
8884 { "at90scr100", "__AVR_AT90SCR100__" },
8885 { "at94k", "__AVR_AT94K__" },
8886 { "m3000", "__AVR_AT000__" },
8887 { "atmega128", "__AVR_ATmega128__" },
8888 { "atmega128a", "__AVR_ATmega128A__" },
8889 { "atmega1280", "__AVR_ATmega1280__" },
8890 { "atmega1281", "__AVR_ATmega1281__" },
8891 { "atmega1284", "__AVR_ATmega1284__" },
8892 { "atmega1284p", "__AVR_ATmega1284P__" },
8893 { "atmega128rfa1", "__AVR_ATmega128RFA1__" },
8894 { "atmega128rfr2", "__AVR_ATmega128RFR2__" },
8895 { "atmega1284rfr2", "__AVR_ATmega1284RFR2__" },
8896 { "at90can128", "__AVR_AT90CAN128__" },
8897 { "at90usb1286", "__AVR_AT90USB1286__" },
8898 { "at90usb1287", "__AVR_AT90USB1287__" },
8899 { "atmega2560", "__AVR_ATmega2560__" },
8900 { "atmega2561", "__AVR_ATmega2561__" },
8901 { "atmega256rfr2", "__AVR_ATmega256RFR2__" },
8902 { "atmega2564rfr2", "__AVR_ATmega2564RFR2__" },
8903 { "atxmega16a4", "__AVR_ATxmega16A4__" },
8904 { "atxmega16a4u", "__AVR_ATxmega16a4U__" },
8905 { "atxmega16c4", "__AVR_ATxmega16C4__" },
8906 { "atxmega16d4", "__AVR_ATxmega16D4__" },
8907 { "atxmega32a4", "__AVR_ATxmega32A4__" },
8908 { "atxmega32a4u", "__AVR_ATxmega32A4U__" },
8909 { "atxmega32c4", "__AVR_ATxmega32C4__" },
8910 { "atxmega32d4", "__AVR_ATxmega32D4__" },
8911 { "atxmega32e5", "__AVR_ATxmega32E5__" },
8912 { "atxmega16e5", "__AVR_ATxmega16E5__" },
8913 { "atxmega8e5", "__AVR_ATxmega8E5__" },
8914 { "atxmega32x1", "__AVR_ATxmega32X1__" },
8915 { "atxmega64a3", "__AVR_ATxmega64A3__" },
8916 { "atxmega64a3u", "__AVR_ATxmega64A3U__" },
8917 { "atxmega64a4u", "__AVR_ATxmega64A4U__" },
8918 { "atxmega64b1", "__AVR_ATxmega64B1__" },
8919 { "atxmega64b3", "__AVR_ATxmega64B3__" },
8920 { "atxmega64c3", "__AVR_ATxmega64C3__" },
8921 { "atxmega64d3", "__AVR_ATxmega64D3__" },
8922 { "atxmega64d4", "__AVR_ATxmega64D4__" },
8923 { "atxmega64a1", "__AVR_ATxmega64A1__" },
8924 { "atxmega64a1u", "__AVR_ATxmega64A1U__" },
8925 { "atxmega128a3", "__AVR_ATxmega128A3__" },
8926 { "atxmega128a3u", "__AVR_ATxmega128A3U__" },
8927 { "atxmega128b1", "__AVR_ATxmega128B1__" },
8928 { "atxmega128b3", "__AVR_ATxmega128B3__" },
8929 { "atxmega128c3", "__AVR_ATxmega128C3__" },
8930 { "atxmega128d3", "__AVR_ATxmega128D3__" },
8931 { "atxmega128d4", "__AVR_ATxmega128D4__" },
8932 { "atxmega192a3", "__AVR_ATxmega192A3__" },
8933 { "atxmega192a3u", "__AVR_ATxmega192A3U__" },
8934 { "atxmega192c3", "__AVR_ATxmega192C3__" },
8935 { "atxmega192d3", "__AVR_ATxmega192D3__" },
8936 { "atxmega256a3", "__AVR_ATxmega256A3__" },
8937 { "atxmega256a3u", "__AVR_ATxmega256A3U__" },
8938 { "atxmega256a3b", "__AVR_ATxmega256A3B__" },
8939 { "atxmega256a3bu", "__AVR_ATxmega256A3BU__" },
8940 { "atxmega256c3", "__AVR_ATxmega256C3__" },
8941 { "atxmega256d3", "__AVR_ATxmega256D3__" },
8942 { "atxmega384c3", "__AVR_ATxmega384C3__" },
8943 { "atxmega384d3", "__AVR_ATxmega384D3__" },
8944 { "atxmega128a1", "__AVR_ATxmega128A1__" },
8945 { "atxmega128a1u", "__AVR_ATxmega128A1U__" },
8946 { "atxmega128a4u", "__AVR_ATxmega128a4U__" },
8947 { "attiny4", "__AVR_ATtiny4__" },
8948 { "attiny5", "__AVR_ATtiny5__" },
8949 { "attiny9", "__AVR_ATtiny9__" },
8950 { "attiny10", "__AVR_ATtiny10__" },
8951 { "attiny20", "__AVR_ATtiny20__" },
8952 { "attiny40", "__AVR_ATtiny40__" },
8953 { "attiny102", "__AVR_ATtiny102__" },
8954 { "attiny104", "__AVR_ATtiny104__" },
Dylan McKayecb6e7b2017-02-07 06:04:18 +00008955};
Dylan McKay924fa3a2017-01-05 05:20:27 +00008956
8957// AVR Target
8958class AVRTargetInfo : public TargetInfo {
8959public:
8960 AVRTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
8961 : TargetInfo(Triple) {
8962 TLSSupported = false;
8963 PointerWidth = 16;
8964 PointerAlign = 8;
8965 IntWidth = 16;
8966 IntAlign = 8;
8967 LongWidth = 32;
8968 LongAlign = 8;
8969 LongLongWidth = 64;
8970 LongLongAlign = 8;
8971 SuitableAlign = 8;
8972 DefaultAlignForAttributeAligned = 8;
8973 HalfWidth = 16;
8974 HalfAlign = 8;
8975 FloatWidth = 32;
8976 FloatAlign = 8;
8977 DoubleWidth = 32;
8978 DoubleAlign = 8;
8979 DoubleFormat = &llvm::APFloat::IEEEsingle();
8980 LongDoubleWidth = 32;
8981 LongDoubleAlign = 8;
8982 LongDoubleFormat = &llvm::APFloat::IEEEsingle();
8983 SizeType = UnsignedInt;
8984 PtrDiffType = SignedInt;
8985 IntPtrType = SignedInt;
8986 Char16Type = UnsignedInt;
8987 WCharType = SignedInt;
8988 WIntType = SignedInt;
8989 Char32Type = UnsignedLong;
8990 SigAtomicType = SignedChar;
8991 resetDataLayout("e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
8992 "-f32:32:32-f64:64:64-n8");
8993 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00008994
Dylan McKay924fa3a2017-01-05 05:20:27 +00008995 void getTargetDefines(const LangOptions &Opts,
8996 MacroBuilder &Builder) const override {
Dylan McKayecb6e7b2017-02-07 06:04:18 +00008997 Builder.defineMacro("AVR");
8998 Builder.defineMacro("__AVR");
Dylan McKay924fa3a2017-01-05 05:20:27 +00008999 Builder.defineMacro("__AVR__");
Dylan McKayecb6e7b2017-02-07 06:04:18 +00009000
9001 if (!this->CPU.empty()) {
9002 auto It = std::find_if(AVRMcus.begin(), AVRMcus.end(),
9003 [&](const MCUInfo &Info) { return Info.Name == this->CPU; });
9004
9005 if (It != AVRMcus.end())
9006 Builder.defineMacro(It->DefineName);
9007 }
Dylan McKay924fa3a2017-01-05 05:20:27 +00009008 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009009
Dylan McKay924fa3a2017-01-05 05:20:27 +00009010 ArrayRef<Builtin::Info> getTargetBuiltins() const override {
9011 return None;
9012 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009013
Dylan McKay924fa3a2017-01-05 05:20:27 +00009014 BuiltinVaListKind getBuiltinVaListKind() const override {
9015 return TargetInfo::VoidPtrBuiltinVaList;
9016 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009017
Dylan McKay924fa3a2017-01-05 05:20:27 +00009018 const char *getClobbers() const override {
9019 return "";
9020 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009021
Dylan McKay924fa3a2017-01-05 05:20:27 +00009022 ArrayRef<const char *> getGCCRegNames() const override {
9023 static const char * const GCCRegNames[] = {
9024 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
9025 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
9026 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
Dylan McKay95aa2652017-01-05 07:17:46 +00009027 "r24", "r25", "X", "Y", "Z", "SP"
Dylan McKay924fa3a2017-01-05 05:20:27 +00009028 };
9029 return llvm::makeArrayRef(GCCRegNames);
9030 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009031
Dylan McKay924fa3a2017-01-05 05:20:27 +00009032 ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
9033 return None;
9034 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009035
Dylan McKay924fa3a2017-01-05 05:20:27 +00009036 ArrayRef<TargetInfo::AddlRegName> getGCCAddlRegNames() const override {
9037 static const TargetInfo::AddlRegName AddlRegNames[] = {
9038 { { "r26", "r27"}, 26 },
9039 { { "r28", "r29"}, 27 },
9040 { { "r30", "r31"}, 28 },
9041 { { "SPL", "SPH"}, 29 },
9042 };
9043 return llvm::makeArrayRef(AddlRegNames);
9044 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009045
Dylan McKay924fa3a2017-01-05 05:20:27 +00009046 bool validateAsmConstraint(const char *&Name,
9047 TargetInfo::ConstraintInfo &Info) const override {
Dylan McKayd31534c2017-02-06 09:01:59 +00009048 // There aren't any multi-character AVR specific constraints.
9049 if (StringRef(Name).size() > 1) return false;
9050
9051 switch (*Name) {
9052 default: return false;
9053 case 'a': // Simple upper registers
9054 case 'b': // Base pointer registers pairs
9055 case 'd': // Upper register
9056 case 'l': // Lower registers
9057 case 'e': // Pointer register pairs
9058 case 'q': // Stack pointer register
9059 case 'r': // Any register
9060 case 'w': // Special upper register pairs
9061 case 't': // Temporary register
9062 case 'x': case 'X': // Pointer register pair X
9063 case 'y': case 'Y': // Pointer register pair Y
9064 case 'z': case 'Z': // Pointer register pair Z
9065 Info.setAllowsRegister();
9066 return true;
9067 case 'I': // 6-bit positive integer constant
9068 Info.setRequiresImmediate(0, 63);
9069 return true;
9070 case 'J': // 6-bit negative integer constant
9071 Info.setRequiresImmediate(-63, 0);
9072 return true;
9073 case 'K': // Integer constant (Range: 2)
9074 Info.setRequiresImmediate(2);
9075 return true;
9076 case 'L': // Integer constant (Range: 0)
9077 Info.setRequiresImmediate(0);
9078 return true;
9079 case 'M': // 8-bit integer constant
9080 Info.setRequiresImmediate(0, 0xff);
9081 return true;
9082 case 'N': // Integer constant (Range: -1)
9083 Info.setRequiresImmediate(-1);
9084 return true;
9085 case 'O': // Integer constant (Range: 8, 16, 24)
9086 Info.setRequiresImmediate({8, 16, 24});
9087 return true;
9088 case 'P': // Integer constant (Range: 1)
9089 Info.setRequiresImmediate(1);
9090 return true;
9091 case 'R': // Integer constant (Range: -6 to 5)
9092 Info.setRequiresImmediate(-6, 5);
9093 return true;
9094 case 'G': // Floating point constant
9095 case 'Q': // A memory address based on Y or Z pointer with displacement.
9096 return true;
9097 }
9098
Dylan McKay924fa3a2017-01-05 05:20:27 +00009099 return false;
9100 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009101
Dylan McKay924fa3a2017-01-05 05:20:27 +00009102 IntType getIntTypeByWidth(unsigned BitWidth,
9103 bool IsSigned) const final {
9104 // AVR prefers int for 16-bit integers.
9105 return BitWidth == 16 ? (IsSigned ? SignedInt : UnsignedInt)
9106 : TargetInfo::getIntTypeByWidth(BitWidth, IsSigned);
9107 }
Dylan McKayf0f33a82017-01-05 05:31:12 +00009108
Dylan McKay924fa3a2017-01-05 05:20:27 +00009109 IntType getLeastIntTypeByWidth(unsigned BitWidth,
9110 bool IsSigned) const final {
9111 // AVR uses int for int_least16_t and int_fast16_t.
9112 return BitWidth == 16
9113 ? (IsSigned ? SignedInt : UnsignedInt)
9114 : TargetInfo::getLeastIntTypeByWidth(BitWidth, IsSigned);
9115 }
Dylan McKayecb6e7b2017-02-07 06:04:18 +00009116
9117 bool setCPU(const std::string &Name) override {
9118 bool IsFamily = llvm::StringSwitch<bool>(Name)
9119 .Case("avr1", true)
9120 .Case("avr2", true)
9121 .Case("avr25", true)
9122 .Case("avr3", true)
9123 .Case("avr31", true)
9124 .Case("avr35", true)
9125 .Case("avr4", true)
9126 .Case("avr5", true)
9127 .Case("avr51", true)
9128 .Case("avr6", true)
9129 .Case("avrxmega1", true)
9130 .Case("avrxmega2", true)
9131 .Case("avrxmega3", true)
9132 .Case("avrxmega4", true)
9133 .Case("avrxmega5", true)
9134 .Case("avrxmega6", true)
9135 .Case("avrxmega7", true)
9136 .Case("avrtiny", true)
9137 .Default(false);
9138
9139 if (IsFamily) this->CPU = Name;
9140
9141 bool IsMCU = std::find_if(AVRMcus.begin(), AVRMcus.end(),
9142 [&](const MCUInfo &Info) { return Info.Name == Name; }) != AVRMcus.end();
9143
9144 if (IsMCU) this->CPU = Name;
9145
9146 return IsFamily || IsMCU;
9147 }
9148
9149protected:
9150 std::string CPU;
Dylan McKay924fa3a2017-01-05 05:20:27 +00009151};
9152
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009153} // end anonymous namespace
9154
Chris Lattner5ba61f02006-10-14 07:39:34 +00009155//===----------------------------------------------------------------------===//
9156// Driver code
9157//===----------------------------------------------------------------------===//
9158
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009159static TargetInfo *AllocateTarget(const llvm::Triple &Triple,
9160 const TargetOptions &Opts) {
Daniel Dunbar52322032009-08-18 05:47:58 +00009161 llvm::Triple::OSType os = Triple.getOS();
Eli Friedmanb5366062008-05-20 14:21:01 +00009162
Daniel Dunbar52322032009-08-18 05:47:58 +00009163 switch (Triple.getArch()) {
9164 default:
Craig Topperf1186c52014-05-08 06:41:40 +00009165 return nullptr;
Eli Friedmanb5366062008-05-20 14:21:01 +00009166
Tim Northover2a0783d2014-05-30 14:14:07 +00009167 case llvm::Triple::xcore:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009168 return new XCoreTargetInfo(Triple, Opts);
Tim Northover2a0783d2014-05-30 14:14:07 +00009169
9170 case llvm::Triple::hexagon:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009171 return new HexagonTargetInfo(Triple, Opts);
Tim Northover2a0783d2014-05-30 14:14:07 +00009172
Jacques Pienaard964cc22016-03-28 21:02:54 +00009173 case llvm::Triple::lanai:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009174 return new LanaiTargetInfo(Triple, Opts);
Jacques Pienaard964cc22016-03-28 21:02:54 +00009175
Tim Northover2a0783d2014-05-30 14:14:07 +00009176 case llvm::Triple::aarch64:
Tim Northovera2ee4332014-03-29 15:09:45 +00009177 if (Triple.isOSDarwin())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009178 return new DarwinAArch64TargetInfo(Triple, Opts);
Tim Northovera2ee4332014-03-29 15:09:45 +00009179
9180 switch (os) {
Ed Schoutenea9448e2015-10-15 15:07:07 +00009181 case llvm::Triple::CloudABI:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009182 return new CloudABITargetInfo<AArch64leTargetInfo>(Triple, Opts);
Ed Maste6a9eda52014-11-13 16:55:42 +00009183 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009184 return new FreeBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
Petr Hosek9834fcd2016-10-24 22:55:57 +00009185 case llvm::Triple::Fuchsia:
9186 return new FuchsiaTargetInfo<AArch64leTargetInfo>(Triple, Opts);
Tim Northovera2ee4332014-03-29 15:09:45 +00009187 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009188 return new LinuxTargetInfo<AArch64leTargetInfo>(Triple, Opts);
James Molloy5e73df52014-04-16 15:06:20 +00009189 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009190 return new NetBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
Brad Smith9aa2bf22017-02-21 23:13:09 +00009191 case llvm::Triple::OpenBSD:
9192 return new OpenBSDTargetInfo<AArch64leTargetInfo>(Triple, Opts);
Tim Northovera2ee4332014-03-29 15:09:45 +00009193 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009194 return new AArch64leTargetInfo(Triple, Opts);
James Molloy5e73df52014-04-16 15:06:20 +00009195 }
9196
Christian Pirker9b019ae2014-02-25 13:51:00 +00009197 case llvm::Triple::aarch64_be:
9198 switch (os) {
Ed Maste6a9eda52014-11-13 16:55:42 +00009199 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009200 return new FreeBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
Petr Hosek9834fcd2016-10-24 22:55:57 +00009201 case llvm::Triple::Fuchsia:
9202 return new FuchsiaTargetInfo<AArch64beTargetInfo>(Triple, Opts);
Christian Pirker9b019ae2014-02-25 13:51:00 +00009203 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009204 return new LinuxTargetInfo<AArch64beTargetInfo>(Triple, Opts);
Christian Pirker9b019ae2014-02-25 13:51:00 +00009205 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009206 return new NetBSDTargetInfo<AArch64beTargetInfo>(Triple, Opts);
Christian Pirker9b019ae2014-02-25 13:51:00 +00009207 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009208 return new AArch64beTargetInfo(Triple, Opts);
Tim Northover9bb857a2013-01-31 12:13:10 +00009209 }
9210
Daniel Dunbar52322032009-08-18 05:47:58 +00009211 case llvm::Triple::arm:
Daniel Dunbar33a004e2009-09-11 01:14:50 +00009212 case llvm::Triple::thumb:
Tim Northover157d9112014-01-16 08:48:16 +00009213 if (Triple.isOSBinFormatMachO())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009214 return new DarwinARMTargetInfo(Triple, Opts);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009215
Daniel Dunbar52322032009-08-18 05:47:58 +00009216 switch (os) {
Ed Schoutenc6d1a732016-09-05 18:38:34 +00009217 case llvm::Triple::CloudABI:
9218 return new CloudABITargetInfo<ARMleTargetInfo>(Triple, Opts);
Rafael Espindolaad8fed52010-06-10 00:46:51 +00009219 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009220 return new LinuxTargetInfo<ARMleTargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009221 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009222 return new FreeBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009223 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009224 return new NetBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
Hans Wennborg0bb84622012-08-02 13:45:48 +00009225 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009226 return new OpenBSDTargetInfo<ARMleTargetInfo>(Triple, Opts);
Eli Friedman9fa28852012-08-08 23:57:20 +00009227 case llvm::Triple::Bitrig:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009228 return new BitrigTargetInfo<ARMleTargetInfo>(Triple, Opts);
Douglas Gregor9fabd852011-07-01 22:41:14 +00009229 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009230 return new RTEMSTargetInfo<ARMleTargetInfo>(Triple, Opts);
Eli Benderskyd7c92032012-12-04 18:38:10 +00009231 case llvm::Triple::NaCl:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009232 return new NaClTargetInfo<ARMleTargetInfo>(Triple, Opts);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00009233 case llvm::Triple::Win32:
9234 switch (Triple.getEnvironment()) {
Yaron Keren321249c2015-07-15 13:32:23 +00009235 case llvm::Triple::Cygnus:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009236 return new CygwinARMTargetInfo(Triple, Opts);
Yaron Keren321249c2015-07-15 13:32:23 +00009237 case llvm::Triple::GNU:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009238 return new MinGWARMTargetInfo(Triple, Opts);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00009239 case llvm::Triple::Itanium:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009240 return new ItaniumWindowsARMleTargetInfo(Triple, Opts);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00009241 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00009242 default: // Assume MSVC for unknown environments
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009243 return new MicrosoftARMleTargetInfo(Triple, Opts);
Saleem Abdulrasoolf4c9e492014-04-04 20:31:19 +00009244 }
Daniel Dunbar52322032009-08-18 05:47:58 +00009245 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009246 return new ARMleTargetInfo(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009247 }
9248
9249 case llvm::Triple::armeb:
9250 case llvm::Triple::thumbeb:
9251 if (Triple.isOSDarwin())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009252 return new DarwinARMTargetInfo(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009253
9254 switch (os) {
9255 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009256 return new LinuxTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009257 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009258 return new FreeBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009259 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009260 return new NetBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009261 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009262 return new OpenBSDTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009263 case llvm::Triple::Bitrig:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009264 return new BitrigTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009265 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009266 return new RTEMSTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009267 case llvm::Triple::NaCl:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009268 return new NaClTargetInfo<ARMbeTargetInfo>(Triple, Opts);
Christian Pirkerf01cd6f2014-03-28 14:40:46 +00009269 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009270 return new ARMbeTargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009271 }
Eli Friedmanb5366062008-05-20 14:21:01 +00009272
Dylan McKay924fa3a2017-01-05 05:20:27 +00009273 case llvm::Triple::avr:
9274 return new AVRTargetInfo(Triple, Opts);
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00009275 case llvm::Triple::bpfeb:
9276 case llvm::Triple::bpfel:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009277 return new BPFTargetInfo(Triple, Opts);
Alexei Starovoitovf657ca82015-06-10 22:59:13 +00009278
Daniel Dunbar52322032009-08-18 05:47:58 +00009279 case llvm::Triple::msp430:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009280 return new MSP430TargetInfo(Triple, Opts);
Eli Friedmanb5366062008-05-20 14:21:01 +00009281
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00009282 case llvm::Triple::mips:
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009283 switch (os) {
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009284 case llvm::Triple::Linux:
Daniel Sanders4672af62016-05-27 11:51:02 +00009285 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009286 case llvm::Triple::RTEMS:
Daniel Sanders4672af62016-05-27 11:51:02 +00009287 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009288 case llvm::Triple::FreeBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009289 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009290 case llvm::Triple::NetBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009291 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009292 default:
Daniel Sanders4672af62016-05-27 11:51:02 +00009293 return new MipsTargetInfo(Triple, Opts);
Joerg Sonnenbergerd60cccf2011-07-05 18:05:54 +00009294 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00009295
9296 case llvm::Triple::mipsel:
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009297 switch (os) {
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009298 case llvm::Triple::Linux:
Daniel Sanders4672af62016-05-27 11:51:02 +00009299 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009300 case llvm::Triple::RTEMS:
Daniel Sanders4672af62016-05-27 11:51:02 +00009301 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009302 case llvm::Triple::FreeBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009303 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009304 case llvm::Triple::NetBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009305 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Petar Jovanovicc19a2842013-09-21 01:27:01 +00009306 case llvm::Triple::NaCl:
Daniel Sanders4672af62016-05-27 11:51:02 +00009307 return new NaClTargetInfo<NaClMips32TargetInfo>(Triple, Opts);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009308 default:
Daniel Sanders4672af62016-05-27 11:51:02 +00009309 return new MipsTargetInfo(Triple, Opts);
Joerg Sonnenberger8360e522011-07-05 18:24:04 +00009310 }
Edward O'Callaghane9a58b12009-11-15 10:22:07 +00009311
Akira Hatanakabef17452011-09-20 19:21:49 +00009312 case llvm::Triple::mips64:
9313 switch (os) {
9314 case llvm::Triple::Linux:
Daniel Sanders4672af62016-05-27 11:51:02 +00009315 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009316 case llvm::Triple::RTEMS:
Daniel Sanders4672af62016-05-27 11:51:02 +00009317 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009318 case llvm::Triple::FreeBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009319 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009320 case llvm::Triple::NetBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009321 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Hans Wennborg0bb84622012-08-02 13:45:48 +00009322 case llvm::Triple::OpenBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009323 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009324 default:
Daniel Sanders4672af62016-05-27 11:51:02 +00009325 return new MipsTargetInfo(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009326 }
9327
9328 case llvm::Triple::mips64el:
9329 switch (os) {
9330 case llvm::Triple::Linux:
Daniel Sanders4672af62016-05-27 11:51:02 +00009331 return new LinuxTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009332 case llvm::Triple::RTEMS:
Daniel Sanders4672af62016-05-27 11:51:02 +00009333 return new RTEMSTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009334 case llvm::Triple::FreeBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009335 return new FreeBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009336 case llvm::Triple::NetBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009337 return new NetBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Hans Wennborg0bb84622012-08-02 13:45:48 +00009338 case llvm::Triple::OpenBSD:
Daniel Sanders4672af62016-05-27 11:51:02 +00009339 return new OpenBSDTargetInfo<MipsTargetInfo>(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009340 default:
Daniel Sanders4672af62016-05-27 11:51:02 +00009341 return new MipsTargetInfo(Triple, Opts);
Akira Hatanakabef17452011-09-20 19:21:49 +00009342 }
9343
Ivan Krasindd7403e2011-08-24 20:22:22 +00009344 case llvm::Triple::le32:
9345 switch (os) {
Douglas Katzman78d7c542015-05-12 21:18:10 +00009346 case llvm::Triple::NaCl:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009347 return new NaClTargetInfo<PNaClTargetInfo>(Triple, Opts);
Douglas Katzman78d7c542015-05-12 21:18:10 +00009348 default:
9349 return nullptr;
Ivan Krasindd7403e2011-08-24 20:22:22 +00009350 }
9351
JF Bastien643817d2014-09-12 17:52:47 +00009352 case llvm::Triple::le64:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009353 return new Le64TargetInfo(Triple, Opts);
JF Bastien643817d2014-09-12 17:52:47 +00009354
Daniel Dunbar52322032009-08-18 05:47:58 +00009355 case llvm::Triple::ppc:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009356 if (Triple.isOSDarwin())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009357 return new DarwinPPC32TargetInfo(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009358 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00009359 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009360 return new LinuxTargetInfo<PPC32TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009361 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009362 return new FreeBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009363 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009364 return new NetBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
Hans Wennborg0bb84622012-08-02 13:45:48 +00009365 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009366 return new OpenBSDTargetInfo<PPC32TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009367 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009368 return new RTEMSTargetInfo<PPC32TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009369 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009370 return new PPC32TargetInfo(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009371 }
Daniel Dunbar52322032009-08-18 05:47:58 +00009372
9373 case llvm::Triple::ppc64:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009374 if (Triple.isOSDarwin())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009375 return new DarwinPPC64TargetInfo(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009376 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00009377 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009378 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009379 case llvm::Triple::Lv2:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009380 return new PS3PPUTargetInfo<PPC64TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009381 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009382 return new FreeBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009383 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009384 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009385 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009386 return new PPC64TargetInfo(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009387 }
Daniel Dunbar52322032009-08-18 05:47:58 +00009388
Bill Schmidt778d3872013-07-26 01:36:11 +00009389 case llvm::Triple::ppc64le:
9390 switch (os) {
9391 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009392 return new LinuxTargetInfo<PPC64TargetInfo>(Triple, Opts);
Joerg Sonnenberger22a2d992015-04-10 20:53:48 +00009393 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009394 return new NetBSDTargetInfo<PPC64TargetInfo>(Triple, Opts);
Bill Schmidt778d3872013-07-26 01:36:11 +00009395 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009396 return new PPC64TargetInfo(Triple, Opts);
Bill Schmidt778d3872013-07-26 01:36:11 +00009397 }
9398
Peter Collingbournec947aae2012-05-20 23:28:41 +00009399 case llvm::Triple::nvptx:
Justin Lebarb6626592017-01-05 16:53:21 +00009400 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/32);
Peter Collingbournec947aae2012-05-20 23:28:41 +00009401 case llvm::Triple::nvptx64:
Justin Lebarb6626592017-01-05 16:53:21 +00009402 return new NVPTXTargetInfo(Triple, Opts, /*TargetPointerWidth=*/64);
Peter Collingbournec947aae2012-05-20 23:28:41 +00009403
Tom Stellardd8e38a32015-01-06 20:34:47 +00009404 case llvm::Triple::amdgcn:
Eli Friedmand13b41e2012-10-12 23:32:00 +00009405 case llvm::Triple::r600:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009406 return new AMDGPUTargetInfo(Triple, Opts);
Eli Friedmand13b41e2012-10-12 23:32:00 +00009407
Daniel Dunbar52322032009-08-18 05:47:58 +00009408 case llvm::Triple::sparc:
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009409 switch (os) {
Anton Korobeynikov804dd052011-10-12 09:30:58 +00009410 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009411 return new LinuxTargetInfo<SparcV8TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009412 case llvm::Triple::Solaris:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009413 return new SolarisTargetInfo<SparcV8TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009414 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009415 return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
Hans Wennborg0bb84622012-08-02 13:45:48 +00009416 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009417 return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009418 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009419 return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009420 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009421 return new SparcV8TargetInfo(Triple, Opts);
Joerg Sonnenberger025949c2011-07-04 21:59:44 +00009422 }
Daniel Dunbar52322032009-08-18 05:47:58 +00009423
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009424 // The 'sparcel' architecture copies all the above cases except for Solaris.
9425 case llvm::Triple::sparcel:
9426 switch (os) {
9427 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009428 return new LinuxTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009429 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009430 return new NetBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009431 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009432 return new OpenBSDTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009433 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009434 return new RTEMSTargetInfo<SparcV8elTargetInfo>(Triple, Opts);
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009435 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009436 return new SparcV8elTargetInfo(Triple, Opts);
Douglas Katzmanf36dddf2015-05-11 15:21:44 +00009437 }
9438
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009439 case llvm::Triple::sparcv9:
9440 switch (os) {
9441 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009442 return new LinuxTargetInfo<SparcV9TargetInfo>(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009443 case llvm::Triple::Solaris:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009444 return new SolarisTargetInfo<SparcV9TargetInfo>(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009445 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009446 return new NetBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009447 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009448 return new OpenBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009449 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009450 return new FreeBSDTargetInfo<SparcV9TargetInfo>(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009451 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009452 return new SparcV9TargetInfo(Triple, Opts);
Jakob Stoklund Olesen4dda1522013-04-16 15:17:49 +00009453 }
9454
Ulrich Weigand47445072013-05-06 16:26:41 +00009455 case llvm::Triple::systemz:
9456 switch (os) {
9457 case llvm::Triple::Linux:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009458 return new LinuxTargetInfo<SystemZTargetInfo>(Triple, Opts);
Ulrich Weigand47445072013-05-06 16:26:41 +00009459 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009460 return new SystemZTargetInfo(Triple, Opts);
Ulrich Weigand47445072013-05-06 16:26:41 +00009461 }
9462
Eli Friedmana9c3d712009-08-19 20:47:07 +00009463 case llvm::Triple::tce:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009464 return new TCETargetInfo(Triple, Opts);
Eli Friedmana9c3d712009-08-19 20:47:07 +00009465
Pekka Jaaskelainen67354482016-11-16 15:22:31 +00009466 case llvm::Triple::tcele:
9467 return new TCELETargetInfo(Triple, Opts);
9468
Daniel Dunbar52322032009-08-18 05:47:58 +00009469 case llvm::Triple::x86:
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009470 if (Triple.isOSDarwin())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009471 return new DarwinI386TargetInfo(Triple, Opts);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009472
Daniel Dunbar52322032009-08-18 05:47:58 +00009473 switch (os) {
Ed Schouten7893e682015-06-13 21:33:49 +00009474 case llvm::Triple::CloudABI:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009475 return new CloudABITargetInfo<X86_32TargetInfo>(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009476 case llvm::Triple::Linux: {
9477 switch (Triple.getEnvironment()) {
9478 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009479 return new LinuxTargetInfo<X86_32TargetInfo>(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009480 case llvm::Triple::Android:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009481 return new AndroidX86_32TargetInfo(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009482 }
9483 }
Daniel Dunbar52322032009-08-18 05:47:58 +00009484 case llvm::Triple::DragonFly:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009485 return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009486 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009487 return new NetBSDI386TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009488 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009489 return new OpenBSDI386TargetInfo(Triple, Opts);
Eli Friedman9fa28852012-08-08 23:57:20 +00009490 case llvm::Triple::Bitrig:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009491 return new BitrigI386TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009492 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009493 return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00009494 case llvm::Triple::KFreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009495 return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple, Opts);
Chris Lattner3e2ee142010-07-07 16:01:42 +00009496 case llvm::Triple::Minix:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009497 return new MinixTargetInfo<X86_32TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009498 case llvm::Triple::Solaris:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009499 return new SolarisTargetInfo<X86_32TargetInfo>(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009500 case llvm::Triple::Win32: {
9501 switch (Triple.getEnvironment()) {
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009502 case llvm::Triple::Cygnus:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009503 return new CygwinX86_32TargetInfo(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009504 case llvm::Triple::GNU:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009505 return new MinGWX86_32TargetInfo(Triple, Opts);
Saleem Abdulrasool24bd7da2014-06-28 23:34:11 +00009506 case llvm::Triple::Itanium:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009507 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00009508 default: // Assume MSVC for unknown environments
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009509 return new MicrosoftX86_32TargetInfo(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009510 }
9511 }
Chris Lattnerb986aba2010-04-11 19:29:39 +00009512 case llvm::Triple::Haiku:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009513 return new HaikuX86_32TargetInfo(Triple, Opts);
Douglas Gregor9fabd852011-07-01 22:41:14 +00009514 case llvm::Triple::RTEMS:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009515 return new RTEMSX86_32TargetInfo(Triple, Opts);
Eli Benderskyd7c92032012-12-04 18:38:10 +00009516 case llvm::Triple::NaCl:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009517 return new NaClTargetInfo<X86_32TargetInfo>(Triple, Opts);
Alexey Bataevc99b0492015-11-25 09:24:26 +00009518 case llvm::Triple::ELFIAMCU:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009519 return new MCUX86_32TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009520 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009521 return new X86_32TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009522 }
9523
9524 case llvm::Triple::x86_64:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009525 if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009526 return new DarwinX86_64TargetInfo(Triple, Opts);
Daniel Dunbar14ad22f2011-04-19 21:43:27 +00009527
Daniel Dunbar52322032009-08-18 05:47:58 +00009528 switch (os) {
Ed Schoutenf33c6072015-03-11 08:42:46 +00009529 case llvm::Triple::CloudABI:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009530 return new CloudABITargetInfo<X86_64TargetInfo>(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009531 case llvm::Triple::Linux: {
9532 switch (Triple.getEnvironment()) {
9533 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009534 return new LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009535 case llvm::Triple::Android:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009536 return new AndroidX86_64TargetInfo(Triple, Opts);
Tamas Berghammer6373cee2015-03-25 10:38:50 +00009537 }
9538 }
Chris Lattner002ba6b2010-01-09 05:41:14 +00009539 case llvm::Triple::DragonFly:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009540 return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009541 case llvm::Triple::NetBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009542 return new NetBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009543 case llvm::Triple::OpenBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009544 return new OpenBSDX86_64TargetInfo(Triple, Opts);
Eli Friedman9fa28852012-08-08 23:57:20 +00009545 case llvm::Triple::Bitrig:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009546 return new BitrigX86_64TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009547 case llvm::Triple::FreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009548 return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
Petr Hosek9834fcd2016-10-24 22:55:57 +00009549 case llvm::Triple::Fuchsia:
9550 return new FuchsiaTargetInfo<X86_64TargetInfo>(Triple, Opts);
Sylvestre Ledru4afe74a2013-09-05 13:47:07 +00009551 case llvm::Triple::KFreeBSD:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009552 return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009553 case llvm::Triple::Solaris:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009554 return new SolarisTargetInfo<X86_64TargetInfo>(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009555 case llvm::Triple::Win32: {
9556 switch (Triple.getEnvironment()) {
Yaron Kerend030d112015-07-22 17:38:19 +00009557 case llvm::Triple::Cygnus:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009558 return new CygwinX86_64TargetInfo(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009559 case llvm::Triple::GNU:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009560 return new MinGWX86_64TargetInfo(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009561 case llvm::Triple::MSVC:
Saleem Abdulrasool94f49512015-07-17 21:26:41 +00009562 default: // Assume MSVC for unknown environments
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009563 return new MicrosoftX86_64TargetInfo(Triple, Opts);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00009564 }
9565 }
Reid Kleckner330fb172016-05-11 16:19:05 +00009566 case llvm::Triple::Haiku:
9567 return new HaikuTargetInfo<X86_64TargetInfo>(Triple, Opts);
Eli Benderskyd7c92032012-12-04 18:38:10 +00009568 case llvm::Triple::NaCl:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009569 return new NaClTargetInfo<X86_64TargetInfo>(Triple, Opts);
Alex Rosenberg12207fa2015-01-27 14:47:44 +00009570 case llvm::Triple::PS4:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009571 return new PS4OSTargetInfo<X86_64TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009572 default:
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009573 return new X86_64TargetInfo(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009574 }
Guy Benyeib798fc92012-12-11 21:38:14 +00009575
Douglas Katzman78d7c542015-05-12 21:18:10 +00009576 case llvm::Triple::spir: {
9577 if (Triple.getOS() != llvm::Triple::UnknownOS ||
9578 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
9579 return nullptr;
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009580 return new SPIR32TargetInfo(Triple, Opts);
Douglas Katzman78d7c542015-05-12 21:18:10 +00009581 }
9582 case llvm::Triple::spir64: {
9583 if (Triple.getOS() != llvm::Triple::UnknownOS ||
9584 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment)
9585 return nullptr;
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009586 return new SPIR64TargetInfo(Triple, Opts);
Douglas Katzman78d7c542015-05-12 21:18:10 +00009587 }
Dan Gohmanc2853072015-09-03 22:51:53 +00009588 case llvm::Triple::wasm32:
Dan Gohman839f2152017-01-17 21:46:38 +00009589 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
9590 Triple.getVendor() != llvm::Triple::UnknownVendor ||
9591 Triple.getOS() != llvm::Triple::UnknownOS ||
9592 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment ||
9593 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm()))
Dan Gohmanc2853072015-09-03 22:51:53 +00009594 return nullptr;
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009595 return new WebAssemblyOSTargetInfo<WebAssembly32TargetInfo>(Triple, Opts);
Dan Gohmanc2853072015-09-03 22:51:53 +00009596 case llvm::Triple::wasm64:
Dan Gohman839f2152017-01-17 21:46:38 +00009597 if (Triple.getSubArch() != llvm::Triple::NoSubArch ||
9598 Triple.getVendor() != llvm::Triple::UnknownVendor ||
9599 Triple.getOS() != llvm::Triple::UnknownOS ||
9600 Triple.getEnvironment() != llvm::Triple::UnknownEnvironment ||
9601 !(Triple.isOSBinFormatELF() || Triple.isOSBinFormatWasm()))
Dan Gohmanc2853072015-09-03 22:51:53 +00009602 return nullptr;
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009603 return new WebAssemblyOSTargetInfo<WebAssembly64TargetInfo>(Triple, Opts);
Pirama Arumuga Nainar54a213d2016-07-02 00:05:42 +00009604
9605 case llvm::Triple::renderscript32:
9606 return new LinuxTargetInfo<RenderScript32TargetInfo>(Triple, Opts);
9607 case llvm::Triple::renderscript64:
9608 return new LinuxTargetInfo<RenderScript64TargetInfo>(Triple, Opts);
Daniel Dunbar52322032009-08-18 05:47:58 +00009609 }
Chris Lattner5ba61f02006-10-14 07:39:34 +00009610}
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009611
9612/// CreateTargetInfo - Return the target info object for the specified target
Eric Christophere4f73b32015-08-07 19:07:08 +00009613/// options.
Alp Toker80758082014-07-06 05:26:44 +00009614TargetInfo *
9615TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
Saleem Abdulrasool10a49722016-04-08 16:52:00 +00009616 const std::shared_ptr<TargetOptions> &Opts) {
Douglas Gregorf8715de2012-11-16 04:24:59 +00009617 llvm::Triple Triple(Opts->Triple);
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009618
9619 // Construct the target
Saleem Abdulrasoole86dd022016-04-09 19:09:25 +00009620 std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009621 if (!Target) {
9622 Diags.Report(diag::err_target_unknown_triple) << Triple.str();
Craig Topperf1186c52014-05-08 06:41:40 +00009623 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009624 }
Alp Toker80758082014-07-06 05:26:44 +00009625 Target->TargetOpts = Opts;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009626
Daniel Dunbaracde99e2009-12-18 18:42:37 +00009627 // Set the target CPU if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00009628 if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
9629 Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
Craig Topperf1186c52014-05-08 06:41:40 +00009630 return nullptr;
Daniel Dunbaracde99e2009-12-18 18:42:37 +00009631 }
9632
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009633 // Set the target ABI if specified.
Douglas Gregorf8715de2012-11-16 04:24:59 +00009634 if (!Opts->ABI.empty() && !Target->setABI(Opts->ABI)) {
9635 Diags.Report(diag::err_target_unknown_abi) << Opts->ABI;
Craig Topperf1186c52014-05-08 06:41:40 +00009636 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009637 }
9638
Rafael Espindolaeb265472013-08-21 21:59:03 +00009639 // Set the fp math unit.
9640 if (!Opts->FPMath.empty() && !Target->setFPMath(Opts->FPMath)) {
9641 Diags.Report(diag::err_target_unknown_fpmath) << Opts->FPMath;
Craig Topperf1186c52014-05-08 06:41:40 +00009642 return nullptr;
Rafael Espindolaeb265472013-08-21 21:59:03 +00009643 }
9644
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009645 // Compute the default target features, we need the target to handle this
9646 // because features may have dependencies on one another.
9647 llvm::StringMap<bool> Features;
Eric Christopher007b0a02015-08-28 22:32:01 +00009648 if (!Target->initFeatureMap(Features, Diags, Opts->CPU,
9649 Opts->FeaturesAsWritten))
Eric Christopher6b454372015-08-25 13:45:24 +00009650 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009651
9652 // Add the features to the compile options.
Douglas Gregorf8715de2012-11-16 04:24:59 +00009653 Opts->Features.clear();
Aaron Ballmanb226d3d2015-08-12 13:38:59 +00009654 for (const auto &F : Features)
9655 Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
9656
Eric Christopher3ff21b32013-10-16 21:26:26 +00009657 if (!Target->handleTargetFeatures(Opts->Features, Diags))
Craig Topperf1186c52014-05-08 06:41:40 +00009658 return nullptr;
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009659
Yaxun Liu39cf40f2016-05-16 17:06:34 +00009660 Target->setSupportedOpenCLOpts();
Alexey Bader0ea07532016-11-01 15:50:52 +00009661 Target->setOpenCLExtensionOpts();
Yaxun Liu39cf40f2016-05-16 17:06:34 +00009662
Daniel Sanders32b2d6b2016-06-14 08:58:50 +00009663 if (!Target->validateTarget(Diags))
9664 return nullptr;
9665
Ahmed Charles9a16beb2014-03-07 19:33:25 +00009666 return Target.release();
Daniel Dunbarb9bbd542009-11-15 06:48:46 +00009667}